simplecov 1.0.2 → 1.1.0

data/lib/simplecov/command_guesser.rb

@@ -11,10 +11,30 @@ module SimpleCov
       # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
       # between rails unit/functional/integration tests impossible without this cached
       # item.
-      attr_accessor :original_run_command
+      attr_reader :original_run_command
+
+      # Assigning the flattened command clears any separately recorded program
+      # name so the two can never describe different runs. Callers that know the
+      # real one assign it immediately afterwards, as `defaults.rb` does.
+      def original_run_command=(command)
+        @original_program_name = nil
+        @original_run_command = command
+      end
+
+      # The invoked program on its own. `original_run_command` joins
+      # `$PROGRAM_NAME` and `ARGV` with a space, so a program path containing
+      # one (`/opt/My Ruby/bin/rspec`) cannot be recovered from it afterwards.
+      # Falls back to the first token for callers that set only the flattened
+      # command, which is every caller outside `defaults.rb`.
+      attr_writer :original_program_name
+
+      def original_program_name
+        @original_program_name || original_run_command.to_s[/\A\s*(\S+)/, 1]
+      end
 
       def guess
-        [from_command_line_options || from_defined_constants, parallel_data].compact.join(" ")
+        framework = from_executable_name || from_command_line_options || from_defined_constants
+        [framework, parallel_data].compact.join(" ")
       end
 
     private
@@ -31,14 +51,31 @@ module SimpleCov
         "(#{number}/#{groups})"
       end
 
+      # The command is `"#{$PROGRAM_NAME} #{ARGV.join(' ')}"`, so a keyword only
+      # carries meaning when it begins a path segment or an argument. Matching it
+      # as a bare substring lets any part of the *interpreter* path decide the
+      # suite name: a Ruby installed under `latest/bin` (as mise does) contains
+      # "test/", so every run through it was labelled "Unit Tests". The same
+      # applies within ARGV, where `spec/greatest/` used to match just as wrongly.
+      #
+      # A backslash bounds a segment too, or a Windows `spec\foo_spec.rb` would
+      # lose a match the bare substrings used to make. The `test/` patterns below
+      # still spell their separator as `/` only, so a backslash `test\functional\`
+      # goes unrecognised there, but that is how it has always been rather than
+      # something the anchoring took away.
+      SEGMENT_START = %r{(?<![^\s/\\])}
+      private_constant :SEGMENT_START
+      SEGMENT_END = %r{(?=[\s/\\]|\z)}
+      private_constant :SEGMENT_END
+
       COMMAND_LINE_FRAMEWORKS = {
-        %r{test/functional/} => "Functional Tests",
-        %r{test/\{.*functional.*\}/} => "Functional Tests",
-        %r{test/integration/} => "Integration Tests",
-        %r{test/} => "Unit Tests",
-        /spec/ => "RSpec",
-        /cucumber/ => "Cucumber Features",
-        /features/ => "Cucumber Features"
+        %r{#{SEGMENT_START}test/functional/} => "Functional Tests",
+        %r{#{SEGMENT_START}test/\{.*functional.*\}/} => "Functional Tests",
+        %r{#{SEGMENT_START}test/integration/} => "Integration Tests",
+        %r{#{SEGMENT_START}test/} => "Unit Tests",
+        /#{SEGMENT_START}spec#{SEGMENT_END}/ => "RSpec",
+        /#{SEGMENT_START}cucumber#{SEGMENT_END}/ => "Cucumber Features",
+        /#{SEGMENT_START}features#{SEGMENT_END}/ => "Cucumber Features"
       }.freeze
       private_constant :COMMAND_LINE_FRAMEWORKS
 
@@ -46,6 +83,26 @@ module SimpleCov
         COMMAND_LINE_FRAMEWORKS.find { |pattern, _| pattern.match?(original_run_command.to_s) }&.last
       end
 
+      # Which binary was invoked outranks everything else on the command line.
+      # `rspec features` is an RSpec suite whose examples live in features/, not
+      # a Cucumber run, and only the executable name says so. Generic runners
+      # (`ruby`, `rake`, a bare `*_test.rb` script) are absent on purpose: they
+      # name no framework, so those runs fall through to the path patterns, which
+      # is what keeps the test/functional vs test/integration split working.
+      EXECUTABLE_FRAMEWORKS = {
+        "rspec" => "RSpec",
+        "cucumber" => "Cucumber Features"
+      }.freeze
+      private_constant :EXECUTABLE_FRAMEWORKS
+
+      def from_executable_name
+        program = original_program_name
+        return unless program
+
+        # Trim any extension so Windows' rspec.bat is recognized too.
+        EXECUTABLE_FRAMEWORKS[File.basename(program, ".*")]
+      end
+
       # Inner array literals after the first are flagged uncovered by Ruby's
       # Coverage module even though the constant evaluates as a whole — known
       # quirk with multi-line array literals.

data/lib/simplecov/configuration/coverage.rb

@@ -38,12 +38,12 @@ module SimpleCov
     #
     # `primary: true` makes this the report's leading criterion (and the one a
     # bare `minimum_coverage 90` targets). `oneshot: true` (valid only for
-    # `:line`) selects the faster oneshot-lines mode. `:eval` is enable-only.
+    # `:line`) selects the faster oneshot-lines mode.
     #
     def coverage(criterion, primary: false, enabled: true, oneshot: false, **thresholds, &block)
       criterion = enable_coverage_criterion(criterion, enabled: enabled, oneshot: oneshot)
       # The cast admits :eval, which primary_coverage rejects at runtime
-      # (it is enable-only and never in the enabled-criteria set).
+      # (it is a standalone toggle, never in the enabled-criteria set).
       primary_coverage(_ = criterion) if primary
 
       configurator = CoverageCriterion.new(self, criterion)
@@ -70,30 +70,24 @@ module SimpleCov
       end
     end
 
-    # Enable the criterion (or its oneshot / eval variant) and return the
-    # criterion symbol that thresholds should be stored under.
+    # Enable or disable the criterion (or its oneshot / eval variant) and
+    # return the criterion symbol that thresholds should be stored under.
     def enable_coverage_criterion(criterion, enabled:, oneshot:)
-      return enable_oneshot_line(criterion) if oneshot
-      return enable_eval_coverage_criterion if criterion == :eval
-
+      criterion = resolve_criterion_variant(criterion, oneshot)
       enabled ? enable_coverage(criterion) : disable_coverage(criterion)
       criterion
     end
 
-    def enable_oneshot_line(criterion)
+    def resolve_criterion_variant(criterion, oneshot)
+      return criterion unless oneshot
+
       unless criterion == :line
         raise SimpleCov::ConfigurationError, "`oneshot: true` is only valid for `coverage :line`"
       end
 
-      enable_coverage(ONESHOT_LINE_COVERAGE_CRITERION)
       ONESHOT_LINE_COVERAGE_CRITERION
     end
 
-    def enable_eval_coverage_criterion
-      enable_coverage(:eval)
-      :eval
-    end
-
     # @api private — threshold-store writers used by CoverageCriterion. They
     # write the same `@minimum_coverage` / `@maximum_coverage` / ... hashes the
     # flat threshold methods populate, so the exit-code checks are unchanged.
@@ -115,7 +109,10 @@ module SimpleCov
 
     def store_minimum_per_group(criterion, percent, group_name)
       raise_on_invalid_coverage({criterion => percent}, "minimum_coverage_by_group")
-      (minimum_coverage_by_group[group_name] ||= {})[criterion] = percent
+      # Normalize like `group` does, so `only: :Models` finds the group
+      # defined as `group "Models"` at check time instead of storing a
+      # Symbol key no lookup ever matches.
+      (minimum_coverage_by_group[GroupNames.normalize(group_name)] ||= {})[criterion] = percent
     end
 
     #

data/lib/simplecov/configuration/coverage_criteria.rb

@@ -3,33 +3,29 @@
 module SimpleCov
   # Selection and validation of the coverage criteria Ruby's `Coverage`
   # library should track. Supports `:line` (the historical default),
-  # `:branch`, `:method`, and `:oneshot_line`, plus the standalone
-  # `:eval` toggle for instrumenting `eval`'d code.
+  # `:branch`, `:method`, and `:oneshot_line`. The standalone `:eval`
+  # toggle lives in `eval_coverage.rb`.
   module Configuration
     SUPPORTED_COVERAGE_CRITERIA = %i[line branch method oneshot_line].freeze
     DEFAULT_COVERAGE_CRITERION = :line
     ONESHOT_LINE_COVERAGE_CRITERION = :oneshot_line
+    LINE_COVERAGE_ALTERNATIVES = {line: :oneshot_line, oneshot_line: :line}.freeze #: line_coverage_alternatives
+    private_constant :LINE_COVERAGE_ALTERNATIVES
 
     # Enable one or more coverage criteria. `:eval` is accepted as a
     # shorthand for the standalone eval-coverage toggle.
     def enable_coverage(*criteria)
-      criteria.each do |criterion|
-        if criterion == :eval
-          enable_eval_coverage
-        else
-          raise_if_criterion_unsupported(criterion)
-          # :oneshot_lines can not be combined with :lines
-          coverage_criteria.delete(DEFAULT_COVERAGE_CRITERION) if criterion == ONESHOT_LINE_COVERAGE_CRITERION
-          coverage_criteria << criterion
-        end
-      end
+      criteria.each { |criterion| criterion == :eval ? enable_eval_coverage : add_coverage_criterion(criterion) }
     end
 
     # Remove `criterion` from the set of enabled coverage criteria.
-    # Disabling every criterion raises at `start_tracking` (not here),
-    # so config files that toggle criteria in arbitrary order don't
-    # have to worry about transient empty states.
+    # `:eval` turns the standalone eval-coverage toggle back off,
+    # mirroring `enable_coverage`. Disabling every criterion raises at
+    # `start_tracking` (not here), so config files that toggle criteria
+    # in arbitrary order don't have to worry about transient empty states.
     def disable_coverage(criterion)
+      return disable_eval_coverage if criterion == :eval
+
       raise_if_criterion_unsupported(criterion)
       coverage_criteria.delete(criterion)
       @primary_coverage = nil if @primary_coverage == criterion
@@ -68,6 +64,15 @@ module SimpleCov
             "Re-enable one with `enable_coverage :line`, `:branch`, or `:method`."
     end
 
+    # Whether this run produces line data at all. The oneshot variant counts:
+    # `ResultAdapter` turns its executed-line list back into a line array. A
+    # branch-only or method-only run produces none, and `Coverage.result`
+    # entries for the files it loaded carry no `"lines"` key.
+    def line_coverage?
+      coverage_criterion_enabled?(DEFAULT_COVERAGE_CRITERION) ||
+        coverage_criterion_enabled?(ONESHOT_LINE_COVERAGE_CRITERION)
+    end
+
     def branch_coverage?
       branch_coverage_supported? && coverage_criterion_enabled?(:branch)
     end
@@ -84,10 +89,6 @@ module SimpleCov
       coverage_criterion_supported?(:methods)
     end
 
-    def coverage_for_eval_supported?
-      coverage_criterion_supported?(:eval)
-    end
-
     # Ask the Coverage runtime itself whether a criterion is supported
     # (Ruby >= 3.2). Older Rubies don't expose `Coverage.supported?`, so
     # fall back to the historical engine check that line/branch/method
@@ -104,27 +105,13 @@ module SimpleCov
     end
     # simplecov:enable
 
-    def coverage_for_eval_enabled?
-      @coverage_for_eval_enabled ||= false
-    end
-
-    # DEPRECATED: prefer `enable_coverage :eval`.
-    def enable_coverage_for_eval
-      SimpleCov::Deprecation.warn("`SimpleCov.enable_coverage_for_eval` is deprecated. " \
-                                  "Replace with `SimpleCov.enable_coverage :eval`.")
-      enable_eval_coverage
-    end
-
   private
 
-    # Shared implementation backing both `enable_coverage :eval` and
-    # the deprecated `enable_coverage_for_eval`.
-    def enable_eval_coverage
-      if coverage_for_eval_supported?
-        @coverage_for_eval_enabled = true
-      else
-        warn "Coverage for eval is not available; Use Ruby 3.2.0 or later"
-      end
+    def add_coverage_criterion(criterion)
+      raise_if_criterion_unsupported(criterion)
+      incompatible = LINE_COVERAGE_ALTERNATIVES[criterion]
+      disable_coverage(incompatible) if incompatible
+      coverage_criteria << criterion
     end
 
     # If `:line` is enabled, it's the default primary; otherwise fall
@@ -140,6 +127,15 @@ module SimpleCov
     end
 
     def raise_if_criterion_disabled(criterion)
+      # `coverage :eval` by itself IS supported — it's a standalone
+      # toggle, never in the enabled-criteria set — so the generic
+      # "unsupported criterion" message below would mislead here.
+      if criterion == :eval
+        raise SimpleCov::ConfigurationError,
+              "Coverage criterion :eval only toggles measuring eval'd code; " \
+              "it cannot carry thresholds or serve as the primary criterion"
+      end
+
       raise_if_criterion_unsupported(criterion)
       return if coverage_criterion_enabled?(criterion)
 

data/lib/simplecov/configuration/eval_coverage.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # The standalone eval-coverage toggle (`enable_coverage :eval`),
+  # instrumenting `eval`'d code on Rubies that support it. Kept separate
+  # from the criteria-set logic in `coverage_criteria.rb` because `:eval`
+  # is a boolean toggle, never a member of the enabled-criteria set.
+  module Configuration
+    def coverage_for_eval_supported?
+      coverage_criterion_supported?(:eval)
+    end
+
+    def coverage_for_eval_enabled?
+      @coverage_for_eval_enabled ||= false
+    end
+
+    # DEPRECATED: prefer `enable_coverage :eval`.
+    def enable_coverage_for_eval
+      SimpleCov::Deprecation.warn("`SimpleCov.enable_coverage_for_eval` is deprecated. " \
+                                  "Replace with `SimpleCov.enable_coverage :eval`.")
+      enable_eval_coverage
+    end
+
+  private
+
+    # Shared implementation backing both `enable_coverage :eval` and
+    # the deprecated `enable_coverage_for_eval`.
+    def enable_eval_coverage
+      if coverage_for_eval_supported?
+        @coverage_for_eval_enabled = true
+      else
+        warn "Coverage for eval is not available; Use Ruby 3.2.0 or later"
+      end
+    end
+
+    # No support check needed: off is a safe state on every Ruby.
+    def disable_eval_coverage
+      @coverage_for_eval_enabled = false
+    end
+  end
+end

data/lib/simplecov/configuration/filters.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Inclusion / exclusion / grouping methods: `cover`, `skip`, `group`,
-  # plus the deprecated `track_files` / `add_filter` / `add_group`
-  # aliases. Mutates the same `filters`, `groups`, and `cover_filters`
-  # collections the main Configuration module exposes.
+  # Inclusion and exclusion methods: `cover` and `skip`, plus the deprecated
+  # `track_files` and `add_filter` aliases.
   module Configuration
-    attr_writer :filters, :groups
+    attr_writer :filters
 
     #
     # Restrict the universe of files in the coverage report to those matching
@@ -43,7 +41,7 @@ module SimpleCov
     end
 
     # Returns the list of string globs passed to `cover` — used by the
-    # disk-discovery pass in `SimpleCov.add_not_loaded_files` so files
+    # disk-discovery pass in `SimpleCov.tracked_file_paths` so files
     # matching a `cover` glob appear in the report even when they were
     # never required during the suite.
     #
@@ -121,33 +119,6 @@ module SimpleCov
       @filters = []
     end
 
-    # Returns the configured groups. Add groups using SimpleCov.group.
-    def groups
-      @groups ||= {}
-    end
-
-    # Define a display group for files. Same matcher grammar as `skip`,
-    # but instead of dropping the matching files it bins them under
-    # `group_name` for the formatter. Files matched by no group fall
-    # into the implicit "Ungrouped" bucket.
-    def group(group_name, filter_argument = nil, &)
-      groups[group_name] = parse_filter(filter_argument, &)
-    end
-
-    # DEPRECATED: alias for `group`. Same arguments, same behavior.
-    def add_group(group_name, filter_argument = nil, &block)
-      example = if block
-                  "`SimpleCov.group #{group_name.inspect} { ... }`"
-                else
-                  "`SimpleCov.group #{group_name.inspect}, #{filter_argument.inspect}`"
-                end
-      SimpleCov::Deprecation.warn(
-        "`SimpleCov.add_group` is deprecated. " \
-        "Replace with `SimpleCov.group` (same arguments, same behavior). Example: #{example}."
-      )
-      group(group_name, filter_argument, &block)
-    end
-
     # Drop every filter previously installed (defaults plus anything
     # earlier in this block) so subsequent `skip` calls start from a
     # clean slate. Order matters — call this before your own `skip`
@@ -168,18 +139,14 @@ module SimpleCov
     end
 
     # Build a filter for a `cover` argument. Strings are treated as
-    # globs (not substrings — that's `skip`/`add_filter`'s semantics).
+    # globs (not substrings — that's `skip`/`add_filter`'s semantics);
+    # everything else dispatches exactly like `add_filter`.
     def build_cover_filter(arg)
-      case arg
-      when String            then SimpleCov::GlobFilter.new(arg)
-      when Regexp            then SimpleCov::RegexFilter.new(arg)
-      when Proc              then SimpleCov::BlockFilter.new(arg)
-      when SimpleCov::Filter then arg
-      when Array             then SimpleCov::ArrayFilter.new(arg.map { |a| build_cover_filter(a) })
-      else raise SimpleCov::ConfigurationError, "Unsupported `cover` argument #{arg.inspect}; " \
-                                                "expected a String glob, Regexp, Proc, " \
-                                                "SimpleCov::Filter, or Array of those."
-      end
+      SimpleCov::Filter.build_filter(arg, string_filter: SimpleCov::GlobFilter)
+    rescue SimpleCov::ConfigurationError
+      raise SimpleCov::ConfigurationError, "Unsupported `cover` argument #{arg.inspect}; " \
+                                           "expected a String glob, Regexp, Proc, " \
+                                           "SimpleCov::Filter, or Array of those."
     end
 
     # Walk a list of cover filters and return the string globs they hold,

data/lib/simplecov/configuration/formatting.rb

@@ -9,11 +9,16 @@ module SimpleCov
     attr_writer :formatter, :print_error_status
 
     #
-    # Gets or sets the configured formatter. Pass `false` (or `nil`) to
-    # opt out of formatting entirely — worker processes in big parallel
-    # CI setups (see #964) only need their `.resultset.json` on disk so
-    # a final `SimpleCov.collate` job can produce the report; running
-    # them without a formatter saves the per-job HTML/multi-formatter
+    # Gets or sets the configured formatter. Accepts a formatter class
+    # (instantiated fresh for every report) or a ready-built instance,
+    # which is how constructor options are passed — e.g.
+    # `formatter SimpleCov::Formatter::HTMLFormatter.new(silent: true)`
+    # to suppress the "Coverage report generated" status line (see
+    # #1240). Pass `false` (or `nil`) to opt out of formatting
+    # entirely — worker processes in big parallel CI setups (see #964)
+    # only need their `.resultset.json` on disk so a final
+    # `SimpleCov.collate` job can produce the report; running them
+    # without a formatter saves the per-job HTML/multi-formatter
     # overhead.
     #
     def formatter(formatter = :__no_arg__)
@@ -40,9 +45,13 @@ module SimpleCov
 
     # Sets the configured formatters. Equivalent to `formatters [...]`.
     # Accepts a single formatter as well as an Array, matching the pre-1.0 behavior
-    # where `MultiFormatter.new` normalized its input.
+    # where `MultiFormatter.new` normalized its input. Elements may be
+    # formatter classes or ready-built instances; see `formatter`.
+    # `nil`, `false`, and `[]` all opt out of formatting entirely —
+    # `false` normalized like `formatter false` does, since `Array(false)`
+    # would otherwise smuggle it in as a "formatter" that can only fail.
     def formatters=(formatters)
-      formatters = Array(formatters)
+      formatters = Array(formatters || nil)
       @formatter = formatters.empty? ? nil : SimpleCov::Formatter::MultiFormatter.new(formatters)
     end
 
@@ -83,8 +92,8 @@ module SimpleCov
     # a copy of the source tree (which dominates the payload on larger
     # projects).
     #
-    # The HTML viewer's `coverage_data.js` always includes source —
-    # the client-side renderer needs it. Only `coverage.json` honors
+    # The HTML report's embedded data always includes source — the
+    # client-side renderer needs it. Only `coverage.json` honors
     # this setting.
     #
     #     SimpleCov.start do

data/lib/simplecov/configuration/groups.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Group configuration is kept separate from inclusion and exclusion filters,
+  # while sharing their matcher parser through the main Configuration module.
+  module Configuration
+    # Returns the configured groups. Add groups using SimpleCov.group.
+    def groups
+      @groups ||= {}
+    end
+
+    def groups=(new_groups)
+      new_groups = new_groups.to_h { |name, filter| [GroupNames.normalize(name), filter] }
+      GroupNames.validate!(new_groups.keys)
+      @groups = new_groups
+    end
+
+    # Define a display group for files. Same matcher grammar as `skip`,
+    # but instead of dropping the matching files it bins them under
+    # `group_name` for the formatter. Files matched by no group fall
+    # into the implicit "Ungrouped" bucket.
+    def group(group_name, filter_argument = nil, &)
+      group_name = GroupNames.normalize(group_name)
+      GroupNames.validate!([group_name])
+      groups[group_name] = parse_filter(filter_argument, &)
+    end
+
+    # DEPRECATED: alias for `group`. Same arguments, same behavior.
+    def add_group(group_name, filter_argument = nil, &block)
+      example = if block
+                  "`SimpleCov.group #{group_name.inspect} { ... }`"
+                else
+                  "`SimpleCov.group #{group_name.inspect}, #{filter_argument.inspect}`"
+                end
+      SimpleCov::Deprecation.warn(
+        "`SimpleCov.add_group` is deprecated. " \
+        "Replace with `SimpleCov.group` (same arguments, same behavior). Example: #{example}."
+      )
+      group(group_name, filter_argument, &block)
+    end
+  end
+end

data/lib/simplecov/configuration/merging.rb

@@ -38,9 +38,7 @@ module SimpleCov
     def enable_for_subprocesses(value = nil)
       SimpleCov::Deprecation.warn("`SimpleCov.enable_for_subprocesses` is deprecated. " \
                                   "Replace with `SimpleCov.merge_subprocesses` (same value, same behavior).")
-      return @enable_for_subprocesses if defined?(@enable_for_subprocesses) && value.nil?
-
-      @enable_for_subprocesses = value || false
+      merge_subprocesses(value)
     end
 
     #
@@ -55,7 +53,7 @@ module SimpleCov
     end
 
     #
-    # Get or set whether this process owns final merge processing:
+    # Get or set whether SimpleCov's selected final process owns merge processing:
     # waiting for sibling workers, building the merged result, formatting,
     # enforcing thresholds, and writing `.last_run.json`.
     #
@@ -83,15 +81,18 @@ module SimpleCov
 
     # @api private
     def merge_finalization_owner?
-      collating_result? || finalize_merge?
+      collating_result? || (finalize_merge? && final_result_process?)
     end
 
     # DEPRECATED: alias for `merging`. Same value, same behavior.
+    # Delegating (rather than duplicating the body) also fixes the
+    # return value: this used to return nil where `merging` returns
+    # false, because the final expression was the skipped guard
+    # assignment rather than the stored value.
     def use_merging(use = nil)
       SimpleCov::Deprecation.warn("`SimpleCov.use_merging` is deprecated. " \
                                   "Replace with `SimpleCov.merging` (same value, same behavior).")
-      @use_merging = use unless use.nil?
-      @use_merging = true unless defined?(@use_merging) && @use_merging == false
+      merging(use)
     end
 
     #

data/lib/simplecov/configuration/thresholds.rb

@@ -14,9 +14,7 @@ module SimpleCov
     def minimum_coverage(coverage = nil)
       return @minimum_coverage ||= {} unless coverage
 
-      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage, "minimum_coverage")
-      @minimum_coverage = coverage
+      @minimum_coverage = normalized_threshold(coverage, "minimum_coverage")
     end
 
     def raise_on_invalid_coverage(coverage, coverage_setting)
@@ -35,9 +33,7 @@ module SimpleCov
     def maximum_coverage(coverage = nil)
       return @maximum_coverage ||= {} unless coverage
 
-      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage, "maximum_coverage")
-      @maximum_coverage = coverage
+      @maximum_coverage = normalized_threshold(coverage, "maximum_coverage")
     end
 
     #
@@ -58,9 +54,7 @@ module SimpleCov
     def maximum_coverage_drop(coverage_drop = nil)
       return @maximum_coverage_drop ||= {} unless coverage_drop
 
-      coverage_drop = {primary_coverage => coverage_drop} if coverage_drop.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage_drop, "maximum_coverage_drop")
-      @maximum_coverage_drop = coverage_drop
+      @maximum_coverage_drop = normalized_threshold(coverage_drop, "maximum_coverage_drop")
     end
 
     #
@@ -100,10 +94,8 @@ module SimpleCov
 
       SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_group` is deprecated. " \
                                   "Replace it with:\n#{per_group_coverage_replacement(coverage)}")
-      @minimum_coverage_by_group = coverage.dup.transform_values do |group_coverage|
-        group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
-        raise_on_invalid_coverage(group_coverage, "minimum_coverage_by_group")
-        group_coverage
+      @minimum_coverage_by_group = coverage.to_h do |group_name, group_coverage|
+        [GroupNames.normalize(group_name), normalized_threshold(group_coverage, "minimum_coverage_by_group")]
       end
     end
 
@@ -117,6 +109,15 @@ module SimpleCov
 
   private
 
+    # Shared normalize-and-validate step behind every threshold setter:
+    # a bare Numeric targets the primary criterion, and the resulting
+    # per-criterion hash is validated before it is stored.
+    def normalized_threshold(coverage, setting)
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+      raise_on_invalid_coverage(coverage, setting)
+      coverage
+    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}`