simplecov 1.1.0 → 1.2.0

data/lib/simplecov/result_processing.rb

@@ -1,158 +1,111 @@
 # frozen_string_literal: true
 
-# Result-building façade: turns the raw `Coverage.result` hash into a
-# `SimpleCov::Result`, applies filters and groups, drives merging
-# across test suites via `SimpleCov::ResultMerger`, and exposes the
-# `collate` entry point for stitching disparate resultsets together.
 module SimpleCov
   class << self
+    # By default `collate` ignores the merge_timeout so all results in all
+    # files specified will be merged. Pass `ignore_timeout: false` to honor it.
     #
-    # Collate a series of SimpleCov result files into a single SimpleCov output.
-    #
-    # See README for usage. By default `collate` ignores the merge_timeout
-    # so all results in all files specified will be merged. Pass
-    # `ignore_timeout: false` to honor it.
-    #
-    # `processes:` above 1 fans the merge out across that many forked worker
-    # processes, for a collate big enough that reading and parsing the
-    # resultsets dominates it. The report is identical either way, not merely
-    # equivalent — the workers visit the resultsets in the order the
-    # single-process merge visits them — and one process never forks at all.
-    # The count is deliberately not clamped to the machine's core count nor
-    # gated on some minimum number of resultsets: how many processes a collate
-    # job can afford is the caller's call, not SimpleCov's. Anything below 1 is
-    # taken as 1, so a count computed from arithmetic that can reach zero needs
-    # no guarding. Defaults to `SIMPLECOV_CONCURRENCY`, or 1 when that is
-    # unset. See `SimpleCov::ParallelResultMerger`.
-    #
-    def collate(result_filenames, profile = nil, processes: ENV.fetch("SIMPLECOV_CONCURRENCY", 1).to_i,
-                ignore_timeout: true, &)
+    # `processes:` above 1 fans the merge out across that many forked workers.
+    # The report is identical either way, not merely equivalent. The count is
+    # deliberately not clamped to the machine's core count nor gated on a
+    # minimum number of resultsets: what a collate job can afford is the
+    # caller's call. Anything below 1 is taken as 1, so an unset
+    # `SIMPLECOV_CONCURRENCY` needs no default of its own.
+    def collate(result_filenames, profile = nil, processes: ENV["SIMPLECOV_CONCURRENCY"].to_i,
+      ignore_timeout: true, &)
       raise ArgumentError, "There are no reports to be merged" if result_filenames.empty?
 
       initial_setup(profile, &)
 
-      # Use the ResultMerger to produce a single, merged result, ready to use.
-      @result = ParallelResultMerger.merge_and_store(*result_filenames, processes: [1, processes].max,
-                                                                        ignore_timeout: ignore_timeout)
+      current_run.result = ParallelResultMerger.merge_and_store(*result_filenames, processes: [1, processes].max,
+        ignore_timeout: ignore_timeout)
 
-      @collating_result = true
+      current_run.collating_result = true
       run_exit_tasks!
     ensure
-      @collating_result = false
+      current_run.collating_result = false
     end
 
-    #
-    # Returns the result for the current coverage run. With merging enabled,
-    # every process stores its own slice, but only the finalization owner reads
-    # and caches the merged result.
-    #
     def result
-      return @result if result?
+      return current_run.result if result?
 
-      use_merging = merging
-
-      collect_own_coverage(standalone: !use_merging)
-
-      # If we're using merging of results, store the current result
-      # first (if there is one), then merge the results and return those
-      if use_merging
-        SimpleCov::ResultMerger.store_result(@result) if result?
-        return @result unless merge_finalization_owner?
+      merge = merging
+      collect_own_coverage(standalone: !merge)
+      merge_own_slice if merge
+      current_run.result
+    end
 
-        wait_for_other_processes
-        @result = SimpleCov::ResultMerger.merged_result
-      end
+    def merge_own_slice
+      ResultMerger.store_result(result) if result?
+      return unless merge_finalization_owner?
 
-      @result
+      wait_for_other_processes
+      current_run.result = ResultMerger.merged_result
     end
 
-    # Build this process's slice of the coverage result. `standalone` is true
-    # when no merge step follows, which makes this the final result: it is the
-    # one that reports dropped source files, and the one that injects unloaded
-    # files. When a merge does follow, both jobs belong to the merged result.
+    # `standalone` is true when no merge step follows, which makes this the
+    # final result: the one that reports dropped source files and injects
+    # unloaded files. When a merge does follow, both jobs belong to the merge.
     def collect_own_coverage(standalone:)
       return unless defined?(Coverage) && Coverage.running?
 
       process_coverage_result(report: standalone, inject_unloaded: standalone)
     end
 
-    # Returns nil if the result has not been computed, otherwise the result.
-    def result?
-      defined?(@result) && @result
-    end
-
-    # @api private — true while `SimpleCov.collate` is running its finalizer.
-    def collating_result?
-      defined?(@collating_result) && @collating_result
-    end
-
-    # Applies the configured filters to the given array of SimpleCov::SourceFile items
     def filtered(files)
-      result = files.to_a.dup
+      result = files.to_a
       filters.each do |filter|
         result = result.reject { |source_file| filter.matches?(source_file) }
       end
-      SimpleCov::FileList.new result
+      FileList.new result
     end
 
-    # Bin the given source files by group filter. `groups:` defaults to
-    # `SimpleCov.groups`; pass a Hash explicitly to bin against a
-    # different group config (e.g., the snapshot a Result captured at
-    # construction). Files matched by no group fall into the implicit
-    # "Ungrouped" bucket.
-    def grouped(files, groups: SimpleCov.groups)
+    # Files matched by no group fall into the implicit "Ungrouped" bucket.
+    def grouped(files, groups: default_groups)
       return {} if GroupNames.validate!(groups.keys).empty?
 
       grouped = groups.transform_values do |filter|
-        SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
+        FileList.new(files.select { |source_file| filter.matches?(source_file) })
       end
 
-      in_group  = grouped_file_set(grouped)
+      in_group = grouped_file_set(grouped)
       ungrouped = files.reject { |source_file| in_group.include?(source_file) }
-      grouped[GroupNames::UNGROUPED] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?
+      grouped[GroupNames::UNGROUPED] = FileList.new(ungrouped) if ungrouped.any?
 
       grouped
     end
 
-    # Applies the profile of given name on SimpleCov configuration
     def load_profile(name)
       profiles.load(name)
     end
 
-    # Clear out the previously cached .result. Primarily useful in testing.
     def clear_result
-      @result = nil
+      current_run.result = nil
     end
 
-    # @api private — persist the per-criterion coverage percentages
-    # rounded down (see #679) so the next run can compute drift.
+    # @api private -- floored (#679) so the next run can compute drift.
     def write_last_run(result)
-      SimpleCov::LastRun.write(
+      LastRun.write(
         result: result.coverage_statistics.transform_values { |stats| round_coverage(stats.percent) }
       )
     end
 
-    # @api private — round down to two decimals to be extra strict.
+    # @api private -- floored, to be extra strict.
     def round_coverage(coverage)
       coverage.floor(2)
     end
 
-    # Add simulated coverage for each of `candidate_paths` the result doesn't
-    # already carry, and return it with the set of paths added.
-    #
-    # @api private — the seam `SimpleCov::ResultMerger` injects through. Public
+    # @api private -- the seam `SimpleCov::ResultMerger` injects through. Public
     # only because the merge runs in another object, on behalf of processes
     # whose configuration it may not share, so it supplies the paths itself.
     def inject_unloaded_files(result, candidate_paths, synthesize: nil, lines: nil)
       return [result, Set.new] if candidate_paths.empty?
 
       # Synthesizing branch and method tuples means parsing every tracked file
-      # that wasn't loaded, which is about half the cost of simulating one.
-      # Nothing reads those tuples when neither criterion is enabled —
-      # `Combine::CoverageAccumulator` only combines them per criterion, and the
-      # statistics drop them the same way — so skip the parse. The same goes
-      # for line data, which a branch-only or method-only run neither reports
-      # nor receives from `Coverage` for the files it loaded. See #1250.
+      # that wasn't loaded, about half the cost of simulating one, and nothing
+      # reads those tuples when neither criterion is enabled. The same goes for
+      # line data, which a branch-only or method-only run neither reports nor
+      # receives from `Coverage` for the files it loaded (#1250).
       UnloadedFileInjector.call(
         result, candidate_paths,
         synthesize: synthesize.nil? ? branch_coverage? || method_coverage? : synthesize,
@@ -160,7 +113,7 @@ module SimpleCov
       )
     end
 
-  private
+    private
 
     def initial_setup(profile, &block)
       load_profile(profile) if profile
@@ -172,46 +125,48 @@ module SimpleCov
     end
 
     # Every path this process was told to track, whether or not it loaded them.
-    # Recorded on the result (and from there into the resultset) so that a merge
-    # in another process can inject the ones nobody loaded without needing this
-    # process's `cover` / `track_files` configuration. A standalone `collate`
-    # never ran `SimpleCov.start` and so has none of its own. See #1250.
+    # Recorded on the result so a merge in another process can inject the ones
+    # nobody loaded without needing this process's `cover` / `track_files`
+    # configuration. A standalone `collate` never ran `SimpleCov.start` (#1250).
     def tracked_file_paths
       UnloadedFileInjector.discover(
         unloaded_file_discovery_globs, root: root, reject: filters.select(&:path_only?)
       )
     end
 
-    # Globs to expand on disk when injecting unloaded files into the
-    # result. Combines the legacy `track_files` glob (additive only)
-    # with every string glob declared via `cover` (also restrictive,
-    # but the restriction lives in `Result#apply_cover_filters!`).
+    # The legacy `track_files` glob (additive only) plus every string glob
+    # declared via `cover` (also restrictive, but the restriction lives in
+    # `Result#apply_cover_filters!`).
     def unloaded_file_discovery_globs
       [tracked_files, *cover_globs].compact
     end
 
-    # Run all the steps that handle processing the raw coverage result.
-    # `report:` is true only when this slice is the final result (merging
-    # off); with merging on the merged result reports dropped source files,
-    # so the per-process slice stays quiet to avoid one warning per worker.
-    #
-    # `inject_unloaded:` is likewise false when a merge step follows. Only the
-    # union of every process's loaded files says what was really never loaded,
-    # so injecting here means each worker simulates nearly the whole project
-    # and all but one of those passes is merged away. See #1250.
+    # `report:` and `inject_unloaded:` are false when a merge step follows.
+    # Only the union of every process's loaded files says what was really never
+    # loaded, and the merged result is the one that reports dropped source
+    # files, so a per-process slice would warn once per worker and simulate
+    # nearly the whole project only to have it merged away (#1250).
     def process_coverage_result(report:, inject_unloaded: true)
-      raw = SimpleCov::UselessResultsRemover.call(Coverage.result)
-      adapted = SimpleCov::ResultAdapter.call(raw)
-      # What this process was told to track and did not load. Subtracting what
-      # it loaded matters because `Result#to_hash` serializes coverage after
-      # filtering: a file this process loaded and then filtered out would
-      # otherwise be recorded as tracked while absent from the stored coverage,
-      # and the merge would simulate it back in as never-loaded. See #1250.
+      # Templates nobody rendered are compiled into the running Coverage so they
+      # arrive at 0% below rather than being absent. Needs a live Coverage and
+      # ActionView, which rules out the merge point that does the same job for
+      # unloaded `.rb` files.
+      ViewCoverage.compile_unrendered
+      raw = UselessResultsRemover.call(Coverage.result)
+      adapted = ResultAdapter.call(raw)
+      # `Result#to_hash` serializes coverage after filtering, so a file this
+      # process loaded and then filtered out would otherwise be recorded as
+      # tracked while absent from the stored coverage, and the merge would
+      # simulate it back in as never-loaded (#1250).
       tracked = tracked_file_paths - adapted.keys
       result, not_loaded = inject_unloaded ? inject_unloaded_files(adapted, tracked) : [adapted, Set.new]
-      @result = SimpleCov::Result.new(
-        result, not_loaded_files: not_loaded, tracked_files: tracked,
-                run_id: SimpleCov.run_id, worker_id: SimpleCov.worker_id, report: report
+      current_run.result = build_result(raw, result, not_loaded: not_loaded, tracked: tracked, report: report)
+    end
+
+    def build_result(raw, coverage, not_loaded:, tracked:, report:)
+      Result.new(
+        coverage, not_loaded_files: not_loaded, tracked_files: tracked, run_id: run_id,
+        worker_id: worker_id, contexts: test_tracker&.recorded_map(closing: raw), report: report
       )
     end
   end

data/lib/simplecov/run_identity.rb

@@ -3,16 +3,16 @@
 require "securerandom"
 
 module SimpleCov
-  # Identifies one test invocation and each top-level parallel worker within
-  # it. Forked subprocesses inherit both values from their parent worker.
+  # Identifies one test invocation and each top-level parallel worker within it.
+  # Forked subprocesses inherit both values from their parent worker.
   module RunIdentity
-  module_function
+    extend self
 
-    # Returns the run id together with its provenance: `true` when the id
-    # alone proves same-run membership (explicitly configured, derived from
-    # parallel_tests' per-invocation pid file, or freshly random), `false`
-    # when it was inferred from the parent pid, which consecutive runs
-    # launched by the same long-lived parent process share.
+    # Answers the run id together with its provenance: true when the id alone
+    # proves same-run membership (explicitly configured, derived from
+    # parallel_tests' per-invocation pid file, or freshly random), false when it
+    # was inferred from the parent pid, which consecutive runs launched by the
+    # same long-lived parent process share.
     def generate
       explicit = ENV.fetch("SIMPLECOV_RUN_ID", nil)
       return [explicit, true] if explicit && !explicit.empty?
@@ -20,7 +20,7 @@ module SimpleCov
       pid_file = ENV.fetch("PARALLEL_PID_FILE", nil)
       return ["parallel-tests:#{File.basename(pid_file)}", true] if pid_file && !pid_file.empty?
 
-      return ["parallel-parent:#{Process.ppid}", false] if SimpleCov::ParallelAdapters.current
+      return ["parallel-parent:#{Process.ppid}", false] if ParallelAdapters.current
 
       [SecureRandom.uuid, true]
     end
@@ -35,10 +35,9 @@ module SimpleCov
       Process.pid.to_s
     end
 
-    # Whether the current run id alone proves same-run membership. Decided
-    # where the id is generated, never re-inferred from the id's shape, so
-    # an explicit SIMPLECOV_RUN_ID that happens to look like an inferred
-    # one is still trusted.
+    # Decided where the id is generated, never re-inferred from the id's shape,
+    # so an explicit SIMPLECOV_RUN_ID that happens to look like an inferred one
+    # is still trusted.
     def authoritative?
       materialize_current
       @authoritative
@@ -50,7 +49,7 @@ module SimpleCov
     end
 
     def materialize_current
-      @current, @authoritative = generate unless defined?(@current)
+      @current, @authoritative = generate unless instance_variable_defined?(:@current)
     end
 
     def current_worker_id
@@ -58,19 +57,18 @@ module SimpleCov
     end
 
     def prepare
-      SimpleCov::ParallelAdapters.current
+      ParallelAdapters.current
       SimpleCov.run_id
       SimpleCov.worker_id
     end
 
-    # Mixed into SimpleCov after ParallelAdapters has loaded.
     module Accessors
       def run_id
-        SimpleCov::RunIdentity.current
+        RunIdentity.current
       end
 
       def worker_id
-        SimpleCov::RunIdentity.current_worker_id
+        RunIdentity.current_worker_id
       end
     end
   end

data/lib/simplecov/simulate_coverage.rb

@@ -1,50 +1,39 @@
 # frozen_string_literal: true
 
+require "coverage"
 require_relative "static_coverage_extractor"
 
 module SimpleCov
-  #
-  # Responsible for producing file coverage metrics.
-  #
   module SimulateCoverage
-  module_function
+    extend self
 
     #
     # Simulate a file coverage report for a file that was tracked but never
-    # required. Returns the same hash shape as `Coverage.result` (lines,
-    # branches, methods).
+    # required, in the same hash shape as `Coverage.result`.
     #
-    # The line classification comes from `Coverage.line_stub` — the same
+    # The line classification comes from `Coverage.line_stub`, the same
     # classification the runtime would have produced if the file had been
-    # required — overlaid with SimpleCov's `# :nocov:` toggles and
+    # required, overlaid with SimpleCov's `# :nocov:` toggles and
     # `# simplecov:disable line` directive ranges, which `Coverage` doesn't
     # know about. This keeps "relevant lines" identical whether a file was
-    # loaded or just tracked, fixing the multi-line statement discrepancy
-    # in https://github.com/simplecov-ruby/simplecov/issues/654.
+    # loaded or just tracked (#654).
     #
-    # Branches and methods are enumerated by static analysis (via
-    # `StaticCoverageExtractor`, which uses Prism). Earlier behavior left
-    # both as empty hashes, which made unloaded files invisible to the
-    # branch/method denominators while their lines DID count — so a
-    # `track_files`/`cover` glob that picked up files without specs
-    # silently inflated branch% relative to line%. See
-    # https://github.com/simplecov-ruby/simplecov/issues/1059. When Prism
-    # isn't loadable (Ruby < 3.3 without the prism gem) or the file
-    # can't be parsed, fall back to the old empty hashes — old behavior,
-    # old tradeoff.
+    # Branches and methods are enumerated by static analysis. Earlier behavior
+    # left both as empty hashes, which made unloaded files invisible to the
+    # branch/method denominators while their lines did count, so a glob that
+    # picked up files without specs silently inflated branch% relative to
+    # line% (#1059). When Prism isn't loadable or the file can't be parsed,
+    # fall back to the old empty hashes.
     #
-    # Pass `synthesize: false` to skip the static analysis and return the
-    # empty hashes directly. Callers use it when neither branch nor method
-    # coverage is enabled, since nothing will read the tuples and the Prism
-    # parse is about half the cost of simulating a file. See #1250.
+    # Pass `synthesize: false` to skip the static analysis. Callers use it when
+    # neither branch nor method coverage is enabled, since nothing will read
+    # the tuples and the Prism parse is about half the cost of simulating a
+    # file (#1250).
     #
     # Pass `lines: false` to omit the `"lines"` key entirely, mirroring what
     # `Coverage.result` reports for a file loaded under a branch-only or
-    # method-only run. Emitting zeroed lines there would make a simulated
-    # file indistinguishable from one a sibling process actually loaded once
-    # the two are merged.
-    #
-    # @return [Hash]
+    # method-only run. Emitting zeroed lines there would make a simulated file
+    # indistinguishable from one a sibling process actually loaded.
     #
     def call(absolute_path, synthesize: true, lines: true)
       source_lines = read_lines(absolute_path)
@@ -52,47 +41,43 @@ module SimpleCov
       return simulated unless lines
 
       classified = coverage_stub(absolute_path, source_lines) ||
-                   LinesClassifier.new.classify(source_lines)
+        LinesClassifier.new.classify(source_lines)
       {"lines" => classified}.merge(simulated)
     end
 
-    # The branch and method tuples for a file, or empty hashes when the static
-    # analysis is skipped (nothing enabled reads them) or unavailable (no Prism,
-    # or the file doesn't parse).
+    # Empty hashes when the static analysis is skipped (nothing enabled reads
+    # them) or unavailable (no Prism, or the file doesn't parse).
     def synthesized_tuples(source_lines, synthesize)
       empty = {"branches" => {}, "methods" => {}} #: Hash[String, Hash[untyped, untyped]]
       synthesized = (StaticCoverageExtractor.call(source_lines.join) if synthesize) || empty
 
-      {"branches" => synthesized["branches"], "methods" => synthesized["methods"]}
+      {"branches" => synthesized.fetch("branches"), "methods" => synthesized.fetch("methods")}
     end
 
-    # SystemCallError, not just ENOENT: a `track_files` glob can sweep
-    # up an unreadable file or a directory named like a Ruby file
-    # (EACCES, EISDIR), and simulation must degrade to "empty file"
-    # rather than crash the merge or report step.
+    # SystemCallError, not just ENOENT: a `track_files` glob can sweep up an
+    # unreadable file or a directory named like a Ruby file, and simulation must
+    # degrade to "empty file" rather than crash the merge or report step.
     def read_lines(path)
       File.readlines(path)
     rescue SystemCallError
       []
     end
 
-    # Combine `Coverage.line_stub` (which gets multi-line statements right)
+    # Combines `Coverage.line_stub` (which gets multi-line statements right)
     # with `LinesClassifier` (which knows about `# :nocov:` toggles and
-    # `# simplecov:disable line` ranges). Returns nil — and the caller
-    # falls back to `LinesClassifier` alone — when `Coverage` can't read
-    # or parse the file, or when the runtime doesn't expose `line_stub`
-    # (JRuby and TruffleRuby).
+    # `# simplecov:disable line` ranges). Answers nil when `Coverage` can't
+    # read or parse the file, or the runtime doesn't expose `line_stub`.
     def coverage_stub(path, source_lines)
       return nil unless Coverage.respond_to?(:line_stub)
 
-      stub = Coverage.line_stub(path)
-      classifier_output = LinesClassifier.new.classify(source_lines)
-      stub.each_index { |idx| stub[idx] = nil if classifier_output[idx].nil? }
-      stub
+      # Paired off rather than indexed: the two lists describe the same file
+      # line for line. A line the classifier has no verdict for keeps the nil
+      # it would have been set to.
+      relevance = LinesClassifier.new.classify(source_lines)
+      Coverage.line_stub(path).zip(relevance).map { |hits, relevant| hits if relevant }
     rescue SystemCallError, SyntaxError
-      # SystemCallError for the same reason as read_lines above:
-      # line_stub reads the file itself, so EACCES/EISDIR surface here
-      # too.
+      # SystemCallError for the same reason as read_lines: line_stub reads the
+      # file itself, so EACCES/EISDIR surface here too.
       nil
     end
   end

data/lib/simplecov/source_file/branch.rb

@@ -2,51 +2,33 @@
 
 module SimpleCov
   class SourceFile
-    #
-    # Representing single branch that has been detected in coverage report.
-    # Give us support methods that handle needed calculations.
     class Branch
       attr_reader :start_line, :end_line, :coverage, :type
 
       def initialize(start_line:, end_line:, coverage:, inline:, type:)
         @start_line = start_line
-        @end_line   = end_line
-        @coverage   = coverage
-        @inline     = inline
-        @type       = type
-        @skipped    = false
+        @end_line = end_line
+        @coverage = coverage
+        @inline = inline
+        @type = type
+        @skipped = false
       end
 
       def inline?
         @inline
       end
 
-      #
-      # Return true if there is relevant count defined > 0
-      #
-      # @return [Boolean]
-      #
       def covered?
         !skipped? && coverage.positive?
       end
 
-      #
-      # Check if branch missed or not
-      #
-      # @return [Boolean]
-      #
       def missed?
         !skipped? && coverage.zero?
       end
 
-      # The line on which we want to report the coverage
-      #
-      # Usually we choose the line above the start of the branch (so that it shows up
-      # at if/else) because that
-      # * highlights the condition
-      # * makes it distinguishable if the first line of the branch is an inline branch
-      #   (see the nested_branches fixture)
-      #
+      # Usually the line above the start of the branch, so that it shows up at the
+      # if/else. That highlights the condition, and makes it distinguishable when
+      # the first line of the branch is itself an inline branch.
       def report_line
         if inline?
           start_line
@@ -55,12 +37,10 @@ module SimpleCov
         end
       end
 
-      # Flags the branch as skipped
       def skipped!
         @skipped = true
       end
 
-      # Returns true if the branch was marked skipped by virtue of nocov comments.
       def skipped?
         @skipped
       end
@@ -69,11 +49,6 @@ module SimpleCov
         start_line <= line_range.end && end_line >= line_range.begin
       end
 
-      #
-      # Return array with coverage count and badge
-      #
-      # @return [Array]
-      #
       def report
         [type, coverage]
       end