feat: add --skip-coverage-path

Author: tilaven

CHANGELOG.md

@@ -1,3 +1,26 @@
+# 0.5.0 - 2026-02-18
+
+Added
+- `--skip-coverage-path` regex option to exclude matching paths from uncovered line calculations and list skipped paths in the summary output
+
+Changed
+- CLI output lines order
+
+# 0.4.1 - 2026-02-15
+
+Fixed
+- Bump version in Cargo.toml
+
+# 0.4.0 - 2026-02-15
+
+Changed
+- Change entrypoint to cmd to simplify CI usage
+
+# 0.3.2 - 2026-02-11
+
+Fixed 
+- dockerhub release
+
 # 0.3.1 - 2026-02-11
 
 Fixed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "diff-coverage"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 description = "Diff-coverage, supercharged in Rust. Fast, memory-efficient coverage on changed lines for CI."
 license = "MIT"
@@ -13,5 +13,6 @@ categories = ["development-tools::testing", "command-line-utilities"]
 clap = { version = "4.5.7", features = ["derive"] }
 owo-colors = "4.0.0"
 quick-xml = "0.37.0"
+regex = "1.10.6"
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0.128"

Cargo.toml

@@ -21,12 +21,16 @@ diff-coverage ./coverage/ coverage.xml --diff-file diff.diff --fail-under 80
 # Output to CI formats
 diff-coverage coverage.xml --diff-file diff.diff --output gitlab=diff-cover.json
 diff-coverage coverage.xml --diff-file diff.diff --output json=diff-cover.json --output summary
+
+# Skip external packages from uncovered line calculations (regex supported)
+diff-coverage coverage.xml --diff-file diff.diff --skip-coverage-path '^pkg/mongodb'
 ```
 
 Options
 - --diff-file <PATH>: diff to analyze
 - --fail-under <PERCENT>: minimum acceptable diff coverage
 - --missing-coverage <MODE>: how to handle files missing from coverage (uncovered or ignore, default: ignore)
+- --skip-coverage-path <REGEX>: regex of file paths to skip from uncovered line calculations (repeatable or comma-separated)
 - --output <FORMAT=PATH>: output target(s), repeatable or comma‑separated Formats: cli, summary, gitlab, json (note: cli and summary don’t take a path)
 - -h, --help: show help
 - -V, --version: show version

README.md

@@ -17,6 +17,7 @@ pub fn run(options: cli::CliOptions) -> Result<(), AppError> {
     let fail_under = options.fail_under;
     let output_targets = options.outputs;
     let missing_coverage = options.missing_coverage;
+    let skip_coverage_paths = options.skip_coverage_paths;
 
     let coverage_files = collect_coverage_files(coverage_paths).map_err(AppError::usage)?;
 
@@ -39,9 +40,13 @@ pub fn run(options: cli::CliOptions) -> Result<(), AppError> {
 
             let treat_missing_as_uncovered =
                 matches!(missing_coverage, cli::MissingCoverageMode::Uncovered);
-            let report =
-                coverage::analyze_changed_coverage(&changed, &coverage, treat_missing_as_uncovered)
-                    .map_err(|err| AppError::usage(err.to_string()))?;
+            let report = coverage::analyze_changed_coverage(
+                &changed,
+                &coverage,
+                treat_missing_as_uncovered,
+                &skip_coverage_paths,
+            )
+            .map_err(|err| AppError::usage(err.to_string()))?;
             write_reports(&report, &output_plan)?;
 
             if let Some(threshold) = fail_under {

src/app/mod.rs

@@ -3,6 +3,7 @@ use std::path::PathBuf;
 use std::sync::OnceLock;
 
 use clap::{CommandFactory, FromArgMatches, Parser, ValueEnum, ValueHint};
+use regex::Regex;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, ValueEnum)]
 #[value(rename_all = "kebab_case")]
@@ -101,6 +102,14 @@ pub struct CliOptions {
         help = "How to handle files missing from coverage: uncovered or ignore"
     )]
     pub missing_coverage: MissingCoverageMode,
+    #[arg(
+        long = "skip-coverage-path",
+        value_name = "REGEX",
+        help = "Regex of file paths to exclude from uncovered line calculations; repeatable or comma-separated",
+        action = clap::ArgAction::Append,
+        value_delimiter = ','
+    )]
+    pub skip_coverage_paths: Vec<Regex>,
     #[arg(
         long = "output",
         id = "output",
@@ -326,4 +335,32 @@ mod tests {
         .expect("parse");
         assert_eq!(options.missing_coverage, MissingCoverageMode::Ignore);
     }
+
+    #[test]
+    fn parses_skip_coverage_paths() {
+        let options = parse_args([
+            OsString::from("bin"),
+            OsString::from("--skip-coverage-path"),
+            OsString::from("^pkg/mongodb"),
+            OsString::from("--skip-coverage-path"),
+            OsString::from("vendor/.*"),
+        ])
+        .expect("parse");
+        assert_eq!(options.skip_coverage_paths.len(), 2);
+        assert_eq!(options.skip_coverage_paths[0].as_str(), "^pkg/mongodb");
+        assert_eq!(options.skip_coverage_paths[1].as_str(), "vendor/.*");
+    }
+
+    #[test]
+    fn parses_skip_coverage_paths_comma_separated() {
+        let options = parse_args([
+            OsString::from("bin"),
+            OsString::from("--skip-coverage-path"),
+            OsString::from("^pkg/mongodb,vendor/.*"),
+        ])
+        .expect("parse");
+        assert_eq!(options.skip_coverage_paths.len(), 2);
+        assert_eq!(options.skip_coverage_paths[0].as_str(), "^pkg/mongodb");
+        assert_eq!(options.skip_coverage_paths[1].as_str(), "vendor/.*");
+    }
 }

src/cli/mod.rs

@@ -214,7 +214,7 @@ mod tests {
             .parse(cov_file, &mut store)
             .expect("parse clover");
 
-        let report = crate::coverage::analyze_changed_coverage(&changed, &store, true);
+        let report = crate::coverage::analyze_changed_coverage(&changed, &store, true, &[]);
         let report = report.expect("report");
         let calc = report
             .uncovered_files

src/coverage/clover.rs

@@ -7,8 +7,9 @@ use std::io::Read;
 use std::collections::BTreeSet;
 
 use crate::diff::types::ChangedFile;
-use crate::report::{CoverageReport, UncoveredFile};
+use crate::report::{CoverageReport, SkippedFile, UncoveredFile};
 use crate::util::path::normalize_path;
+use regex::Regex;
 use store::CoverageStore;
 
 pub trait CoverageParser {
@@ -25,8 +26,10 @@ pub fn analyze_changed_coverage(
     changed_files: &[ChangedFile],
     coverage: &CoverageStore,
     treat_missing_as_uncovered: bool,
+    skip_paths: &[Regex],
 ) -> Result<CoverageReport, store::CoverageLookupError> {
     let mut uncovered_files = Vec::new();
+    let mut skipped_files = Vec::new();
     let mut total_changed = 0usize;
     let mut total_covered = 0usize;
 
@@ -36,6 +39,16 @@ pub fn analyze_changed_coverage(
         if unique_lines.is_empty() {
             continue;
         }
+        if let Some(matched) = skip_paths
+            .iter()
+            .find(|pattern| pattern.is_match(&normalized_path))
+        {
+            skipped_files.push(SkippedFile {
+                path: normalized_path,
+                pattern: matched.as_str().to_string(),
+            });
+            continue;
+        }
 
         let file_coverage = coverage.file_coverage(&normalized_path)?;
         let mut uncovered_lines = Vec::new();
@@ -77,6 +90,7 @@ pub fn analyze_changed_coverage(
         total_changed,
         total_covered,
         uncovered_files,
+        skipped_files,
     })
 }
 
@@ -86,6 +100,7 @@ mod tests {
     use crate::coverage::store::CoverageStore;
     use crate::coverage::CoverageSink;
     use crate::diff::types::ChangedFile;
+    use regex::Regex;
 
     #[test]
     fn counts_unique_changed_lines_and_tracks_uncovered() {
@@ -98,11 +113,12 @@ mod tests {
         store.on_line("src/foo.rs", 1, 2);
         store.on_line("src/foo.rs", 2, 0);
 
-        let report = analyze_changed_coverage(&changed_files, &store, true).expect("report");
+        let report = analyze_changed_coverage(&changed_files, &store, true, &[]).expect("report");
 
         assert_eq!(report.total_changed, 2);
         assert_eq!(report.total_covered, 1);
         assert_eq!(report.uncovered_files.len(), 1);
+        assert!(report.skipped_files.is_empty());
         let uncovered = &report.uncovered_files[0];
         assert_eq!(uncovered.path, "src/foo.rs");
         assert_eq!(uncovered.uncovered_lines, vec![2]);
@@ -116,11 +132,12 @@ mod tests {
         }];
 
         let store = CoverageStore::default();
-        let report = analyze_changed_coverage(&changed_files, &store, true).expect("report");
+        let report = analyze_changed_coverage(&changed_files, &store, true, &[]).expect("report");
 
         assert_eq!(report.total_changed, 2);
         assert_eq!(report.total_covered, 0);
         assert_eq!(report.uncovered_files.len(), 1);
+        assert!(report.skipped_files.is_empty());
         let uncovered = &report.uncovered_files[0];
         assert_eq!(uncovered.path, "src/foo.rs");
         assert_eq!(uncovered.uncovered_lines, vec![1, 2]);
@@ -134,10 +151,40 @@ mod tests {
         }];
 
         let store = CoverageStore::default();
-        let report = analyze_changed_coverage(&changed_files, &store, false).expect("report");
+        let report = analyze_changed_coverage(&changed_files, &store, false, &[]).expect("report");
 
         assert_eq!(report.total_changed, 0);
         assert_eq!(report.total_covered, 0);
         assert!(report.uncovered_files.is_empty());
+        assert!(report.skipped_files.is_empty());
+    }
+
+    #[test]
+    fn skips_files_matching_patterns() {
+        let changed_files = vec![
+            ChangedFile {
+                path: "pkg/mongodb/client.go".to_string(),
+                changed_lines: vec![1, 2],
+            },
+            ChangedFile {
+                path: "src/main.go".to_string(),
+                changed_lines: vec![10],
+            },
+        ];
+
+        let mut store = CoverageStore::default();
+        store.on_line("src/main.go", 10, 1);
+
+        let patterns = [Regex::new(r"^pkg/mongodb").expect("regex")];
+        let report = analyze_changed_coverage(&changed_files, &store, true, &patterns)
+            .expect("report");
+
+        assert_eq!(report.total_changed, 1);
+        assert_eq!(report.total_covered, 1);
+        assert!(report.uncovered_files.is_empty());
+        assert_eq!(report.skipped_files.len(), 1);
+        let skipped = &report.skipped_files[0];
+        assert_eq!(skipped.path, "pkg/mongodb/client.go");
+        assert_eq!(skipped.pattern, r"^pkg/mongodb");
     }
 }

src/coverage/mod.rs

@@ -51,6 +51,21 @@ pub fn render_to<W: Write + ?Sized>(
         }
     }
 
+    if !report.skipped_files.is_empty() {
+        writeln!(out)?;
+        let header = "Skipped paths from uncovered line calculation (matched --skip-coverage-path):";
+        if use_color {
+            writeln!(out, "{}", header.yellow().bold())?;
+        } else {
+            writeln!(out, "{header}")?;
+        }
+        for skipped in &report.skipped_files {
+            writeln!(out, "- {} (matched {})", skipped.path, skipped.pattern)?;
+        }
+    }
+
+    writeln!(out)?;
+    writeln!(out, "-------------")?;
     writeln!(out, "Coverage for changed lines: {percent_display}")?;
     out.flush()
 }
@@ -108,7 +123,8 @@ fn push_range(ranges: &mut Vec<String>, start: u32, end: u32) {
 
 #[cfg(test)]
 mod tests {
-    use super::format_line_ranges;
+    use super::{format_line_ranges, render_to};
+    use crate::report::{CoverageReport, SkippedFile};
 
     #[test]
     fn formats_line_ranges() {
@@ -117,4 +133,25 @@ mod tests {
         assert_eq!(format_line_ranges(&[1, 2, 3, 5]), "1-3, 5");
         assert_eq!(format_line_ranges(&[1, 3, 5, 6, 7, 8, 9]), "1, 3, 5-9");
     }
+
+    #[test]
+    fn includes_skipped_paths() {
+        let report = CoverageReport {
+            total_changed: 1,
+            total_covered: 1,
+            uncovered_files: Vec::new(),
+            skipped_files: vec![SkippedFile {
+                path: "pkg/mongodb/client.go".to_string(),
+                pattern: "^pkg/mongodb".to_string(),
+            }],
+        };
+
+        let mut out = Vec::new();
+        render_to(&report, &mut out, false).expect("render");
+        let text = String::from_utf8(out).expect("utf8");
+
+        assert!(text.contains("Skipped paths"));
+        assert!(text.contains("pkg/mongodb/client.go"));
+        assert!(text.contains("^pkg/mongodb"));
+    }
 }