chore: update validation script output

wu-clan · wu-clan · commit fc9df052fe26 · 2026-03-07T16:27:43.000+08:00
diff --git a/.github/workflows/validate-plugin-toml.yml b/.github/workflows/validate-plugin-toml.yml
@@ -7,6 +7,9 @@ on:
     paths:
       - 'plugins/**'
 
+permissions:
+  pull-requests: write
+
 jobs:
   validate:
     runs-on: ubuntu-latest
@@ -42,5 +45,57 @@ jobs:
         run: pnpm install
 
       - name: Validate plugin.toml files
+        id: validate
         if: steps.changed.outputs.plugins != ''
-        run: pnpm validate ${{ steps.changed.outputs.plugins }}
+        continue-on-error: true
+        env:
+          VALIDATION_REPORT_PATH: validation-report.md
+        run: |
+          pnpm validate ${{ steps.changed.outputs.plugins }}
+          echo "result=success" >> $GITHUB_OUTPUT
+        # If validation fails (exit 1), continue-on-error keeps the workflow running
+        # but 'result=success' won't be written to GITHUB_OUTPUT
+
+      - name: Post validation comment
+        if: always() && steps.changed.outputs.plugins != ''
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const marker = '<!-- plugin-toml-validation -->';
+
+            let body;
+            const reportPath = 'validation-report.md';
+            if (fs.existsSync(reportPath)) {
+              body = marker + '\n' + fs.readFileSync(reportPath, 'utf8');
+            } else {
+              body = marker + '\n## Plugin TOML Validation Report\n\n> No validation report generated.';
+            }
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+
+            const existing = comments.find(c => c.body && c.body.includes(marker));
+
+            if (existing) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: existing.id,
+                body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body,
+              });
+            }
+
+      - name: Fail if validation failed
+        if: steps.validate.outcome == 'failure'
+        run: exit 1
diff --git a/generate.ts b/generate.ts
@@ -109,38 +109,40 @@ function generatePluginData(pluginsDir: string, gitmodulesPath: string): PluginD
         const pluginConfig = loadPluginToml(pluginPath)
 
         if (!pluginConfig?.plugin) {
-            console.warn(`警告: ${ pluginName } 没有有效的 plugin.toml`)
+            console.warn(`Warning: ${ pluginName } has no valid plugin.toml`)
             continue
         }
 
         const modulePath = `plugins/${ pluginName }`
         const gitModule = gitModules.get(modulePath)
 
         if (!gitModule) {
-            console.warn(`警告: ${ pluginName } 没有对应的 git submodule`)
+            console.warn(`Warning: ${ pluginName } has no matching git submodule`)
             continue
         }
 
         const rawPlugin = pluginConfig.plugin
 
-        // 验证并过滤 tags
+        // Validate and filter tags
         let tags: ValidTag[] | undefined
         if (rawPlugin.tags && Array.isArray(rawPlugin.tags)) {
             const filtered = rawPlugin.tags
             .map(tag => tag.toLowerCase())
             .filter((tag): tag is ValidTag => VALID_TAGS.includes(tag as ValidTag))
             if (filtered.length > 0) {
+                // @ts-ignore
                 tags = [...new Set(filtered)]
             }
         }
 
-        // 验证并过滤 database
+        // Validate and filter database
         let database: ValidDatabase[] | undefined
         if (rawPlugin.database && Array.isArray(rawPlugin.database)) {
             const filtered = rawPlugin.database
             .map(db => db.toLowerCase() as ValidDatabase)
             .filter((db): db is ValidDatabase => VALID_DATABASES.includes(db))
             if (filtered.length > 0) {
+                // @ts-ignore
                 database = [...new Set(filtered)]
             }
         }
@@ -201,10 +203,10 @@ function main() {
     const pluginsDir = path.join(baseDir, 'plugins')
     const gitmodulesPath = path.join(baseDir, '.gitmodules')
 
-    console.log('生成插件数据...')
+    console.log('Generating plugins data...')
 
     const pluginDataList = generatePluginData(pluginsDir, gitmodulesPath)
-    console.log(`找到 ${ pluginDataList.length } 个插件`)
+    console.log(`Found ${ pluginDataList.length } plugins`)
 
     fs.writeFileSync(
         path.join(baseDir, 'plugins-data.ts'),
@@ -218,7 +220,7 @@ function main() {
         'utf-8'
     )
 
-    console.log('完成')
+    console.log('Done')
 }
 
 main()
diff --git a/validate.ts b/validate.ts
@@ -22,126 +22,209 @@ interface PluginToml {
 }
 
 interface ValidationError {
-    plugin: string
     field: string
     message: string
     invalidValues?: string[]
 }
 
-function validatePluginToml(pluginName: string, pluginPath: string): ValidationError[] {
+interface ValidationResult {
+    plugin: string
+    passed: boolean
+    config: PluginTomlPlugin | null
+    errors: ValidationError[]
+}
+
+const REQUIRED_FIELDS: (keyof Pick<PluginTomlPlugin, 'summary' | 'version' | 'description' | 'author'>)[] = [
+    'summary',
+    'version',
+    'description',
+    'author',
+]
+
+const ALL_FIELDS: (keyof PluginTomlPlugin)[] = [...REQUIRED_FIELDS, 'icon', 'tags', 'database']
+
+function validatePluginToml(pluginName: string, pluginPath: string): ValidationResult | null {
     const errors: ValidationError[] = []
     const tomlPath = path.join(pluginPath, 'plugin.toml')
 
     if (!fs.existsSync(tomlPath)) {
-        return errors
+        return null
     }
 
     let config: PluginToml
     try {
         config = toml.parse(fs.readFileSync(tomlPath, 'utf-8')) as PluginToml
     } catch (e) {
         errors.push({
-            plugin: pluginName,
             field: 'plugin.toml',
-            message: `解析失败: ${ e instanceof Error ? e.message : String(e) }`,
+            message: `Parse failed: ${ e instanceof Error ? e.message : String(e) }`,
         })
-        return errors
+        return { plugin: pluginName, passed: false, config: null, errors }
     }
 
     if (!config.plugin) {
         errors.push({
-            plugin: pluginName,
             field: 'plugin',
-            message: '缺少 [plugin] 配置块',
+            message: 'Missing [plugin] section',
         })
-        return errors
+        return { plugin: pluginName, passed: false, config: null, errors }
     }
 
-    // 验证 tags
+    // Validate required fields
+    for (const field of REQUIRED_FIELDS) {
+        const value = config.plugin[field]
+        if (!value || (typeof value === 'string' && value.trim() === '')) {
+            errors.push({
+                field,
+                message: 'Required field missing',
+            })
+        }
+    }
+
+    // Validate tags
     if (config.plugin.tags && Array.isArray(config.plugin.tags)) {
         const invalidTags = config.plugin.tags.filter(
             tag => !VALID_TAGS.includes(tag.toLowerCase() as ValidTag)
         )
         if (invalidTags.length > 0) {
             errors.push({
-                plugin: pluginName,
                 field: 'tags',
-                message: `包含无效的 tags 值`,
+                message: 'Invalid values',
                 invalidValues: invalidTags,
             })
         }
     }
 
-    // 验证 database
+    // Validate database
     if (config.plugin.database && Array.isArray(config.plugin.database)) {
         const invalidDatabases = config.plugin.database.filter(
             db => !VALID_DATABASES.includes(db.toLowerCase() as ValidDatabase)
         )
         if (invalidDatabases.length > 0) {
             errors.push({
-                plugin: pluginName,
                 field: 'database',
-                message: `包含无效的 database 值`,
+                message: 'Invalid values',
                 invalidValues: invalidDatabases,
             })
         }
     }
 
-    return errors
+    return {
+        plugin: pluginName,
+        passed: errors.length === 0,
+        config: config.plugin,
+        errors,
+    }
+}
+
+function formatFieldRow(name: string, value: string | string[] | undefined, error?: ValidationError): string {
+    if (Array.isArray(value) && value.length > 0) {
+        const display = value.map(v => `\`${ v }\``).join(', ')
+        const status = error
+            ? `❌ ${ error.message }: ${ error.invalidValues!.map(v => `\`${ v }\``).join(', ') }`
+            : '✅'
+        return `| \`${ name }\` | ${ display } | ${ status } |\n`
+    }
+    if (typeof value === 'string' && value.trim()) {
+        return `| \`${ name }\` | ${ value } | ${ error ? `❌ ${ error.message }` : '✅' } |\n`
+    }
+    return `| \`${ name }\` | - | ${ error ? `❌ ${ error.message }` : '➖' } |\n`
+}
+
+function generateReport(results: ValidationResult[]): string {
+    const allPassed = results.every(r => r.passed)
+
+    let report = `## Plugin TOML Validation Report\n\n`
+    report += `**Status**: ${ allPassed ? '✅ All Passed' : '❌ Validation Failed' }\n\n`
+
+    for (const result of results) {
+        report += `### ${ result.passed ? '✅' : '❌' } \`${ result.plugin }\`\n\n`
+
+        if (!result.config) {
+            result.errors.forEach(e => report += `> ⚠️ \`${ e.field }\`: ${ e.message }\n`)
+            report += '\n'
+            continue
+        }
+
+        const errorMap = new Map(result.errors.map(e => [e.field, e]))
+        report += `| Field | Value | Status |\n`
+        report += `|-------|-------|--------|\n`
+        for (const field of ALL_FIELDS) {
+            report += formatFieldRow(field, result.config[field], errorMap.get(field))
+        }
+        report += '\n'
+    }
+
+    if (!allPassed) {
+        report += `### Reference\n\n`
+        report += `| Type | Allowed Values |\n`
+        report += `|------|----------------|\n`
+        report += `| Tags | ${ VALID_TAGS.map(t => `\`${ t }\``).join(', ') } |\n`
+        report += `| Database | ${ VALID_DATABASES.map(d => `\`${ d }\``).join(', ') } |\n`
+    }
+
+    return report
 }
 
 function main() {
     const pluginsDir = path.join(__dirname, 'plugins')
-    const allErrors: ValidationError[] = []
+    const results: ValidationResult[] = []
 
     if (!fs.existsSync(pluginsDir)) {
-        console.log('plugins 目录不存在')
+        console.log('plugins directory not found')
         process.exit(0)
     }
 
-    // 支持命令行参数指定要验证的插件
     const args = process.argv.slice(2)
     let pluginDirs: string[]
 
     if (args.length > 0) {
-        // 验证指定的插件
         pluginDirs = args.filter(name => {
             const pluginPath = path.join(pluginsDir, name)
             return fs.existsSync(pluginPath)
         })
     } else {
-        // 验证所有插件
         pluginDirs = fs.readdirSync(pluginsDir, { withFileTypes: true })
-            .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
-            .map(entry => entry.name)
+        .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+        .map(entry => entry.name)
     }
 
-    console.log(`验证 ${ pluginDirs.length } 个插件...\n`)
-
     for (const pluginName of pluginDirs) {
         const pluginPath = path.join(pluginsDir, pluginName)
-        const errors = validatePluginToml(pluginName, pluginPath)
-        allErrors.push(...errors)
+        const result = validatePluginToml(pluginName, pluginPath)
+        if (result) {
+            results.push(result)
+        }
     }
 
-    if (allErrors.length === 0) {
-        console.log('所有插件验证通过')
-        console.log(`\n允许的 tags: ${ VALID_TAGS.join(', ') }`)
-        console.log(`允许的 database: ${ VALID_DATABASES.join(', ') }`)
-        process.exit(0)
-    }
+    const passed = results.filter(r => r.passed).length
+    const failed = results.filter(r => !r.passed).length
 
-    console.error('验证失败:\n')
-    for (const error of allErrors) {
-        console.error(`[${ error.plugin }] ${ error.field }: ${ error.message }`)
-        if (error.invalidValues) {
-            console.error(`  无效值: ${ error.invalidValues.join(', ') }`)
+    // Write report file (for CI)
+    const reportPath = process.env.VALIDATION_REPORT_PATH
+    if (reportPath) {
+        fs.writeFileSync(reportPath, generateReport(results), 'utf-8')
+        console.log(`Done: ${ passed } passed, ${ failed } failed`)
+    } else {
+        console.log(`Validating ${ pluginDirs.length } plugins...\n`)
+        for (const { plugin, passed: ok, errors } of results) {
+            if (ok) {
+                console.log(`  ✅ ${ plugin }`)
+                continue
+            }
+            console.error(`  ❌ ${ plugin }`)
+            errors.forEach(({ field, message, invalidValues }) =>
+                console.error(`     - ${ field }: ${ invalidValues ? `${ message }: ${ invalidValues.join(', ') }` : message }`)
+            )
+        }
+        console.log(`\nResult: ${ passed } passed, ${ failed } failed`)
+        if (failed > 0) {
+            console.error(`\nAllowed tags: ${ VALID_TAGS.join(', ') }`)
+            console.error(`Allowed database: ${ VALID_DATABASES.join(', ') }`)
         }
     }
 
-    console.error(`\n允许的 tags: ${ VALID_TAGS.join(', ') }`)
-    console.error(`允许的 database: ${ VALID_DATABASES.join(', ') }`)
-    process.exit(1)
+    process.exit(failed > 0 ? 1 : 0)
 }
 
 main()
