feat: Rework glob functionality to work by excluding specific things

Author: OleRoss

README.md

@@ -35,17 +35,18 @@ jobs:
             coverage/coverage2.xml
           update-comment: true
           show-changed-lines-only: true
-          show-glob-only: '**/**'
+          exclude-files: |
+            some_generated_files/*.rs
 ```
 
 ### Inputs
 
-| Name                      | Default    | Description                                                     |
-|---------------------------|------------|-----------------------------------------------------------------|
-| `files`                   | (required) | One or multiple files. Can be multiple lines. Glob is supported |
-| `update-comment`          | true       | TODO: Update                                                    |
-| `show-changed-lines-only` | true       | If part of a PR, filter coverage data against changed lines     |
-| `show-glob-only`          | '**'    | Select subdirectories to show coverage data for                 |
+| Name                      | Default    | Description                                                                                |
+|---------------------------|------------|--------------------------------------------------------------------------------------------|
+| `files`                   | (required) | One or multiple files. Can be multiple lines. Glob is supported                            |
+| `update-comment`          | true       | TODO: Update                                                                               |
+| `show-changed-lines-only` | true       | If part of a PR, filter coverage data against changed lines                                |
+| `exclude-files`           | ''         | Glob patterns for files to exclude. Can be multiple lines. If empty, no files are excluded |
 
 ### Outputs
 

action.yaml

@@ -13,10 +13,10 @@ inputs:
     description: If part of a PR, filter coverage data against changed lines
     required: false
     default: 'true'
-  show-glob-only:
-    description: Select subdirectories to show coverage data for
+  exclude-files:
+    description: Glob patterns for files to exclude from coverage data. Can be multiple lines. If empty, no files are excluded.
     required: false
-    default: '**'
+    default: ''
   source:
     description: Fallback source directory for resolving file paths from coverage files
     required: false

package.json

@@ -5,6 +5,7 @@
     "build": "ncc build --source-map --license licenses.txt src/index.ts",
     "build:cli": "ncc build --source-map src/cli.ts -o dist-cli",
     "test": "vitest",
+    "run:cli": "pnpm run build:cli && node dist-cli/index.js",
     "test:coverage": "vitest run --coverage"
   },
   "bin": {

src/action.ts

@@ -7,7 +7,7 @@ export type Inputs = {
   files: string
   updateComment: boolean
   showChangedLinesOnly: boolean
-  globPattern: string
+  excludeFilesPattern: string
   sourceDir: string
 }
 
@@ -23,12 +23,22 @@ const actionLogger: Logger = {
 export const run = async (inputs: Inputs, octokit: Octokit, context: Context): Promise<void> => {
   const shas = getComparisonShas(context)
 
+  const excludePatterns = inputs.excludeFilesPattern
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+
+  const filePatterns = inputs.files
+    .split(/[\n,]/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+
   // Process coverage using the core module
   const result = await processCoverage(
     {
-      files: inputs.files,
+      filePatterns,
       sourceDir: inputs.sourceDir,
-      globPattern: inputs.globPattern,
+      excludePatterns,
       baseSha: shas?.baseSha,
       headSha: shas?.headSha,
     },

src/cli.ts

@@ -19,12 +19,12 @@ USAGE:
   coverage-visualizer --files <patterns> [options]
 
 OPTIONS:
-  --files <patterns>       Coverage file patterns (required, comma or newline separated)
+  --file <pattern>       Coverage file patterns (required)
   --output <path>          Output file path (optional, prints to stdout if not specified)
   --source <path>          Source directory for resolving file paths (default: current directory)
   --base-ref <ref>         Git ref to compare against (e.g., origin/main, HEAD~1)
   --show-changed-only      Filter to show only changed lines (requires --base-ref)
-  --show-glob <pattern>    Glob pattern to filter which files to show (default: **)
+  --exclude-file <pattern> Glob pattern for files to exclude (can be passed multiple times)
   --verbose, -v            Enable debug logging
   --help                   Show this help message
 
@@ -38,20 +38,20 @@ EXAMPLES:
   # Show only changed lines compared to main branch
   coverage-visualizer --files "coverage/*.xml" --base-ref origin/main --show-changed-only
 
-  # Filter to specific directory
-  coverage-visualizer --files "coverage/*.xml" --show-glob "src/components/**"
+  # Exclude specific files or directories
+  coverage-visualizer --files "coverage/*.xml" --exclude-files "to_exclude/*" --exclude-files "my_folder/*.generated"
 `)
 }
 
 async function main(): Promise<void> {
   const { values } = parseArgs({
     options: {
-      files: { type: 'string', short: 'f' },
+      file: { type: 'string', short: 'f' },
       output: { type: 'string', short: 'o' },
       source: { type: 'string', short: 's' },
       'base-ref': { type: 'string', short: 'b' },
       'show-changed-only': { type: 'boolean', default: false },
-      'show-glob': { type: 'string', default: '**' },
+      'exclude-files': { type: 'string', multiple: true },
       verbose: { type: 'boolean', short: 'v', default: false },
       help: { type: 'boolean', short: 'h', default: false },
     },
@@ -67,8 +67,8 @@ async function main(): Promise<void> {
   }
 
   // Validate required arguments
-  if (!values.files) {
-    console.error('Error: --files is required\n')
+  if (!values.file) {
+    console.error('Error: --file is required\n')
     printHelp()
     process.exit(1)
   }
@@ -106,11 +106,12 @@ async function main(): Promise<void> {
   }
 
   // Process coverage
+  const excludePatterns = (values['exclude-files'] as string[] | undefined) ?? []
   const result = await processCoverage(
     {
-      files: values.files,
+      filePatterns: [values.file],
       sourceDir: values.source ?? process.cwd(),
-      globPattern: values['show-glob'] ?? '**',
+      excludePatterns,
       baseSha,
       headSha,
     },

src/core/process-coverage.ts

@@ -1,3 +1,4 @@
+import assert from 'node:assert'
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import {
@@ -40,16 +41,17 @@ export function createCliLogger(verbose: boolean): Logger {
  */
 export type ProcessCoverageInputs = {
   /** Coverage file patterns (newline or comma separated) */
-  files: string
+  filePatterns: string[]
   /** Source directory for resolving file paths from coverage files */
   sourceDir: string
-  /** Glob pattern to filter which files to show */
-  globPattern: string
+  /** Glob patterns for files to exclude. If empty, no files are excluded. */
+  excludePatterns: string[]
   /** Explicit base commit SHA for comparison */
   baseSha?: string | undefined
   /** Explicit head commit SHA for comparison */
   headSha?: string | undefined
 }
+
 /**
  * Result of coverage processing.
  */
@@ -74,16 +76,10 @@ export async function processCoverage(
   inputs: ProcessCoverageInputs,
   logger: Logger,
 ): Promise<ProcessCoverageResult | null> {
-  // Find all matching coverage files
-  const filePatterns = inputs.files
-    .split(/[\n,]/)
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0)
-
-  logger.info(`Looking for coverage files matching: [${filePatterns.join(', ')}]`)
+  logger.info(`Looking for coverage files matching: [${inputs.filePatterns.join(', ')}]`)
 
   // Sort and de-duplicate matched files for deterministic CI output
-  const globResults = await Array.fromAsync(fs.glob(filePatterns))
+  const globResults = await Array.fromAsync(fs.glob(inputs.filePatterns))
   const matchedFiles = [...new Set(globResults.map((f) => path.resolve(f)).sort())]
 
   if (matchedFiles.length === 0) {
@@ -135,8 +131,10 @@ export async function processCoverage(
   }
 
   // Apply filters to the coverage report
-  const globFilteredPackages: PackageCoverage[] = filterByGlob(mergedPackages, inputs.globPattern, logger)
-  const fileFilteredPackages = changedLinesPerFileMap ?filterByChangedLines(globFilteredPackages, changedLinesPerFileMap, logger) : globFilteredPackages
+  const globFilteredPackages: PackageCoverage[] = filterByGlob(mergedPackages, inputs.excludePatterns, logger)
+  const fileFilteredPackages = changedLinesPerFileMap
+    ? filterByChangedLines(globFilteredPackages, changedLinesPerFileMap, logger)
+    : globFilteredPackages
 
   // Read file contents from disk using resolved paths
   const fileContents = await readFileContents(fileFilteredPackages)
@@ -217,21 +215,23 @@ async function mergeReportAndResolveSources(
         const existing = fileMap.get(resolvedPath)
         if (existing) {
           const merged = CoberturaCoverageParser.merge(existing, file.lines)
+          assert(existing.resolvedPath)
           fileMap.set(resolvedPath, merged)
           logger.debug?.(`Merged duplicate file: ${file.filename}`)
         } else {
-          fileMap.set(resolvedPath, { resolvedPath, ...file })
+          file.resolvedPath = resolvedPath
+          fileMap.set(resolvedPath, file)
         }
       }
     }
   }
 
   // Convert file maps back to arrays for the final report
-  const packages: PackageCoverage[] = Array.from(packageMap.values()).map(({ name, fileMap }) => {
+  const packages: PackageCoverage[] = Array.from(packageMap.values()).map(({ name, fileMap }): PackageCoverage => {
     const files = Array.from(fileMap.values())
     return {
       name,
-      files,
+      files: files,
       coverage: CoberturaCoverageParser.calculateFileCoverage(files),
     }
   })

src/coverage/model.ts

@@ -28,7 +28,7 @@ export type FileCoverage = {
   /** Display path (relative to source root, for markdown output) */
   readonly filename: string
   /** Absolute path for reading file contents (set after path resolution) */
-  resolvedPath?: string | undefined
+  resolvedPath: string | undefined
   /** Coverage information per line */
   readonly lines: LineCoverage[]
   /** The coverage information */

src/coverage/parsers/cobertura.ts

@@ -133,6 +133,7 @@ export class CoberturaCoverageParser implements CoverageParser {
         const coverage = CoberturaCoverageParser.calculateCoverage(lines)
         newFile = {
           filename,
+          resolvedPath: undefined,
           lines,
           coverage
         }
@@ -150,6 +151,7 @@ export class CoberturaCoverageParser implements CoverageParser {
     return {
       lines,
       filename: file.filename,
+      resolvedPath: file.resolvedPath,
       coverage
     }
   }

src/filter/filter.ts

@@ -5,18 +5,38 @@ import type { FileCoverage, PackageCoverage } from '../coverage/model.js'
 import type { ChangedLinesMap } from './model.js'
 
 /**
- * Filter coverage packages to only include files matching a glob pattern.
+ * Filter coverage packages to exclude files matching any of the provided glob patterns.
+ * If patterns array is empty, no files are excluded (all files are included).
  */
-export function filterByGlob(packages: PackageCoverage[], pattern: string, logger: Logger): PackageCoverage[] {
-  const effectivePattern = pattern.includes('/') ? pattern : `**/${pattern}`
+export function filterByGlob(packages: PackageCoverage[], patterns: string[], logger: Logger): PackageCoverage[] {
+  if (patterns.length === 0) {
+    return packages
+  }
+
+  // Normalize patterns: if pattern doesn't contain '/', prepend '**/'
+  const effectivePatterns = patterns.map((pattern) => (pattern.includes('/') ? pattern : `**/${pattern}`))
+
   const totalFilesBefore = packages.reduce((sum, pkg) => sum + pkg.files.length, 0)
 
   const filteredPackages = packages
     .map((pkg) => {
       const files = pkg.files.filter((file) => {
-        const filePath = file.resolvedPath ?? file.filename
-        logger.debug?.(`Filtering '${filePath}' against glob '${effectivePattern}'`)
-        return path.matchesGlob(filePath, effectivePattern)
+        const filePath = file.resolvedPath
+        // Files without resolvedPath are included (not excluded)
+        if (!filePath) {
+          return true
+        }
+
+        // Exclude file if it matches ANY of the patterns
+        const shouldExclude = effectivePatterns.some((pattern) => {
+          const matches = path.matchesGlob(filePath, pattern)
+          if (matches) {
+            logger.debug?.(`Excluding '${filePath}' (matches exclude-pattern '${pattern}')`)
+          }
+          return matches
+        })
+
+        return !shouldExclude
       })
       return {
         name: pkg.name,
@@ -27,7 +47,9 @@ export function filterByGlob(packages: PackageCoverage[], pattern: string, logge
     .filter((pkg) => pkg.files.length > 0)
 
   const totalFilesAfter = filteredPackages.reduce((sum, pkg) => sum + pkg.files.length, 0)
-  logger.info(`Filtered ${totalFilesAfter}/${totalFilesBefore} files against glob '${effectivePattern}'`)
+  logger.info(
+    `Filtered ${totalFilesAfter}/${totalFilesBefore} files against exclude-patterns: [${effectivePatterns.join(', ')}]`,
+  )
 
   return filteredPackages
 }

src/index.ts

@@ -1,14 +1,14 @@
 import * as core from '@actions/core'
-import { run } from './action.js'
 import { getContext, getOctokit } from './github.js'
+import { run } from './action.js'
 
 try {
   await run(
     {
       files: core.getInput('files', { required: true }),
       updateComment: core.getBooleanInput('update-comment'),
       showChangedLinesOnly: core.getBooleanInput('show-changed-lines-only'),
-      globPattern: core.getInput('show-glob-only') || '**',
+      excludeFilesPattern: core.getInput('exclude-files') || '',
       sourceDir: core.getInput('source') || process.env['GITHUB_WORKSPACE'] || process.cwd(),
     },
     getOctokit(),