Allow per-path overrides in minimum_coverage_by_file

`minimum_coverage_by_file` now accepts String and Regexp keys alongside
the existing Symbol-keyed per-criterion defaults. String keys match the
project-relative path exactly, except those ending in `/`, which match
as a directory prefix; Regexp keys are tested against the project path.
Per-path values may be a Numeric (primary criterion) or a per-criterion
Hash, e.g. `minimum_coverage_by_file line: 70, 'app/critical.rb' => 100`.

For each file, the effective threshold is the Symbol-keyed defaults
merged with every matching override — later overrides win per criterion,
and any override wins over the default for the same criterion. A file
that matches no override keeps the global defaults, so adding an
override only ever raises the bar for the files it touches. The new
overrides surface in `coverage.json` under the existing
`errors.minimum_coverage_by_file` block.

The public getter `SimpleCov.minimum_coverage_by_file` still returns
just the Symbol-keyed defaults, preserving the existing return shape;
a new `SimpleCov.minimum_coverage_by_file_overrides` reader exposes the
per-path map. The setter, `CoverageViolations.minimum_by_file`, the
`MinimumCoverageByFileCheck` constructor, the `CoverageLimits` struct,
and the JSON formatter were updated to carry overrides through.

Resolves #575.

Author: sferik

.rubocop.yml

@@ -59,7 +59,7 @@ Metrics/ClassLength:
 
 Metrics/ModuleLength:
   Description: Avoid modules longer than 100 lines of code.
-  Max: 300
+  Max: 320
   Exclude:
     - "lib/simplecov.rb"
 

CHANGELOG.md

@@ -15,6 +15,7 @@ Unreleased
 * `# :nocov:` toggle comments (and the configurable `SimpleCov.nocov_token` / `SimpleCov.skip_token`) are deprecated in favor of the new `# simplecov:disable` / `# simplecov:enable` directives. Each file that still uses `# :nocov:` emits a one-time deprecation warning to stderr at load time pointing at the recommended replacement, and any call to `SimpleCov.nocov_token` or `SimpleCov.skip_token` (getter or setter) likewise warns. The directive will be removed in a future release.
 
 ## Enhancements
+* `SimpleCov.minimum_coverage_by_file` now accepts per-path overrides alongside the existing per-criterion defaults: pass String or Regexp keys to declare file- or directory-specific thresholds, e.g. `minimum_coverage_by_file line: 70, 'app/mailers/request_mailer.rb' => 100`. A String ending in `/` matches as a directory prefix; otherwise it must equal the project-relative path. Regexp keys match against the project-relative path. Per-path values may be a Numeric (primary criterion) or a per-criterion Hash; for each file the effective threshold is the defaults merged with any matching overrides (later overrides win per criterion, overrides win over defaults). The new overrides surface in `coverage.json` under the existing `errors.minimum_coverage_by_file` block. See #575.
 * Added `SimpleCov.maximum_coverage` (and the convenience `SimpleCov.expected_coverage`, which sets `minimum_coverage` and `maximum_coverage` to the same value) so the suite can be pinned to an exact coverage figure. A drop fails per the minimum; an unexpected increase also fails, prompting you to bump the threshold up rather than silently absorbing the improvement. Accepts the same Numeric / per-criterion Hash forms as `minimum_coverage`. Exits with status 4 (`SimpleCov::ExitCodes::MAXIMUM_COVERAGE`) when violated, and surfaces in `coverage.json` under `errors.maximum_coverage`. Comparisons floor the actual percent to two decimal places, so `expected_coverage 95.42` still passes when the actual is e.g. 95.4287. See #187.
 * Added a bundled `strict` profile (`SimpleCov.start "strict"`) that enables line, branch, and method coverage and pins the minimum threshold for each at 100%. Drops to line-only on engines without branch/method support (JRuby). See #1061.
 * `SimpleCov.coverage_path` is now explicitly settable rather than always computed from `SimpleCov.root + SimpleCov.coverage_dir`. Setting it pins the report destination regardless of later `root` / `coverage_dir` changes — useful for out-of-tree build directories (CMake/CTest etc.) where the coverage report doesn't live under the source root. See #716.

README.md

@@ -933,6 +933,20 @@ SimpleCov.minimum_coverage_by_file line: 80
 SimpleCov.minimum_coverage_by_file line: 90, branch: 80
 ```
 
+You can also raise the bar for specific files or directories by passing String or Regexp keys alongside the Symbol-keyed defaults. The String form does an exact match against the project-relative path, or a directory-prefix match when it ends in `/`; the Regexp form is matched against the project-relative path. Per-path values may be a single number (applied to the primary criterion) or a per-criterion Hash. For each file, the effective threshold is the defaults merged with any matching overrides — later overrides win per criterion, and overrides themselves win over defaults. See #575.
+
+```ruby
+# 70% line coverage everywhere — but require 100% for one critical file
+SimpleCov.minimum_coverage_by_file line: 70, 'app/mailers/request_mailer.rb' => 100
+
+# Directory prefix + Regexp; per-criterion override for the payments code
+SimpleCov.minimum_coverage_by_file(
+  line: 70,
+  'lib/auth/' => 95,
+  %r{\Alib/payments/} => { line: 100, branch: 90 }
+)
+```
+
 ### Minimum coverage by group
 
 You can define the minimum coverage percentage expected for specific groups. SimpleCov will return non-zero if unmet, 

features/minimum_coverage_by_file.feature

@@ -70,3 +70,49 @@ Feature:
     And the output should contain "Branch coverage by file (50.00%) is below the expected minimum coverage (70.00%) in lib/faked_project/some_class.rb."
     And the output should not contain "Line coverage ("
     And the output should contain "SimpleCov failed with exit 2"
+
+  Scenario: Per-path override raises the bar for a specific file
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_filter 'test.rb'
+        minimum_coverage_by_file line: 70, 'lib/faked_project/framework_specific.rb' => 100
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should not be 0
+    And the output should contain "Line coverage by file (75.00%) is below the expected minimum coverage (100.00%) in lib/faked_project/framework_specific.rb."
+    And the output should contain "SimpleCov failed with exit 2"
+
+  Scenario: Per-path override does not flag files that pass the default but not the override
+    # framework_specific.rb is at 75% — passes the default 70%; some_class.rb is
+    # at 80% — passes both. The directory-prefix override raises the bar to 90%
+    # for lib/faked_project/, so framework_specific.rb fails its override.
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_filter 'test.rb'
+        minimum_coverage_by_file line: 70, 'lib/faked_project/' => 90
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should not be 0
+    And the output should contain "Line coverage by file (75.00%) is below the expected minimum coverage (90.00%) in lib/faked_project/framework_specific.rb."
+    And the output should contain "SimpleCov failed with exit 2"
+
+  Scenario: Per-path override that no file matches has no effect
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_filter 'test.rb'
+        minimum_coverage_by_file line: 70, 'lib/nonexistent.rb' => 100
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should be 0

lib/simplecov.rb

@@ -314,16 +314,20 @@ def process_result(result)
     CoverageLimits = Struct.new(
       :minimum_coverage,
       :minimum_coverage_by_file,
+      :minimum_coverage_by_file_overrides,
       :minimum_coverage_by_group,
       :maximum_coverage,
       :maximum_coverage_drop,
       keyword_init: true
     )
     def result_exit_status(result)
       coverage_limits = CoverageLimits.new(
-        minimum_coverage: minimum_coverage, minimum_coverage_by_file: minimum_coverage_by_file,
+        minimum_coverage: minimum_coverage,
+        minimum_coverage_by_file: minimum_coverage_by_file,
+        minimum_coverage_by_file_overrides: minimum_coverage_by_file_overrides,
         minimum_coverage_by_group: minimum_coverage_by_group,
-        maximum_coverage: maximum_coverage, maximum_coverage_drop: maximum_coverage_drop
+        maximum_coverage: maximum_coverage,
+        maximum_coverage_drop: maximum_coverage_drop
       )
 
       ExitCodes::ExitCodeHandling.call(result, coverage_limits: coverage_limits)

lib/simplecov/configuration.rb

@@ -426,18 +426,33 @@ def maximum_coverage_drop(coverage_drop = nil)
     #
     # Defines the minimum coverage per file required for the testsuite to pass.
     # SimpleCov will return non-zero if the current coverage of the least covered file
-    # is below this threshold.
+    # is below this threshold. Default is 0% (disabled).
     #
-    # Default is 0% (disabled)
+    # Accepts a Numeric (global threshold on the primary criterion), a Symbol-keyed
+    # Hash (per-criterion globals), or a Hash mixing Symbol keys with String / Regexp
+    # keys to declare per-path overrides. For each file the effective threshold is
+    # the Symbol-keyed defaults merged with any matching overrides — later overrides
+    # win per criterion, overrides win over defaults. See the README and #575.
     #
     def minimum_coverage_by_file(coverage = nil)
       return @minimum_coverage_by_file ||= {} unless coverage
 
       coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
 
-      raise_on_invalid_coverage(coverage, "minimum_coverage_by_file")
+      defaults, overrides = partition_per_file_thresholds(coverage)
+
+      raise_on_invalid_coverage(defaults, "minimum_coverage_by_file")
+      overrides.each_value { |criteria| raise_on_invalid_coverage(criteria, "minimum_coverage_by_file") }
 
-      @minimum_coverage_by_file = coverage
+      @minimum_coverage_by_file = defaults
+      @minimum_coverage_by_file_overrides = overrides
+    end
+
+    # Returns the per-path overrides set via `minimum_coverage_by_file`,
+    # as an ordered Hash mapping each pattern (String or Regexp) to its
+    # per-criterion thresholds Hash. Defaults to an empty Hash.
+    def minimum_coverage_by_file_overrides
+      @minimum_coverage_by_file_overrides ||= {}
     end
 
     #
@@ -681,6 +696,24 @@ def minimum_possible_coverage_exceeded(coverage_option)
       warn "The coverage you set for #{coverage_option} is greater than 100%"
     end
 
+    # Split a `minimum_coverage_by_file` argument into Symbol-keyed criterion
+    # defaults and String/Regexp-keyed per-path overrides; normalize Numeric
+    # override values to `{primary_coverage => N}` so downstream code only
+    # has one shape to handle.
+    def partition_per_file_thresholds(coverage)
+      coverage.each_key { |key| validate_per_file_key(key) }
+      defaults, raw = coverage.partition { |key, _| key.is_a?(Symbol) }.map(&:to_h)
+      overrides = raw.transform_values { |value| value.is_a?(Numeric) ? {primary_coverage => value} : value }
+      [defaults, overrides]
+    end
+
+    def validate_per_file_key(key)
+      return if key.is_a?(Symbol) || key.is_a?(String) || key.is_a?(Regexp)
+
+      raise SimpleCov::ConfigurationError,
+            "minimum_coverage_by_file keys must be Symbol (criterion), String, or Regexp; got #{key.inspect}"
+    end
+
     # Copy instance variables from block_context into self, saving any of ours
     # that would be clobbered. Returns the saved values for later restoration.
     def swap_ivars_from(block_context)

lib/simplecov/coverage_violations.rb

@@ -30,9 +30,15 @@ def maximum_overall(result, thresholds)
       end
 
       # @return [Array<Hash>] {:criterion, :expected, :actual, :filename, :project_filename}
-      def minimum_by_file(result, thresholds)
-        thresholds.flat_map do |criterion, expected|
-          result.files.filter_map { |file| file_minimum_violation(file, criterion, expected) }
+      #
+      # `defaults` is the criterion-keyed Hash applied to every file.
+      # `overrides` is an ordered Hash<pattern, criterion_thresholds> of per-path
+      # overrides; for each file, defaults are merged with every matching override
+      # (later wins per criterion, overrides win over defaults).
+      def minimum_by_file(result, defaults, overrides = {})
+        result.files.flat_map do |file|
+          effective = effective_per_file_thresholds(file, defaults, overrides)
+          effective.filter_map { |criterion, expected| file_minimum_violation(file, criterion, expected) }
         end
       end
 
@@ -70,6 +76,31 @@ def percent_for(stats_source, criterion)
         round(stats.percent) if stats
       end
 
+      # Walk the overrides in declaration order, merging each one that matches
+      # the file's project path into the running effective threshold (so the
+      # most-specific or latest-declared override wins per criterion). Returns
+      # the defaults Hash unchanged when nothing matches.
+      def effective_per_file_thresholds(file, defaults, overrides)
+        return defaults if overrides.empty?
+
+        path = file.project_filename
+        overrides.reduce(defaults) do |acc, (pattern, criterion_thresholds)|
+          path_matches?(path, pattern) ? acc.merge(criterion_thresholds) : acc
+        end
+      end
+
+      # Per-path matching for `minimum_coverage_by_file` overrides. Strings
+      # ending in `/` are treated as directory prefixes; otherwise they must
+      # match `project_filename` exactly. Regexps are tested via `match?`.
+      # The configuration setter rejects anything other than String/Regexp,
+      # so no dead `else` branch is needed here.
+      def path_matches?(project_filename, pattern)
+        return project_filename.match?(pattern) if pattern.is_a?(Regexp)
+        return project_filename.start_with?(pattern) if pattern.end_with?("/")
+
+        project_filename == pattern
+      end
+
       def file_minimum_violation(file, criterion, expected)
         actual = percent_for(file, criterion) or return
         return unless actual < expected

lib/simplecov/exit_codes/exit_code_handling.rb

@@ -22,7 +22,9 @@ def call(result, coverage_limits:)
       def coverage_checks(result, coverage_limits)
         [
           MinimumOverallCoverageCheck.new(result, coverage_limits.minimum_coverage),
-          MinimumCoverageByFileCheck.new(result, coverage_limits.minimum_coverage_by_file),
+          MinimumCoverageByFileCheck.new(
+            result, coverage_limits.minimum_coverage_by_file, coverage_limits.minimum_coverage_by_file_overrides
+          ),
           MinimumCoverageByGroupCheck.new(result, coverage_limits.minimum_coverage_by_group),
           MaximumOverallCoverageCheck.new(result, coverage_limits.maximum_coverage),
           MaximumCoverageDropCheck.new(result, coverage_limits.maximum_coverage_drop)

lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -5,9 +5,10 @@ module ExitCodes
     # Fails when any individual file falls below the configured minimum
     # coverage for any criterion.
     class MinimumCoverageByFileCheck
-      def initialize(result, minimum_coverage_by_file)
+      def initialize(result, minimum_coverage_by_file, overrides = {})
         @result = result
         @minimum_coverage_by_file = minimum_coverage_by_file
+        @overrides = overrides
       end
 
       def failing?
@@ -34,7 +35,9 @@ def exit_code
     private
 
       def violations
-        @violations ||= SimpleCov::CoverageViolations.minimum_by_file(@result, @minimum_coverage_by_file)
+        @violations ||= SimpleCov::CoverageViolations.minimum_by_file(
+          @result, @minimum_coverage_by_file, @overrides
+        )
       end
     end
   end

lib/simplecov/formatter/json_formatter/result_hash_formatter.rb

@@ -62,14 +62,18 @@ def format_minimum_coverage_errors
         end
 
         def format_minimum_coverage_by_file_errors
-          violations = SimpleCov::CoverageViolations.minimum_by_file(@result, SimpleCov.minimum_coverage_by_file)
-          violations.each do |violation|
-            key = CRITERION_KEYS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion)))
-            bucket = formatted_result[:errors][:minimum_coverage_by_file] ||= {}
-            criterion_errors = bucket[key] ||= {}
-            criterion_errors[violation.fetch(:project_filename)] =
-              {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
-          end
+          violations = SimpleCov::CoverageViolations.minimum_by_file(
+            @result, SimpleCov.minimum_coverage_by_file, SimpleCov.minimum_coverage_by_file_overrides
+          )
+          violations.each { |violation| record_minimum_coverage_by_file_error(violation) }
+        end
+
+        def record_minimum_coverage_by_file_error(violation)
+          key = CRITERION_KEYS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion)))
+          bucket = formatted_result[:errors][:minimum_coverage_by_file] ||= {}
+          criterion_errors = bucket[key] ||= {}
+          criterion_errors[violation.fetch(:project_filename)] =
+            {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
         end
 
         def format_minimum_coverage_by_group_errors