simplecov 0.22.0 → 1.1.1

data/lib/simplecov/combine/lines_combiner.rb

@@ -5,38 +5,68 @@ module SimpleCov
     #
     # Combine two different lines coverage results on same file
     #
-    # Should be called through `SimpleCov.combine`.
+    # Should be called through `CoverageAccumulator`.
     module LinesCombiner
     module_function
 
-      def combine(coverage_a, coverage_b)
-        coverage_a
-          .zip(coverage_b)
-          .map do |coverage_a_val, coverage_b_val|
-            merge_line_coverage(coverage_a_val, coverage_b_val)
-          end
-      end
-
-      # Return depends on coverage in a specific line
+      # Folds `source` into `target` rather than building a third array.
+      # Only for a `target` the caller owns outright: a caller holding a
+      # reference to it (e.g. the parsed `coverage` key of a resultset
+      # hash being passed into a second merge) would see it change.
+      # `source` is never touched.
       #
-      # @param [Integer || nil] first_val
-      # @param [Integer || nil] second_val
+      # Two runs of the same source file should agree on which lines
+      # are coverage-relevant (`nil` for comments / whitespace, `0`+
+      # for executable). When they don't, treat "relevant on either
+      # side" as relevant rather than masking a real `0` as `nil`,
+      # which would silently drop an uncovered line from the
+      # denominator and inflate the percentage:
       #
-      # Logic:
-      #
-      # => nil + 0 = nil
       # => nil + nil = nil
-      # => int + int = int
+      # => nil + int = int (preserves a relevant-but-uncovered 0)
+      # => int + int = int (sum)
+      #
+      # The loop is written out rather than dispatching a block per
+      # element because this is the innermost loop of a merge: a
+      # 160-worker run over ~1,800 files folds tens of millions of line
+      # counts through it, and a call per count is a measurable share of
+      # that.
       #
-      # @return [Integer || nil]
-      def merge_line_coverage(first_val, second_val)
-        sum = first_val.to_i + second_val.to_i
+      # @return [Array] the array to keep — `target` itself once there is one
+      def merge_into(target, source)
+        return target unless source
+        return source.dup unless target
 
-        if sum.zero? && (first_val.nil? || second_val.nil?)
-          nil
-        else
-          sum
+        size = source.size
+        target.concat(Array.new(size - target.size)) if target.size < size
+        sum_into(target, source, size)
+      end
+
+      # Split out only to keep `merge_into` short; it is the same loop.
+      #
+      # The `Integer` tests coerce malformed counts (a "3" written by a
+      # hand-edited or foreign resultset, a JSON float) with `to_i`, so
+      # external input merges to a wrong answer instead of raising out of
+      # the middle of a merge. An `is_a?` per count is far cheaper than
+      # the block dispatch this loop exists to avoid, and the well-formed
+      # fast path stays branch-for-branch what it was.
+      def sum_into(target, source, size)
+        index = 0
+        while index < size
+          if (value = source[index])
+            value = value.to_i unless value.is_a?(Integer)
+            existing = target[index]
+            target[index] = existing.is_a?(Integer) ? existing + value : coerce_add(existing, value)
+          end
+          index += 1
         end
+        target
+      end
+
+      # The rare arm: `existing` is nil (line not yet relevant in the
+      # target) or malformed external input.
+      def coerce_add(existing, value)
+        existing.nil? ? value : existing.to_i + value
       end
     end
   end

data/lib/simplecov/combine/methods_combiner.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../source_file/ruby_data_parser"
+require_relative "identity_interner"
+require_relative "interned_counts"
+
+module SimpleCov
+  module Combine
+    #
+    # Combine different method coverage results on a single file.
+    #
+    # Should be called through `CoverageAccumulator`.
+    module MethodsCombiner
+    module_function
+
+      #
+      # Return merged methods or the existing methods if other is missing.
+      #
+      # Method coverage maps `[class, name, start_line, start_col, end_line,
+      # end_col]` keys to hit counts. Keys are matched on their SOURCE
+      # identity — the location, ignoring the class and name elements —
+      # because Ruby records one entry per defined method: the same
+      # `define_method` block defined onto different classes, or under
+      # different names, in different processes arrives with different
+      # receivers or names for the same source method, and matching on the
+      # full key would keep both, letting a never-called copy's 0 shadow a
+      # covered method after merge (issue #1234). Combining sums the hit
+      # counts for matching methods and preserves methods that only appear
+      # in one result.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        merged = absorb({}, coverage_a) #: Hash[untyped, [untyped, Integer]]
+        materialize(absorb(merged, coverage_b))
+      end
+
+      # Folds `coverage` into `target`, an interned table keyed by method
+      # source identity. See `BranchesCombiner.absorb` for why a fold keeps
+      # its accumulator interned.
+      #
+      # A `nil` `target` stays `nil` until some resultset actually carries
+      # methods, so a merge can tell "no method data anywhere" apart from
+      # "method data that covers nothing".
+      #
+      # @return [Hash, nil] `target`, created on the first coverage seen
+      def absorb(target, coverage)
+        return target unless coverage
+
+        target ||= {} #: Hash[untyped, [untyped, Integer]]
+        InternedCounts.absorb_counts(target, coverage, identities)
+      end
+
+      # Turns an interned table back into the tuple-keyed hash the rest of
+      # SimpleCov reads. Done once, at the end of a fold.
+      #
+      # @return [Hash]
+      def materialize(target)
+        target.values.to_h
+      end
+
+      # Bounded by the project's method count, like `RubyDataParser`'s parse
+      # cache.
+      def identities
+        @identities ||= IdentityInterner.build { |key| source_identity(key) }
+      end
+
+      def source_identity(key)
+        _class_name, _method_name, *location = SourceFile::RubyDataParser.call(key)
+        location.freeze
+      end
+    end
+  end
+end

data/lib/simplecov/combine/results_combiner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "coverage_accumulator"
+
 module SimpleCov
   module Combine
     # There might be reports from different kinds of tests,
@@ -12,48 +14,23 @@ module SimpleCov
 
       #
       # Combine process explanation
-      # => ResultCombiner: define all present files between results and start combine on file level.
-      # ==> FileCombiner: collect result of next combine levels lines and branches.
+      # => ResultsCombiner: hand every result to one accumulator.
+      # ==> CoverageAccumulator::MergedFile: hold one file's merged coverage.
       # ===> LinesCombiner: combine lines results.
       # ===> BranchesCombiner: combine branches results.
+      # ===> MethodsCombiner: combine methods results.
       #
-      # @return [Hash]
-      #
-      def combine(*results)
-        results.reduce({}) do |combined_results, next_result|
-          combine_result_sets(combined_results, next_result)
-        end
-      end
-
-      #
-      # Manage combining results on files level
-      #
-      # @param [Hash] combined_results
-      # @param [Hash] result
+      # Callers that read their results one at a time (`ResultMerger`, to
+      # keep a big CI run's resultsets out of memory all at once) should
+      # drive a `CoverageAccumulator` directly instead of collecting the
+      # results to pass here.
       #
       # @return [Hash]
       #
-      def combine_result_sets(combined_results, result)
-        results_files = combined_results.keys | result.keys
-
-        results_files.each_with_object({}) do |file_name, file_combination|
-          file_combination[file_name] = combine_file_coverage(
-            combined_results[file_name],
-            result[file_name]
-          )
-        end
-      end
-
-      #
-      # Combine two files coverage results
-      #
-      # @param [Hash] coverage_a
-      # @param [Hash] coverage_b
-      #
-      # @return [Hash]
-      #
-      def combine_file_coverage(coverage_a, coverage_b)
-        Combine.combine(Combine::FilesCombiner, coverage_a, coverage_b)
+      def combine(*results)
+        accumulator = CoverageAccumulator.new
+        results.each { |result| accumulator.absorb(result) }
+        accumulator.result || {}
       end
     end
   end

data/lib/simplecov/combine.rb

@@ -1,30 +1,12 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Functionally for combining coverage results
+  # Namespace for the pieces that combine coverage results.
+  #
+  # `CoverageAccumulator` is the entry point: it folds any number of
+  # resultsets together, delegating one file's lines, branches and methods to
+  # the combiner modules alongside it.
   #
   module Combine
-  module_function
-
-    #
-    # Combine two coverage based on the given combiner_module.
-    #
-    # Combiners should always be called through this interface,
-    # as it takes care of short-circuiting of one of the coverages is nil.
-    #
-    # @return [Hash]
-    def combine(combiner_module, coverage_a, coverage_b)
-      return existing_coverage(coverage_a, coverage_b) if empty_coverage?(coverage_a, coverage_b)
-
-      combiner_module.combine(coverage_a, coverage_b)
-    end
-
-    def empty_coverage?(coverage_a, coverage_b)
-      !(coverage_a && coverage_b)
-    end
-
-    def existing_coverage(coverage_a, coverage_b)
-      coverage_a || coverage_b
-    end
   end
 end

data/lib/simplecov/command_guesser.rb

@@ -11,53 +11,124 @@ 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_env || from_command_line_options || from_defined_constants
+        framework = from_executable_name || from_command_line_options || from_defined_constants
+        [framework, parallel_data].compact.join(" ")
       end
 
     private
 
-      def from_env
-        # If being run from inside parallel_tests set the command name according to the process number
-        return unless ENV["PARALLEL_TEST_GROUPS"] && ENV["TEST_ENV_NUMBER"]
+      # When parallel_tests (or a compatible runner) is driving the suite,
+      # tag the command name with this worker's position in the pool.
+      def parallel_data
+        groups, number = ENV.values_at("PARALLEL_TEST_GROUPS", "TEST_ENV_NUMBER")
+        return unless groups && number
 
-        number = ENV["TEST_ENV_NUMBER"]
+        # parallel_tests sets the first worker's TEST_ENV_NUMBER to "" rather
+        # than "1"; restore the position so the rendered label reads cleanly.
         number = "1" if number.empty?
-        "(#{number}/#{ENV['PARALLEL_TEST_GROUPS']})"
+        "(#{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{#{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
+
       def from_command_line_options
-        case original_run_command
-        when /test\/functional\//, /test\/\{.*functional.*\}\//
-          "Functional Tests"
-        when /test\/integration\//
-          "Integration Tests"
-        when /test\//
-          "Unit Tests"
-        when /spec/
-          "RSpec"
-        when /cucumber/, /features/
-          "Cucumber Features"
-        end
+        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.
+      DEFINED_CONSTANT_FRAMEWORKS = [
+        ["RSpec",      -> { defined?(::RSpec) }],
+        ["Unit Tests", -> { defined?(Test::Unit) }],   # simplecov:disable
+        ["Minitest",   -> { defined?(::Minitest) }],   # simplecov:disable
+        ["MiniTest",   -> { defined?(MiniTest) }]      # simplecov:disable
+      ].freeze
+      private_constant :DEFINED_CONSTANT_FRAMEWORKS
+
+      # If the command regexps fail, let's try checking defined constants.
       def from_defined_constants
-        # If the command regexps fail, let's try checking defined constants.
-        if defined?(RSpec)
-          "RSpec"
-        elsif defined?(Test::Unit)
-          "Unit Tests"
-        elsif defined?(Minitest)
-          "Minitest"
-        elsif defined?(MiniTest)
-          "MiniTest"
-        else
-          # TODO: Provide link to docs/wiki article
-          warn "SimpleCov failed to recognize the test framework and/or suite used. Please specify manually using SimpleCov.command_name 'Unit Tests'."
-          "Unknown Test Framework"
-        end
+        # simplecov:disable branch — first iter returns when ::RSpec is defined; later branches unreachable
+        DEFINED_CONSTANT_FRAMEWORKS.each { |name, defined_check| return name if defined_check.call }
+        # simplecov:enable branch
+
+        # TODO: Provide link to docs/wiki article
+        # simplecov:disable — only fires when no framework is detected, which
+        # is impossible while our own specs are running under rspec
+        warn(
+          "SimpleCov failed to recognize the test framework and/or suite used. " \
+          "Please specify manually using SimpleCov.command_name 'Unit Tests'."
+        )
+        "Unknown Test Framework"
+        # simplecov:enable
       end
     end
   end

data/lib/simplecov/configuration/coverage.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # The `coverage` configuration method configures each coverage criterion
+  # (`:line`, `:branch`, `:method`, `:eval`) uniformly in one place: naming a
+  # criterion enables it,
+  # and every threshold is declared with the same syntax regardless of which
+  # criterion it applies to. Because the criterion is fixed by the enclosing
+  # `coverage` call, threshold values are always plain percentages — there is
+  # no per-criterion Hash competing with the value for a slot.
+  #
+  #   SimpleCov.start do
+  #     coverage :line do
+  #       minimum          90
+  #       minimum_per_file 80
+  #       minimum_per_file 100, only: "app/mailers/request_mailer.rb"
+  #       maximum_drop     5
+  #     end
+  #
+  #     coverage :branch, minimum: 80
+  #     coverage :method, minimum: 100
+  #   end
+  #
+  # Line coverage is enabled by default, so `coverage :line` is only needed to
+  # set line thresholds or options. Thresholds feed the same internal stores
+  # as the flat `minimum_coverage` family, so enforcement is unchanged.
+  module Configuration
+    # One-liner keyword options `coverage` accepts, each forwarding to the
+    # `CoverageCriterion` verb of the same name. `minimum_per_group` is omitted
+    # because it needs an `only:` target, so it's block-only.
+    COVERAGE_THRESHOLD_OPTIONS = %i[minimum maximum exact maximum_drop minimum_per_file].freeze
+
+    #
+    # Configure (and, unless `enabled: false`, enable) a coverage criterion.
+    #
+    # Threshold options mirror the block verbs for one-liner use:
+    #   coverage :branch, minimum: 80, maximum_drop: 5
+    #
+    # `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.
+    #
+    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 a standalone toggle, never in the enabled-criteria set).
+      primary_coverage(_ = criterion) if primary
+
+      configurator = CoverageCriterion.new(self, criterion)
+      apply_threshold_options(configurator, thresholds)
+      configurator.instance_eval(&block) if block
+
+      criterion
+    end
+
+  private
+
+    # Forward the one-liner threshold keywords (`coverage :branch, minimum: 80`)
+    # to the matching `CoverageCriterion` verbs, rejecting anything that isn't a
+    # recognized threshold option.
+    def apply_threshold_options(configurator, options)
+      options.each do |verb, value|
+        unless COVERAGE_THRESHOLD_OPTIONS.include?(verb)
+          raise SimpleCov::ConfigurationError,
+                "Unknown `coverage` option #{verb.inspect}. " \
+                "Supported options are #{COVERAGE_THRESHOLD_OPTIONS.inspect}."
+        end
+
+        configurator.public_send(verb, value)
+      end
+    end
+
+    # 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:)
+      criterion = resolve_criterion_variant(criterion, oneshot)
+      enabled ? enable_coverage(criterion) : disable_coverage(criterion)
+      criterion
+    end
+
+    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
+
+      ONESHOT_LINE_COVERAGE_CRITERION
+    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.
+    def store_overall_threshold(setting, criterion, percent)
+      raise_on_invalid_coverage({criterion => percent}, setting.to_s)
+      public_send(setting)[criterion] = percent
+    end
+
+    def store_minimum_per_file(criterion, percent, target)
+      raise_on_invalid_coverage({criterion => percent}, "minimum_coverage_by_file")
+      return minimum_coverage_by_file[criterion] = percent if target.nil?
+
+      unless target.is_a?(String) || target.is_a?(Regexp)
+        raise SimpleCov::ConfigurationError, "`only:` must be a String path or Regexp, got #{target.inspect}"
+      end
+
+      (minimum_coverage_by_file_overrides[target] ||= {})[criterion] = percent
+    end
+
+    def store_minimum_per_group(criterion, percent, group_name)
+      raise_on_invalid_coverage({criterion => percent}, "minimum_coverage_by_group")
+      # 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
+
+    #
+    # Receiver for a `coverage <criterion> do ... end` block. Each verb writes a
+    # threshold for the single criterion the block configures, so the value is
+    # always a plain percentage (`minimum_per_file 100` is unambiguous) and the
+    # syntax is identical across line, branch, and method coverage.
+    #
+    class CoverageCriterion
+      def initialize(config, criterion)
+        @config = config
+        @criterion = criterion
+      end
+
+      # Overall (suite-wide) minimum for this criterion.
+      def minimum(percent)
+        @config.send(:store_overall_threshold, :minimum_coverage, @criterion, percent)
+      end
+
+      # Overall maximum: fails the build if coverage rises above it. Paired with
+      # `minimum` (or via `exact`) this pins coverage so an unexpected jump fails.
+      def maximum(percent)
+        @config.send(:store_overall_threshold, :maximum_coverage, @criterion, percent)
+      end
+
+      # Pin coverage to an exact figure (sets both `minimum` and `maximum`).
+      def exact(percent)
+        minimum(percent)
+        maximum(percent)
+      end
+
+      # Maximum allowed drop between runs (`maximum_drop 0` refuses any drop).
+      def maximum_drop(percent)
+        @config.send(:store_overall_threshold, :maximum_coverage_drop, @criterion, percent)
+      end
+
+      # Per-file minimum. With no `only:`, sets the default applied to every
+      # file; with `only:` (a String path or Regexp), overrides that default
+      # for the matching files.
+      def minimum_per_file(percent, only: nil)
+        @config.send(:store_minimum_per_file, @criterion, percent, only)
+      end
+
+      # Per-group minimum for the named group (defined via `group`).
+      def minimum_per_group(percent, only:)
+        @config.send(:store_minimum_per_group, @criterion, percent, only)
+      end
+
+      # Make this criterion the report's primary (leading) criterion.
+      def primary
+        # @criterion is Symbol-wide because this receiver is also built for
+        # :eval; primary_coverage validates at runtime.
+        @config.primary_coverage(_ = @criterion)
+      end
+    end
+  end
+end