simplecov 1.0.2 → 1.1.0

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "prism_compat"
 require_relative "condition_folding"
 require_relative "location_conventions"
 require_relative "method_collector"
@@ -7,42 +8,13 @@ require_relative "value_position"
 
 module SimpleCov
   module StaticCoverageExtractor
-    # `Prism::IfNode#subsequent` was renamed from `consequent` in Prism
-    # 1.3 (Dec 2024). Ruby 3.3's stdlib still ships an older Prism that
-    # only exposes `consequent`; 3.4+ and any project that's done
-    # `gem install prism` exposes `subsequent`. Resolve the method name
-    # ONCE here so the per-node hot path stays branch-free. The
-    # not-taken arm on whichever Prism version we're on can't be
-    # exercised by our own dogfood (we only run on one Prism at a time).
-    # simplecov:disable
-    IF_NODE_SUBSEQUENT_METHOD =
-      if ::Prism::IfNode.method_defined?(:subsequent)
-        :subsequent
-      else
-        :consequent
-      end
-
-    # The same Prism 1.3 rename hit the `else` accessor on `UnlessNode`,
-    # `CaseNode`, and `CaseMatchNode` (all three: `consequent` ->
-    # `else_clause`). Ruby 3.3's stdlib Prism (0.19) only exposes
-    # `consequent`, so reaching for `else_clause` there raised
-    # NoMethodError inside the extractor — `call` swallowed it and the
-    # whole file silently fell back to no simulated data for any
-    # `unless`/`else` or empty-arm `case`. Resolve the name once, like
-    # IF_NODE_SUBSEQUENT_METHOD. All three nodes renamed together, so one
-    # constant (probed off CaseNode) covers them.
-    ELSE_CLAUSE_METHOD =
-      if ::Prism::CaseNode.method_defined?(:else_clause)
-        :else_clause
-      else
-        :consequent
-      end
-    # simplecov:enable
-
     # Prism visitor that accumulates branch and method tuples in the
     # shape Ruby's `Coverage` reports. Tuple ids are sequential across
-    # the file — `Coverage` uses sequential ids too, so this matches the
-    # conventional shape. Only defined when Prism is loadable;
+    # the file like `Coverage`'s, but the numbering order can differ
+    # (e.g. `case`/`when` and chained `&.` are visited in a different
+    # order than Coverage numbers them). That's fine: the combiners
+    # intern on source span and the report output drops ids, so nothing
+    # downstream compares them. Only defined when Prism is loadable;
     # `StaticCoverageExtractor.available?` is the runtime gate.
     class Visitor < ::Prism::Visitor
       # Method tuples and the class/module nesting that names them are
@@ -64,6 +36,7 @@ module SimpleCov
         @next_id = 0
         @class_stack = []
         @value_positions = nil
+        @suppress_methods = false
       end
 
       # Entry point for a parsed file. On legacy Rubies the location of an
@@ -84,13 +57,27 @@ module SimpleCov
       # `else`, another IfNode for `elsif`). When the subsequent is
       # missing, Coverage synthesizes a `:else` arm attributed to the
       # whole condition's range — we do the same.
+      #
+      # A folded condition emits no tuple, and on modern Rubies only its
+      # live arm is descended into: the compiler eliminates the dead
+      # arm's entire subtree, so a branch or method nested there would be
+      # a phantom no loaded run can produce. A falsy `if`'s elsif chain
+      # survives as a plain `if`, which is what visiting the subsequent
+      # IfNode emits. On 3.2 the dead arm is visited too, branches only
+      # (see visit_folded_arms).
       def visit_if_node(node)
-        emit_if_like(node, :if) unless static_condition?(node.predicate)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, node.statements, PrismCompat.subsequent(node)) if verdict
+
+        emit_if_like(node, :if)
         super
       end
 
       def visit_unless_node(node)
-        emit_if_like(node, :unless) unless static_condition?(node.predicate)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, PrismCompat.else_clause(node), node.statements) if verdict
+
+        emit_if_like(node, :unless)
         super
       end
 

data/lib/simplecov/unloaded_file_injector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "simulate_coverage"
+
+module SimpleCov
+  # Fills in coverage for files that were tracked (via `cover` / `track_files`)
+  # but never loaded, so they count toward the denominators instead of being
+  # absent from the report entirely.
+  #
+  # This is the mechanism; the merge-time policy of *when* to inject and
+  # which criteria the simulated files carry lives in
+  # `ResultMerger::UnloadedFiles` — easy names to confuse.
+  #
+  # Everything arrives as arguments rather than being read from the SimpleCov
+  # singleton. The merge step performs this injection on behalf of the processes
+  # that contributed to it, and it does not necessarily share their
+  # configuration: a standalone `collate` never ran `SimpleCov.start`, so it has
+  # no `cover` glob of its own and takes the tracked paths from the resultsets
+  # instead. See #1250.
+  module UnloadedFileInjector
+  module_function
+
+    # Expand `globs` into absolute paths, relative to `root` rather than
+    # `Dir.pwd` — test runners that chdir (or CI scripts that invoke the suite
+    # from a subdirectory) would otherwise silently miss files and produce a
+    # different set per environment. See #1106.
+    # `reject:` are the producing process's path-decidable filters. Paths its
+    # own report would exclude must not be recorded as tracked, or a merge that
+    # does not share the configuration would simulate them back in. Before
+    # injection moved to the merge the producer filtered them out of its own
+    # result and they never reached a resultset. A block filter is handed the
+    # source file and may consult coverage that does not exist yet, so those
+    # still fall to the merging process's filter chain. See #1250.
+    def discover(globs, root:, reject: [])
+      paths = globs.compact
+                   .flat_map { |glob| Dir.glob(glob, base: root) }
+                   .uniq
+                   .map { |path| File.expand_path(path, root) }
+      return paths if reject.empty?
+
+      paths.reject { |path| rejected?(path, reject) }
+    end
+
+    # `SourceFile` reads source and builds lines lazily, so a path-only filter
+    # answers without anything here touching disk.
+    def rejected?(path, filters)
+      candidate = SourceFile.new(path, NO_COVERAGE_YET, loaded: false)
+      filters.any? { |filter| filter.matches?(candidate) }
+    end
+
+    no_coverage_yet = {"lines" => []} #: Hash[String, Array[untyped]]
+    NO_COVERAGE_YET = no_coverage_yet.freeze
+    private_constant :NO_COVERAGE_YET
+
+    # Add simulated coverage for every path `coverage` does not already carry.
+    # Paths that are present are left alone, whoever put them there, which is
+    # what lets this run over resultsets a previous SimpleCov already injected
+    # into without double-counting or overwriting real data.
+    #
+    # Returns the augmented coverage and the set of paths that were added.
+    def call(coverage, paths, synthesize:, lines:)
+      injected = Set.new
+      augmented = coverage.dup
+
+      paths.each do |path|
+        next if augmented.key?(path)
+
+        augmented[path] = SimulateCoverage.call(path, synthesize: synthesize, lines: lines)
+        injected << path
+      end
+
+      [augmented, injected]
+    end
+  end
+end

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/lib/simplecov.rb

@@ -158,10 +158,8 @@ module SimpleCov
                                               ::Process.respond_to?(:_fork)
       # simplecov:enable
 
-      # Trigger adapter selection now so the (possibly lazy) parallel_tests
-      # gem load happens at start_tracking time rather than mid-suite.
-      # `current` is memoized; subsequent calls are cheap.
-      SimpleCov::ParallelAdapters.current
+      # Select the parallel adapter and generate identities before any forks.
+      SimpleCov::RunIdentity.prepare
 
       @result = nil
       self.pid = Process.pid
@@ -230,6 +228,7 @@ end
 require "forwardable"
 require_relative "simplecov/color"
 require_relative "simplecov/deprecation"
+require_relative "simplecov/group_names"
 require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
 require_relative "simplecov/coverage_statistics"
@@ -245,22 +244,29 @@ require_relative "simplecov/result"
 require_relative "simplecov/filter"
 require_relative "simplecov/formatter"
 require_relative "simplecov/last_run"
+require_relative "simplecov/report_stamp"
 require_relative "simplecov/lines_classifier"
 require_relative "simplecov/result_merger"
+require_relative "simplecov/parallel_result_merger"
 require_relative "simplecov/parallel_adapters"
+require_relative "simplecov/run_identity"
+SimpleCov.extend SimpleCov::RunIdentity::Accessors
 require_relative "simplecov/command_guesser"
 require_relative "simplecov/version"
 require_relative "simplecov/result_adapter"
 require_relative "simplecov/combine"
+require_relative "simplecov/combine/identity_interner"
 require_relative "simplecov/combine/branches_combiner"
 require_relative "simplecov/combine/methods_combiner"
-require_relative "simplecov/combine/files_combiner"
 require_relative "simplecov/combine/lines_combiner"
+require_relative "simplecov/combine/coverage_accumulator"
 require_relative "simplecov/combine/results_combiner"
 require_relative "simplecov/useless_results_remover"
 require_relative "simplecov/simulate_coverage"
+require_relative "simplecov/unloaded_file_injector"
 require_relative "simplecov/result_processing"
 require_relative "simplecov/exit_handling"
+require_relative "simplecov/report_deferral"
 require_relative "simplecov/parallel_coordination"
 
 # Load default config

data/schemas/coverage-v1.0.schema.json

@@ -254,7 +254,7 @@
         },
         "total": {"type": "integer", "minimum": 0, "description": "Executable lines: `covered + missed`. Does not include `omitted`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered lines (hits per covered line)."}
+        "strength": {"type": "number", "description": "Average executions per coverable line: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "coverage_statistic": {
@@ -266,7 +266,7 @@
         "missed": {"type": "integer", "minimum": 0},
         "total": {"type": "integer", "minimum": 0, "description": "Total branches or methods: `covered + missed`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered branches or methods (hits per covered item)."}
+        "strength": {"type": "number", "description": "Average executions per coverable branch or method: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "line_coverage": {

data/schemas/coverage.schema.json

@@ -254,7 +254,7 @@
         },
         "total": {"type": "integer", "minimum": 0, "description": "Executable lines: `covered + missed`. Does not include `omitted`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered lines (hits per covered line)."}
+        "strength": {"type": "number", "description": "Average executions per coverable line: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "coverage_statistic": {
@@ -266,7 +266,7 @@
         "missed": {"type": "integer", "minimum": 0},
         "total": {"type": "integer", "minimum": 0, "description": "Total branches or methods: `covered + missed`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered branches or methods (hits per covered item)."}
+        "strength": {"type": "number", "description": "Average executions per coverable branch or method: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "line_coverage": {