simplecov 0.22.0 → 1.0.0.rc2

data/lib/simplecov/parallel_coordination.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# simplecov:disable
+# Methods below only fire under a parallel test runner; not reachable
+# from a single-process rspec run. Cucumber's test_projects exercise
+# the parallel_tests integration end-to-end in subprocesses, but
+# those subprocesses don't merge their Coverage data back into the
+# parent this dogfood report measures.
+module SimpleCov
+  class << self
+    # @api private
+    # How long the first worker is willing to wait for all sibling
+    # workers' resultsets to appear in the cache before proceeding
+    # with whatever it has. Tuned generously enough that slow CI
+    # runners with one straggler don't trip the "incomplete results"
+    # path on a routine basis. See #1065 for the parallel_rspec /
+    # GenericAdapter case where there is no native wait primitive
+    # and this poll is the only synchronization available.
+    PARALLEL_RESULTS_WAIT_TIMEOUT = 60
+    private_constant :PARALLEL_RESULTS_WAIT_TIMEOUT
+
+    # @api private
+    def final_result_process?
+      adapter = SimpleCov::ParallelAdapters.current
+      return true unless adapter
+
+      adapter.first_worker?
+    end
+
+    # @api private
+    def wait_for_other_processes
+      adapter = SimpleCov::ParallelAdapters.current
+      return unless adapter && final_result_process?
+
+      # Native synchronization first (adapters that wrap a runner with a
+      # real "wait" primitive — parallel_tests'
+      # `wait_for_other_processes_to_finish` — implement this; adapters
+      # without a native API no-op and rely on the polling fallback below).
+      adapter.wait_for_siblings
+
+      # The native wait can return before sibling at_exit handlers finish
+      # writing resultsets, and adapters without a native wait have
+      # nothing else. Either way, poll the resultset cache until all
+      # expected workers have reported or a timeout is reached. Capture
+      # the outcome so `ready_to_process_results?` can suppress min/max
+      # threshold checks against a partial total.
+      @parallel_results_complete = wait_for_parallel_results(adapter.expected_worker_count)
+    end
+
+    # @api private — true when every sibling reported its resultset
+    # before the wait deadline. Defaults to true outside a parallel
+    # run (when `wait_for_other_processes` is a no-op).
+    def parallel_results_complete?
+      defined?(@parallel_results_complete) ? @parallel_results_complete : true
+    end
+
+    # @api private — returns true when every expected worker reported
+    # before the deadline, false on timeout. Single-process runs
+    # (expected <= 1) short-circuit to true with no waiting.
+    def wait_for_parallel_results(expected)
+      return true unless expected > 1 # simplecov:disable branch — only false in real parallel runs
+
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + PARALLEL_RESULTS_WAIT_TIMEOUT
+      loop do
+        seen = SimpleCov::ResultMerger.read_resultset.size
+        return true if seen >= expected
+        return false if parallel_wait_timed_out?(deadline, expected, seen)
+
+        sleep 0.1
+      end
+    end
+
+    # @api private — true once the wait deadline has passed; warns on
+    # the first timeout so the user knows the merged total is partial.
+    def parallel_wait_timed_out?(deadline, expected, seen)
+      return false unless Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+
+      warn_about_incomplete_parallel_results(expected, seen)
+      true
+    end
+
+    # @api private
+    def warn_about_incomplete_parallel_results(expected, seen)
+      return unless print_errors
+
+      warn SimpleCov::Color.colorize(
+        "Only #{seen} of #{expected} parallel-test workers reported within " \
+        "#{PARALLEL_RESULTS_WAIT_TIMEOUT}s. Coverage totals are partial; " \
+        "minimum / maximum coverage checks are skipped for this run.",
+        :yellow
+      )
+    end
+  end
+end
+# simplecov:enable

data/lib/simplecov/process.rb

@@ -1,19 +1,31 @@
 # frozen_string_literal: true
 
-module Process
-  class << self
-    def fork_with_simplecov(&block)
-      if defined?(SimpleCov) && SimpleCov.running
-        fork_without_simplecov do
-          SimpleCov.at_fork.call(Process.pid)
-          block.call if block_given?
-        end
-      else
-        fork_without_simplecov(&block)
-      end
-    end
+# Hooks `Process._fork` (Ruby 3.1+) so child processes inherit SimpleCov's
+# coverage tracking when `SimpleCov.enable_for_subprocesses?` is set.
+#
+# `Process._fork` is the official extension point: `Kernel#fork`,
+# `Process.fork`, `IO.popen("-")`, and similar all funnel through it.
+# Hooking `_fork` (instead of redefining `Process.fork`) composes
+# correctly with other libraries doing the same — they each prepend
+# their own module and chain via `super`.
 
-    alias fork_without_simplecov fork
-    alias fork fork_with_simplecov
+module SimpleCov
+  # Prepended onto Process's singleton class so every fork — direct or
+  # via Kernel#fork / IO.popen — re-runs SimpleCov's at_fork callback in
+  # the child.
+  module ProcessForkHook
+    def _fork
+      active = defined?(SimpleCov) && Coverage.running?
+      # Assign the next serial in the PARENT, before the fork, so the child
+      # inherits its own stable ordinal via copy-on-write. The default
+      # at_fork uses it (instead of the child pid) to name the subprocess's
+      # result, keeping that name identical across runs. See issue #1171.
+      SimpleCov.next_subprocess_serial! if active
+      pid = super
+      SimpleCov.at_fork.call(::Process.pid) if pid.zero? && active
+      pid
+    end
   end
 end
+
+Process.singleton_class.prepend(SimpleCov::ProcessForkHook)

data/lib/simplecov/profiles/bundler_filter.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "bundler_filter" do
-  add_filter "/vendor/bundle/"
+  skip "/vendor/bundle/"
 end

data/lib/simplecov/profiles/hidden_filter.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "hidden_filter" do
-  add_filter %r{^/\..*}
+  skip(/\A\..*/)
 end

data/lib/simplecov/profiles/rails.rb

@@ -3,16 +3,30 @@
 SimpleCov.profiles.define "rails" do
   load_profile "test_frameworks"
 
-  add_filter %r{^/config/}
-  add_filter %r{^/db/}
+  skip %r{\Aconfig/}
+  skip %r{\Adb/}
 
-  add_group "Controllers", "app/controllers"
-  add_group "Channels", "app/channels"
-  add_group "Models", "app/models"
-  add_group "Mailers", "app/mailers"
-  add_group "Helpers", "app/helpers"
-  add_group "Jobs", %w[app/jobs app/workers]
-  add_group "Libraries", "lib/"
+  group "Controllers", "app/controllers"
+  group "Channels", "app/channels"
+  group "Models", "app/models"
+  group "Mailers", "app/mailers"
+  group "Helpers", "app/helpers"
+  group "Jobs", %w[app/jobs app/workers]
+  group "Libraries", "lib/"
 
-  track_files "{app,lib}/**/*.rb"
+  # Preserve the legacy `track_files` semantics (additive disk-discovery
+  # without restricting the report's universe): write the ivar directly
+  # so loading the profile doesn't emit the public-API deprecation. Users
+  # migrating their own configs should prefer `cover "{app,lib}/**/*.rb"`,
+  # which both injects unloaded files and scopes the report to the match
+  # set — usually the intended behavior for a Rails project.
+  @tracked_files = "{app,lib}/**/*.rb"
+
+  # `parallelize(workers: ...)` forks worker processes that each run a
+  # slice of the suite. Without subprocess support, the workers' coverage
+  # is dropped on the floor and the parent records 0% for everything they
+  # touched. Hooking `Process._fork` makes each worker re-call
+  # `SimpleCov.start` with a unique command_name so the resultsets merge
+  # correctly.
+  merge_subprocesses true
 end

data/lib/simplecov/profiles/root_filter.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "root_filter" do
-  # Exclude all files outside of simplecov root
-  root_filter = nil
-  add_filter do |src|
-    root_filter ||= /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/io
-    src.filename !~ root_filter
+  # Exclude all files outside of simplecov root. Shares the regex with
+  # SimpleCov::UselessResultsRemover so the root-prefix logic lives in one
+  # place; this profile is the user-facing entry point that tools like
+  # `SimpleCov.filtered` apply.
+  skip do |src|
+    src.filename !~ SimpleCov::UselessResultsRemover.root_regex
   end
 end

data/lib/simplecov/profiles/strict.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A "no shortfalls allowed" profile: every coverage criterion is
+# enabled and held to 100%. Per
+# https://github.com/simplecov-ruby/simplecov/issues/1061, this lives as
+# an opt-in profile rather than the default — most projects can't
+# realistically start at 100% on day one — so a team that has paid down
+# the debt can flip the strict switch without re-typing the threshold
+# trio every time.
+#
+# JRuby gracefully degrades: `enable_coverage :branch` / `:method` are
+# accepted (they just add to the configured criteria set), but the
+# runtime can't actually measure them, so the corresponding stats never
+# materialize. `CoverageViolations` skips threshold lookups for
+# criteria not in the stats, so the `:branch` / `:method` clauses below
+# silently no-op on JRuby and only `:line` is enforced.
+#
+# `:eval` widens the universe of code held to 100% to include strings
+# passed through `Kernel#eval` (typically ERB templates, when the user
+# sets `ERB#filename=`). Guarded on `coverage_for_eval_supported?` so
+# the profile stays quiet on Ruby < 3.2, where `enable_coverage :eval`
+# would otherwise warn about the missing runtime support every time
+# the profile loads.
+SimpleCov.profiles.define "strict" do
+  enable_coverage :branch
+  enable_coverage :method
+  # simplecov:disable branch — dogfood runs on Ruby >= 3.2 only, so
+  # the else arm (eval coverage not supported) is unreachable from CI.
+  enable_coverage :eval if coverage_for_eval_supported?
+  # simplecov:enable
+  minimum_coverage line: 100, branch: 100, method: 100
+end

data/lib/simplecov/profiles/test_frameworks.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "test_frameworks" do
-  add_filter "/test/"
-  add_filter "/features/"
-  add_filter "/spec/"
-  add_filter "/autotest/"
+  skip %r{\A(test|features|spec|autotest)/}
 end

data/lib/simplecov/profiles.rb

@@ -17,7 +17,7 @@ module SimpleCov
     #
     def define(name, &blk)
       name = name.to_sym
-      raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+      raise SimpleCov::ConfigurationError, "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
 
       self[name] = blk
     end
@@ -26,10 +26,39 @@ module SimpleCov
     # Applies the profile of given name on SimpleCov.configure
     #
     def load(name)
+      SimpleCov.configure(&fetch_proc(name))
+    end
+
+    #
+    # Returns the proc registered for the given profile name, autoloading
+    # bundled or plugin-gem profiles on first lookup. Raises if the profile
+    # cannot be located.
+    #
+    # Lookup order:
+    #   1. already registered via #define
+    #   2. require "simplecov/profiles/<name>"   (bundled profiles)
+    #   3. require "simplecov-profile-<name>"    (third-party plugin gems)
+    #
+    def fetch_proc(name)
       name = name.to_sym
-      raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+      autoload_profile(name) unless key?(name)
+      return self[name] if key?(name)
+
+      raise SimpleCov::ConfigurationError, "Could not find SimpleCov Profile called '#{name}'"
+    end
+
+  private
 
-      SimpleCov.configure(&self[name])
+    def autoload_profile(name)
+      require "simplecov/profiles/#{name}"
+    rescue LoadError
+      begin
+        # simplecov:disable — third-party gem fallback (no such gem in test env)
+        require "simplecov-profile-#{name}"
+        # simplecov:enable
+      rescue LoadError
+        # fall through; #fetch_proc raises the user-facing error
+      end
     end
   end
 end

data/lib/simplecov/result/missing_source_files_reporter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    # When a resultset references source files that don't exist on the local
+    # filesystem they're silently dropped — which produces an empty `0 / 0
+    # (100.00%)` report that looks like success but isn't. Emit a single
+    # warning summarizing the drop and, when every entry was lost, point at
+    # the typical cause (`SimpleCov.collate` invoked from a machine or path
+    # different from where the resultsets were generated). See #980.
+    class MissingSourceFilesReporter
+      def initialize(missing_paths, input_size:, every_entry_dropped:)
+        @missing_paths = missing_paths
+        @input_size = input_size
+        @every_entry_dropped = every_entry_dropped
+      end
+
+      def warn!
+        warn SimpleCov::Color.colorize(message, :yellow)
+      end
+
+      def message
+        @every_entry_dropped ? all_missing_warning : partial_missing_warning
+      end
+
+    private
+
+      def all_missing_warning
+        "SimpleCov dropped all #{@missing_paths.size} source file(s) from the result — " \
+          "none of the paths in the resultset exist on this filesystem: " \
+          "#{summary}. If you're running `SimpleCov.collate`, the source " \
+          "files must be available at the same absolute paths as when the individual resultsets " \
+          "were generated."
+      end
+
+      def partial_missing_warning
+        "SimpleCov dropped #{@missing_paths.size} source file(s) from the result because " \
+          "they don't exist on this filesystem: #{summary}. They were " \
+          "tracked in the resultset but have since moved or been removed."
+      end
+
+      def summary
+        sample = @missing_paths.first(5).join(", ")
+        remaining = @missing_paths.size - 5
+        remaining.positive? ? "#{sample} (+#{remaining} more)" : sample
+      end
+    end
+  end
+end

data/lib/simplecov/result/source_file_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    # Constructs `SimpleCov::SourceFile` instances from a raw coverage
+    # hash, sorts them by filename, and surfaces filenames whose source
+    # is no longer present on disk so the caller can warn about the
+    # silent drop (see #980).
+    class SourceFileBuilder
+      attr_reader :missing_source_files
+
+      def initialize(original_result, not_loaded_files:)
+        @original_result = original_result
+        @not_loaded_files = not_loaded_files
+        @missing_source_files = []
+      end
+
+      def call
+        SimpleCov::FileList.new(
+          @original_result
+            .filter_map { |filename, coverage| build_source_file(filename, coverage) }
+            .sort_by(&:filename)
+        )
+      end
+
+    private
+
+      def build_source_file(filename, coverage)
+        unless File.file?(filename)
+          @missing_source_files << filename
+          return
+        end
+
+        SimpleCov::SourceFile.new(
+          filename,
+          stringify_outer_keys(coverage),
+          loaded: !@not_loaded_files.include?(filename)
+        )
+      end
+
+      # `Coverage.result` returns symbol keys (`:lines`, `:branches`,
+      # `:methods`); resultsets loaded from disk are already string-keyed.
+      # SourceFile reads with strings, and handles both Array and
+      # stringified-Array branch/method keys via `restore_ruby_data_structure`,
+      # so only the outer hash needs normalizing.
+      def stringify_outer_keys(coverage)
+        coverage.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/simplecov/result.rb

@@ -2,6 +2,8 @@
 
 require "digest/sha1"
 require "forwardable"
+require_relative "result/missing_source_files_reporter"
+require_relative "result/source_file_builder"
 
 module SimpleCov
   #
@@ -10,9 +12,11 @@ module SimpleCov
   #
   class Result
     extend Forwardable
+
     # Returns the original Coverage.result used for this instance of SimpleCov::Result
     attr_reader :original_result
-    # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+    # Returns all files that are applicable to this result (sans filters!) as instances of
+    # SimpleCov::SourceFile. Aliased as :source_files
     attr_reader :files
     alias source_files files
     # Explicitly set the Time this result has been created
@@ -20,20 +24,47 @@ module SimpleCov
     # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
     attr_writer :command_name
 
-    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics, :coverage_statistics_by_file
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength,
+                   :covered_lines, :missed_lines,
+                   :total_branches, :covered_branches, :missed_branches,
+                   :total_methods, :covered_methods, :missed_methods,
+                   :coverage_statistics, :coverage_statistics_by_file
     def_delegator :files, :lines_of_code, :total_lines
 
+    # Bundles the filter and grouping configuration a Result applies to its
+    # source files after building them. Each field defaults to the SimpleCov
+    # singleton's configuration, so ordinary callers never construct one;
+    # tests pass a custom instance to opt out of (or extend) the project's
+    # filters or groups (e.g. `filters: []` to keep every file). Grouping the
+    # three together keeps Result#initialize's parameter list small.
+    class FilterConfig
+      attr_reader :filters, :cover_filters, :groups
+
+      def initialize(filters: SimpleCov.filters, cover_filters: SimpleCov.cover_filters, groups: SimpleCov.groups)
+        @filters = filters
+        @cover_filters = cover_filters
+        @groups = groups
+      end
+    end
+
     # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
-    # coverage data)
-    def initialize(original_result, command_name: nil, created_at: nil)
-      result = original_result
-      @original_result = result.freeze
+    # coverage data).
+    #
+    # `filter_config` defaults to the SimpleCov singleton's filter / group
+    # configuration so existing call sites are unchanged. Pass a custom
+    # FilterConfig to opt out — useful for tests that build synthetic Results
+    # and don't want the project's filters or groups applied.
+    def initialize(original_result, command_name: nil, created_at: nil, not_loaded_files: Set.new,
+                   filter_config: FilterConfig.new)
+      @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
-      @files = SimpleCov::FileList.new(result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
-      end.compact.sort_by(&:filename))
-      filter!
+      @groups_config = filter_config.groups
+      builder = SourceFileBuilder.new(original_result, not_loaded_files: not_loaded_files)
+      @files = builder.call
+      warn_about_missing_source_files(builder.missing_source_files, original_result.size)
+      apply_cover_filters!(filter_config.cover_filters)
+      apply_filters!(filter_config.filters)
     end
 
     # Returns all filenames for source files contained in this result
@@ -41,14 +72,37 @@ module SimpleCov
       files.map(&:filename)
     end
 
-    # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
+    # Returns the SimpleCov::SourceFile for the given path, or nil if no
+    # matching file is in this result. The path is resolved against
+    # SimpleCov.root, so callers can pass either an absolute path or a
+    # project-relative one.
+    def source_file_for(path)
+      target = File.expand_path(path, SimpleCov.root)
+      files.find { |file| file.filename == target }
+    end
+
+    # Returns the {line:/branch:/method:} coverage_statistics hash for the
+    # given file path, or nil if no matching source file is in this
+    # result. See SimpleCov::Result#source_file_for for path resolution.
+    def coverage_for(path)
+      source_file_for(path)&.coverage_statistics
+    end
+
+    # Returns a Hash of groups for this result. Define groups using SimpleCov.group 'Models', 'app/models'
     def groups
-      @groups ||= SimpleCov.grouped(files)
+      @groups ||= SimpleCov.grouped(files, groups: @groups_config)
     end
 
-    # Applies the configured SimpleCov.formatter on this result
+    # Applies the configured SimpleCov.formatter on this result. Returns
+    # nil if formatting has been opted out of (`SimpleCov.formatter false`
+    # / `SimpleCov.formatters []`) — the cheap path for non-final
+    # processes in a parallel CI run, which only need their
+    # `.resultset.json` on disk. See #964.
     def format!
-      SimpleCov.formatter.new.format(self)
+      formatter = SimpleCov.formatter
+      return nil if formatter.nil?
+
+      formatter.new.format(self)
     end
 
     # Defines when this result has been created. Defaults to Time.now
@@ -81,14 +135,38 @@ module SimpleCov
 
   private
 
+    def warn_about_missing_source_files(missing, input_size)
+      return if missing.empty?
+
+      MissingSourceFilesReporter.new(
+        missing,
+        input_size: input_size,
+        every_entry_dropped: @files.empty? && missing.size == input_size
+      ).warn!
+    end
+
     def coverage
-      keys = original_result.keys & filenames
-      Hash[keys.zip(original_result.values_at(*keys))]
+      original_result.slice(*filenames)
     end
 
-    # Applies all configured SimpleCov filters on this result's source files
-    def filter!
-      @files = SimpleCov.filtered(files)
+    # Applies the given filter chain to `@files`, dropping each source
+    # file that any filter matches.
+    def apply_filters!(filters)
+      filters.each do |filter|
+        @files = SimpleCov::FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
+      end
+    end
+
+    # When any `cover` matcher is configured, restrict `@files` to source
+    # files matching at least one of them. With no cover matchers configured
+    # this is a no-op, preserving the historical "everything required, then
+    # filtered" universe.
+    def apply_cover_filters!(cover_filters)
+      return if cover_filters.empty?
+
+      @files = SimpleCov::FileList.new(
+        @files.select { |source_file| cover_filters.any? { |filter| filter.matches?(source_file) } }
+      )
     end
   end
 end

data/lib/simplecov/result_adapter.rb

@@ -18,13 +18,75 @@ module SimpleCov
     def adapt
       return unless result
 
-      result.each_with_object({}) do |(file_name, cover_statistic), adapted_result|
-        if cover_statistic.is_a?(Array)
-          adapted_result.merge!(file_name => {"lines" => cover_statistic})
-        else
-          adapted_result.merge!(file_name => cover_statistic)
-        end
+      result.to_h do |file_name, cover_statistic|
+        [file_name, adapt_one(file_name, cover_statistic)]
       end
     end
+
+  private
+
+    # Pre-0.18 resultsets pointed each filename straight at a line-coverage
+    # array; everything since uses the `{lines:, branches:, methods:}`
+    # shape. Newer entries also need their methods table massaged before
+    # downstream code merges across processes.
+    def adapt_one(file_name, cover_statistic)
+      return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
+
+      adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      normalize_method_keys(cover_statistic)
+      cover_statistic
+    end
+
+    # Normalize memory addresses in method coverage keys so that results
+    # from different processes can be merged. Anonymous class names like
+    # "#<Class:0x00007ff19ab24790>" get inconsistent addresses across runs.
+    # Address widths vary by runtime (32-bit hosts: 8 hex chars; 64-bit
+    # CRuby: 16; some JVM/TruffleRuby formats may differ), so match any
+    # length of hex digits and collapse to a single placeholder.
+    ADDRESS_PATTERN = /0x\h+/
+    private_constant :ADDRESS_PATTERN
+
+    ADDRESS_PLACEHOLDER = "0x0"
+    private_constant :ADDRESS_PLACEHOLDER
+
+    # Strip the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
+    # method keys. `module_function` and class methods get recorded both as
+    # singleton (`[#<Class:Foo>, :m, …]`) and instance/module (`[Foo, :m, …]`)
+    # entries pointing at the same source location; only one of the two is
+    # ever reachable at runtime, so we merge them. Only applies to named
+    # constants — anonymous-class addresses like `#<Class:0x0>` are left
+    # alone (handled by ADDRESS_PATTERN above).
+    SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
+    private_constant :SINGLETON_WRAPPER_PATTERN
+
+    def normalize_method_keys(cover_statistic)
+      methods = cover_statistic[:methods]
+      return unless methods
+
+      cover_statistic[:methods] = methods.each_with_object({}) do |(key, count), normalized|
+        normalized_key = key.dup
+        normalized_key[0] = key[0].to_s
+                                  .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                                  .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+        # Keys may collide after normalization (anonymous classes sharing a
+        # method name, or singleton + instance forms of a module_function method).
+        normalized[normalized_key] = normalized.fetch(normalized_key, 0) + count
+      end
+    end
+
+    def adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      return unless cover_statistic.key?(:oneshot_lines)
+
+      oneshot_lines = cover_statistic.delete(:oneshot_lines)
+      line_stub     = build_line_stub(file_name, oneshot_lines)
+      oneshot_lines.each { |covered_line| line_stub[covered_line - 1] = 1 }
+      cover_statistic[:lines] = line_stub
+    end
+
+    def build_line_stub(file_name, oneshot_lines)
+      Coverage.line_stub(file_name)
+    rescue Errno::ENOENT, SyntaxError
+      Array.new(oneshot_lines.max || 0, nil)
+    end
   end
 end