simplecov 1.0.0.rc3 → 1.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eda0f749acc9b248635b6b1128c601b28bd77304994f78ebbbec0fc9097a2969
-  data.tar.gz: 8d55b00892b8f2cd47f7d3960c52e5d177c4951a77cbcd4af42282ae7ec745fa
+  metadata.gz: e60ecd48ca2790532fba8cdf76aaf6f29f18dd08c27fdc4d349988d2d60d6cd6
+  data.tar.gz: 600d7ca6449e36825de427633b8b6890cd77f292ad661c4a86b325e3424081bd
 SHA512:
-  metadata.gz: 4cafbbdb4eb3ee18f0c6fad85b865e5522d7e5b86d8d154a42b716a61bfbf57a734d2a0381f95d0d59cd6b914d910f559054725ba92ed6c3f1388421299d824e
-  data.tar.gz: 79c267679cbf76017bbbc2541ab239a226145c2b798fc75731492f7600edafc9efe7c56e3e5a769392b4a0dff7b1a3a8d808af8a9d341b6ab26b6c19b1676a6a
+  metadata.gz: 49db7a5cf640b63fd877832f67580a15ea384a79ce6f4778be807474170b69dde752c58f60729ce5ba2e2a9d3266a53704ff70cbf76b4f70c697d28f4553e200
+  data.tar.gz: e69d632cb5f3e0a4b8d7e65c9bbfae5bb6b779df1b37c28227374ca799a9a57910438a0bc6c32b1e34785e04db70e19ce53db33771ddf7d2bb5d4cf9c9dccb5f

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+1.0.0.rc4 (2026-06-26)
+======================
+
+## Enhancements
+* Added `SimpleCov.finalize_merge` to separate storing mergeable worker resultsets from owning final report finalization. Parallel workers that write to explicit custom coverage destinations can now store their shard `.resultset.json` files without waiting on sibling shards they cannot see; an explicit `SimpleCov.collate` cleanup step then formats the merged report, enforces thresholds, and writes `.last_run.json`. SimpleCov infers this external-finalization mode only for recognized multi-worker parallel runs with merging enabled and a custom coverage destination, and emits a configuration warning until users set `finalize_merge false` (or `true`) explicitly. See #1215.
+
+## Bugfixes
+* The `parallel_tests` adapter now only activates and uses the native wait API when the native pid-file synchronization contract is present. Processes that inherit `TEST_ENV_NUMBER` / `PARALLEL_TEST_GROUPS` without `PARALLEL_PID_FILE`, or lose `PARALLEL_PID_FILE` before SimpleCov's `at_exit` hook runs, now use the generic resultset polling path instead of calling `ParallelTests.wait_for_other_processes_to_finish` and failing when `parallel_tests` fetches the missing pid-file path. See #1210.
+* The default `at_exit` formatter now writes reports only from the final parallel-test worker while still storing each worker's resultset for the final merge, so JSON/XML/HTML formatters no longer clobber canonical coverage files from non-final workers. See #1210.
+* `SimpleCov.parallel_tests false` now disables the generic `TEST_ENV_NUMBER` adapter as well as the `parallel_tests` gem adapter, so projects that use those environment variables for a different coverage collation flow can opt out consistently. See #1208.
+* Parallel result coordination now stores the final worker's own resultset before waiting for sibling resultsets, preventing an off-by-one timeout where the final worker reported `N-1` of `N` workers and skipped threshold checks immediately before producing a complete merged report. See #1208.
+* Static branch coverage now matches Ruby's runtime branch tuple identities for `unless` and safe-navigation calls, and resultset merges now combine serialized branch tuples by source location instead of by their local sequential ids. This prevents equivalent branches from being duplicated when static and runtime branch extraction assign different ids. See #1206.
+
 1.0.0.rc3 (2026-06-18)
 ======================
 

data/README.md

@@ -160,7 +160,8 @@ This is recommended whenever you merge frameworks that rely on each other, like
 > Calling `SimpleCov.start` directly from `.simplecov` is deprecated. Tracking still begins for backward
 > compatibility, but a one-time deprecation warning fires; a future release will require the explicit `SimpleCov.start`
 > from a test helper. Migrating prevents a long-standing bug where `.simplecov` auto-loaded in a Rakefile or Rails'
-> `Bundler.require` would leave an empty parent-process report that overwrites the test subprocess's good one. See #581.
+> `Bundler.require` would leave an empty parent-process report that overwrites the test subprocess's good one. See
+> [#581](https://github.com/simplecov-ruby/simplecov/issues/581).
 
 ### Changing the report location
 
@@ -217,8 +218,8 @@ Brand-new in the redesigned API (no legacy method to migrate from):
 |-------------------------------------|--------------------------------------------------------------------------------------------------------------------------|
 | `cover "lib/**/*.rb"`               | Positive scope (allowlist). Multiple calls union; strings are globs. See above for the relationship with `track_files`.  |
 | `no_default_skips`                  | Clear every previously-installed filter — defaults and anything earlier in the block — so subsequent `skip`s start clean.|
-| `formatter false` / `formatters []` | Opt out of formatting entirely. Workers in big parallel CI runs only need their `.resultset.json` for a final `SimpleCov.collate` step; skipping the formatter saves the per-job HTML / multi-formatter overhead. See #964. |
-| `parallel_tests true` / `false`     | Force on / off the auto-require of the `parallel_tests` gem. Default (unset) auto-detects from `TEST_ENV_NUMBER` / `PARALLEL_TEST_GROUPS` and silently skips if the gem isn't installed. Set explicitly when you use those env vars for unrelated subprocess coordination. See #1018. |
+| `formatter false` / `formatters []` | Opt out of formatting entirely. Workers in big parallel CI runs only need their `.resultset.json` for a final `SimpleCov.collate` step; skipping the formatter saves the per-job HTML / multi-formatter overhead. See [#964](https://github.com/simplecov-ruby/simplecov/issues/964). |
+| `parallel_tests true` / `false`     | Force on / off the auto-require of the `parallel_tests` gem. Default (unset) auto-detects from `TEST_ENV_NUMBER` / `PARALLEL_TEST_GROUPS` and silently skips if the gem isn't installed. Set explicitly when you use those env vars for unrelated subprocess coordination. See [#1018](https://github.com/simplecov-ruby/simplecov/issues/1018). |
 
 Example before/after:
 
@@ -748,6 +749,51 @@ whatever has arrived, skipping the minimum / maximum coverage checks against tha
 much heavier test files and routinely finishes a minute or more after the others, raise it with
 `SimpleCov.parallel_wait_timeout 180` so its coverage is included.
 
+### Merge finalization ownership
+
+`SimpleCov.merging true` stores each process' resultset so it can be merged with other suites or workers. By default,
+SimpleCov also owns **finalizing** that merge: waiting for sibling workers, building the merged result, formatting the
+report, enforcing minimum / maximum coverage, and writing `.last_run.json`.
+
+Some parallel runners intentionally write each worker's resultset to a separate coverage directory and then run an
+explicit cleanup step with `SimpleCov.collate`. In that setup, workers should still store their resultsets, but the
+cleanup task owns finalization:
+
+```ruby
+# spec/spec_helper.rb
+SimpleCov.start do
+  if ENV["TEST_ENV_NUMBER"]
+    merging true
+    coverage_dir "coverage/turbo_tests/#{ENV["TEST_ENV_NUMBER"]}"
+    command_name "rspec-#{ENV["TEST_ENV_NUMBER"]}"
+    finalize_merge false
+  end
+end
+```
+
+```ruby
+# Rakefile
+task "coverage:collate" do
+  require "simplecov"
+
+  SimpleCov.collate Dir["coverage/turbo_tests/*/.resultset.json"] do
+    coverage(:line) { minimum 100 }
+    coverage(:branch) { minimum 100 }
+  end
+end
+```
+
+When `finalize_merge false`, the worker writes its `.resultset.json` and exits without waiting for siblings, formatting,
+checking thresholds, or writing `.last_run.json`. The `SimpleCov.collate` process is the finalizer and performs those
+steps for the merged result.
+
+For compatibility, SimpleCov infers `finalize_merge false` and prints a configuration warning only when all of these are
+true: a recognized parallel adapter is active, more than one worker is expected, merging is enabled, the coverage
+destination was explicitly changed from the default, and the process has parallel-worker environment variables. Set
+`SimpleCov.finalize_merge false` to keep external collation ownership without the warning, or
+`SimpleCov.finalize_merge true` if the selected worker should own the built-in wait / merge / report flow even with a
+custom coverage destination.
+
 ### Merging across execution environments
 
 If your tests run in parallel across multiple build machines, download each run's `.resultset.json` and merge them into
@@ -866,14 +912,14 @@ SimpleCov coordinates with parallel test runners through a small pluggable adapt
 
 - **`ParallelTestsAdapter`** — wraps the [grosser/parallel_tests](https://github.com/grosser/parallel_tests) gem and
   uses its `ParallelTests.first_process?` / `ParallelTests.wait_for_other_processes_to_finish` APIs for precise worker
-  coordination.
+  coordination. Activates only when the native `parallel_tests` pid-file contract is present.
 - **`GenericAdapter`** — catch-all for any runner that follows the `TEST_ENV_NUMBER` / `PARALLEL_TEST_GROUPS` env-var
   convention but doesn't ship a Ruby API (parallel_rspec, knapsack-style splitters, custom CI sharding scripts).
   Activates when `TEST_ENV_NUMBER` is set and no more-specific adapter is.
 
 Adapters are tried in registration order; the first whose `active?` returns `true` is chosen. With both built-ins, this
 means parallel_tests users get the precise gem-based path and parallel_rspec (or any env-var-only runner) gets the
-polling-based fallback without any configuration change. See #1065.
+polling-based fallback without any configuration change. See [#1065](https://github.com/simplecov-ruby/simplecov/issues/1065).
 
 #### Registering a custom adapter
 

data/lib/simplecov/combine/branches_combiner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../source_file/ruby_data_parser"
+
 module SimpleCov
   module Combine
     #
@@ -22,11 +24,30 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        coverage_a.merge(coverage_b) do |_condition, branches_inside_a, branches_inside_b|
-          branches_inside_a.merge(branches_inside_b) do |_branch, a_count, b_count|
-            a_count + b_count
+        combined = [coverage_a, coverage_b].each_with_object({}) do |coverage, memo|
+          coverage.each do |condition, branches_inside|
+            condition_key = tuple_identity(condition)
+            condition_tuple, merged_branches = memo[condition_key] ||= [condition, {}]
+            merge_branches(merged_branches, branches_inside)
+            memo[condition_key] = [condition_tuple, merged_branches]
           end
         end
+
+        combined.values.to_h { |condition, branches| [condition, branches.values.to_h] }
+      end
+
+      def merge_branches(target, source)
+        source.each do |branch, count|
+          branch_key = tuple_identity(branch)
+          branch_tuple, existing_count = target[branch_key]
+          target[branch_key] = [branch_tuple || branch, existing_count ? existing_count + count : count]
+        end
+      end
+
+      def tuple_identity(tuple)
+        tuple = SourceFile::RubyDataParser.call(tuple)
+        type, _id, start_line, start_column, end_line, end_column = tuple
+        [type, start_line, start_column, end_line, end_column]
       end
     end
   end

data/lib/simplecov/configuration/merging.rb

@@ -54,6 +54,38 @@ module SimpleCov
       @use_merging
     end
 
+    #
+    # Get or set whether this process owns final merge processing:
+    # waiting for sibling workers, building the merged result, formatting,
+    # enforcing thresholds, and writing `.last_run.json`.
+    #
+    # Defaults to true, except for recognized multi-worker parallel runs
+    # that explicitly write to a custom coverage destination while merging
+    # is enabled. Those runs are likely using an external `SimpleCov.collate`
+    # step to finalize the merge.
+    #
+    def finalize_merge(value = :__no_arg__)
+      unless value == :__no_arg__
+        @finalize_merge = value
+        @finalize_merge_explicit = true
+      end
+
+      return @finalize_merge if defined?(@finalize_merge_explicit) && @finalize_merge_explicit
+
+      inferred = inferred_finalize_merge?
+      warn_about_inferred_finalize_merge unless inferred
+      inferred
+    end
+
+    def finalize_merge?
+      finalize_merge
+    end
+
+    # @api private
+    def merge_finalization_owner?
+      collating_result? || finalize_merge?
+    end
+
     # DEPRECATED: alias for `merging`. Same value, same behavior.
     def use_merging(use = nil)
       SimpleCov::Deprecation.warn("`SimpleCov.use_merging` is deprecated. " \
@@ -83,5 +115,50 @@ module SimpleCov
       @parallel_wait_timeout = seconds if seconds.is_a?(Integer)
       @parallel_wait_timeout ||= 60
     end
+
+  private
+
+    def inferred_finalize_merge?
+      return true unless merging
+
+      adapter = SimpleCov::ParallelAdapters.current
+      return true unless adapter
+      return true unless adapter.expected_worker_count > 1
+      return true unless parallel_worker_environment?
+      return true unless explicit_custom_coverage_destination?
+
+      false
+    end
+
+    def parallel_worker_environment?
+      ENV.key?("TEST_ENV_NUMBER") || ENV.key?("PARALLEL_TEST_GROUPS")
+    end
+
+    def explicit_custom_coverage_destination?
+      return false unless explicit_coverage_destination?
+
+      coverage_path != File.expand_path("coverage", root)
+    end
+
+    def explicit_coverage_destination?
+      (defined?(@coverage_path_explicit) && @coverage_path_explicit) ||
+        (defined?(@coverage_dir_explicit) && @coverage_dir_explicit)
+    end
+
+    def warn_about_inferred_finalize_merge
+      return if defined?(@finalize_merge_inference_warned) && @finalize_merge_inference_warned
+      return unless print_errors
+
+      @finalize_merge_inference_warned = true
+      warn SimpleCov::Color.colorize(inferred_finalize_merge_warning, :yellow)
+    end
+
+    def inferred_finalize_merge_warning
+      "SimpleCov inferred `finalize_merge false` because this parallel worker is merging " \
+        "into a custom coverage destination. Set `SimpleCov.finalize_merge false` to keep " \
+        "external collation ownership, or `SimpleCov.finalize_merge true` if this worker " \
+        "should wait, merge, format, enforce thresholds, and write `.last_run.json`. " \
+        "See https://github.com/simplecov-ruby/simplecov#merge-finalization-ownership."
+    end
   end
 end

data/lib/simplecov/configuration.rb

@@ -31,6 +31,7 @@ module SimpleCov
       return @coverage_dir if defined?(@coverage_dir) && dir.nil?
 
       @coverage_path = nil unless @coverage_path_explicit # invalidate cache
+      @coverage_dir_explicit = true unless dir.nil?
       @coverage_dir = dir || "coverage"
     end
 
@@ -94,14 +95,18 @@ module SimpleCov
 
     #
     # Gets or sets the behavior to process coverage results.
-    # By default, it calls SimpleCov.result.format!
+    # By default, it stores/merges the current result and formats only
+    # from the final reporting process.
     #
     def at_exit(&block)
       @at_exit = block if block
       return @at_exit if @at_exit
       return proc {} unless active_session?
 
-      @at_exit = proc { SimpleCov.result.format! }
+      @at_exit = proc do
+        result = SimpleCov.result
+        result.format! if result && SimpleCov.merge_finalization_owner? && SimpleCov.final_result_process?
+      end
     end
 
     # Whether SimpleCov has anything to do at exit: the Coverage module

data/lib/simplecov/exit_handling.rb

@@ -105,15 +105,16 @@ module SimpleCov
       Kernel.exit(exit_status)
     end
 
-    # @api private — the first worker in a parallel run is the only
-    # one that reports against thresholds, and only when its
+    # @api private — the process that owns final merge processing is the
+    # only one that reports against thresholds, and only when its
     # `wait_for_other_processes` confirmed every sibling reported.
     # When the wait times out, the merged total is partial and
     # comparing it against `minimum_coverage` / `maximum_coverage`
     # would surface a spurious "below minimum" violation about the
     # missing slice rather than a real shortfall.
     def ready_to_process_results?
-      final_result_process? && result? && parallel_results_complete?
+      merge_finalization_owner? && final_result_process? && result? &&
+        (collating_result? || parallel_results_complete?)
     end
 
     def process_results_and_report_error

data/lib/simplecov/parallel_adapters/generic.rb

@@ -23,6 +23,8 @@ module SimpleCov
     class GenericAdapter < Base
       class << self
         def active?
+          return false if SimpleCov.parallel_tests == false
+
           ENV.key?("TEST_ENV_NUMBER")
         end
 

data/lib/simplecov/parallel_adapters/parallel_tests.rb

@@ -7,16 +7,20 @@ module SimpleCov
     # Adapter for [grosser/parallel_tests](https://github.com/grosser/parallel_tests).
     # This is the historical default — SimpleCov has special-cased
     # parallel_tests since 0.18 — and remains the most precise option for
-    # projects on it. Detection is the standard pair: the `ParallelTests`
-    # constant has been loaded AND `TEST_ENV_NUMBER` is set. The gem itself
-    # is autoloaded lazily on first `active?` check so users who don't have
-    # it installed see no warnings (see #1018).
+    # projects on it. Detection requires the full native coordination
+    # contract: the `ParallelTests` constant has been loaded,
+    # `TEST_ENV_NUMBER` is set, and `PARALLEL_PID_FILE` is set. The pid-file
+    # path is required because the native wait API reads it with `ENV.fetch`.
+    # When a runner only provides the env-var convention, GenericAdapter is
+    # the correct coordination path.
     class ParallelTestsAdapter < Base
       class << self
         def active?
+          return false if SimpleCov.parallel_tests == false
+
           ensure_loaded
           # !! to coerce `defined?` (returns nil or "constant") to a proper bool.
-          !!(defined?(::ParallelTests) && ENV.key?("TEST_ENV_NUMBER"))
+          !!(defined?(::ParallelTests) && native_parallel_tests_environment?)
         end
 
         # Pick the *first* started process to do the final-result work,
@@ -34,6 +38,8 @@ module SimpleCov
         end
 
         def wait_for_siblings
+          return unless native_parallel_tests_environment?
+
           ::ParallelTests.wait_for_other_processes_to_finish
         end
 
@@ -71,6 +77,10 @@ module SimpleCov
         def env_suggests_parallel_tests?
           ENV.key?("TEST_ENV_NUMBER") && ENV.key?("PARALLEL_TEST_GROUPS")
         end
+
+        def native_parallel_tests_environment?
+          ENV.key?("TEST_ENV_NUMBER") && ENV.key?("PARALLEL_PID_FILE")
+        end
       end
     end
   end

data/lib/simplecov/result_processing.rb

@@ -21,7 +21,10 @@ module SimpleCov
       # Use the ResultMerger to produce a single, merged result, ready to use.
       @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
 
+      @collating_result = true
       run_exit_tasks!
+    ensure
+      @collating_result = false
     end
 
     #
@@ -41,8 +44,10 @@ module SimpleCov
       # 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
-        wait_for_other_processes
         SimpleCov::ResultMerger.store_result(@result) if result?
+        return @result unless finalize_merge?
+
+        wait_for_other_processes
         @result = SimpleCov::ResultMerger.merged_result
       end
 
@@ -54,6 +59,11 @@ module SimpleCov
       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.clone

data/lib/simplecov/static_coverage_extractor/method_collector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Visitor mixin that collects method tuples and tracks the lexical
+    # class / module nesting that names them, in the shape Ruby's
+    # `Coverage` reports methods. Mixed into `Visitor`, it shares that
+    # visitor's `@methods` / `@class_stack` state and keeps the
+    # method-collection concern separate from branch extraction.
+    module MethodCollector
+      # Track class/module nesting so method tuples carry the lexical
+      # class name. Module + Class are both treated as namespaces here
+      # since `Coverage` reports both as the constant.
+      def visit_class_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      def visit_module_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      # `def name(...)` and `def self.name(...)` both produce DefNode.
+      # The class context is the surrounding lexical class/module (or
+      # `Object` at the top level, matching `Coverage`'s convention).
+      def visit_def_node(node)
+        loc = node.location
+        class_name = @class_stack.last || "Object"
+        key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]
+        @methods[key] = 0
+        super
+      end
+
+    private
+
+      # Render a constant path (e.g., `Foo::Bar`) as its source-form
+      # string. Defensive nil / to_s fallbacks: ClassNode and ModuleNode
+      # always carry a constant_path in practice.
+      # simplecov:disable
+      def constant_name(node)
+        return "<anonymous>" if node.nil?
+        return node.slice if node.respond_to?(:slice)
+
+        node.to_s
+      end
+      # simplecov:enable
+
+      def with_class(name)
+        @class_stack.push(name)
+        yield
+      ensure
+        @class_stack.pop
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "method_collector"
+
 module SimpleCov
   module StaticCoverageExtractor
     # `Prism::IfNode#subsequent` was renamed from `consequent` in Prism
@@ -24,6 +26,10 @@ module SimpleCov
     # conventional shape. 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
+      # collected by this mixin; this class focuses on branch extraction.
+      include MethodCollector
+
       attr_reader :branches, :methods
 
       def initialize
@@ -41,12 +47,17 @@ module SimpleCov
       # missing, Coverage synthesizes a `:else` arm attributed to the
       # whole condition's range — we do the same.
       def visit_if_node(node)
-        emit_if_like(node)
+        emit_if_like(node, :if)
         super
       end
 
       def visit_unless_node(node)
-        emit_if_like(node)
+        emit_if_like(node, :unless)
+        super
+      end
+
+      def visit_call_node(node)
+        emit_safe_navigation(node) if node.respond_to?(:safe_navigation?) && node.safe_navigation?
         super
       end
 
@@ -75,42 +86,28 @@ module SimpleCov
         super
       end
 
-      # Track class/module nesting so method tuples carry the lexical
-      # class name. Module + Class are both treated as namespaces here
-      # since `Coverage` reports both as the constant.
-      def visit_class_node(node)
-        with_class(constant_name(node.constant_path)) { super }
-      end
-
-      def visit_module_node(node)
-        with_class(constant_name(node.constant_path)) { super }
-      end
-
-      # `def name(...)` and `def self.name(...)` both produce DefNode.
-      # The class context is the surrounding lexical class/module (or
-      # `Object` at the top level, matching `Coverage`'s convention).
-      def visit_def_node(node)
-        loc = node.location
-        class_name = @class_stack.last || "Object"
-        key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]
-        @methods[key] = 0
-        super
-      end
-
     private
 
       # IfNode and UnlessNode share a shape (predicate + then body +
       # optional else/elsif) but expose the trailing arm under different
       # accessors. `if_like_else_location` hides that split.
-      def emit_if_like(node)
+      def emit_if_like(node, type)
         then_loc = arm_location(node.statements, node.location)
         else_loc = if_like_else_location(node)
-        @branches[build_tuple(:if, node.location)] = {
+        @branches[build_tuple(type, node.location)] = {
           build_tuple(:then, then_loc) => 0,
           build_tuple(:else, else_loc) => 0
         }
       end
 
+      def emit_safe_navigation(node)
+        loc = node.location
+        @branches[build_tuple(:"&.", loc)] = {
+          build_tuple(:then, loc) => 0,
+          build_tuple(:else, loc) => 0
+        }
+      end
+
       # Resolve the source range Coverage attributes to a real-or-synthetic
       # `:else` arm of an if-like construct. IfNode uses
       # `subsequent` / `consequent` depending on Prism version (resolved
@@ -169,25 +166,6 @@ module SimpleCov
         @next_id += 1
         [type, id, location.start_line, location.start_column, location.end_line, location.end_column]
       end
-
-      # Render a constant path (e.g., `Foo::Bar`) as its source-form
-      # string. Defensive nil / to_s fallbacks: ClassNode and ModuleNode
-      # always carry a constant_path in practice.
-      # simplecov:disable
-      def constant_name(node)
-        return "<anonymous>" if node.nil?
-        return node.slice if node.respond_to?(:slice)
-
-        node.to_s
-      end
-      # simplecov:enable
-
-      def with_class(name)
-        @class_stack.push(name)
-        yield
-      ensure
-        @class_stack.pop
-      end
     end
   end
 end

data/lib/simplecov/static_coverage_extractor.rb

@@ -79,13 +79,14 @@ module SimpleCov
     #     methods:  Set[[name, start_line], ...]  # e.g., [[:foo, 7], [:bar, 13]]
     #   }
     #
-    # Branch matching is start_line-only because Coverage's condition type
-    # vocabulary (`:if`, `:unless`, `:case`, `:while`, `:until`) does not
-    # always match Prism's emitted type (the existing visitor reports
-    # `:if` for `unless` and ternary). Coincidental line-sharing between
-    # a real branch and an eval-generated one will keep both, which is
-    # an acceptable false-negative for an opt-in filter. Method matching
-    # uses (name, start_line) since a method name is unique at any line.
+    # Branch matching is start_line-only rather than by the full tuple.
+    # Static extraction and Coverage can still disagree on a branch's exact
+    # column positions (and, for some constructs, its type), so matching on
+    # start_line alone is the conservative choice that tolerates those
+    # differences. Coincidental line-sharing between a real branch and an
+    # eval-generated one will keep both, which is an acceptable
+    # false-negative for an opt-in filter. Method matching uses
+    # (name, start_line) since a method name is unique at any line.
     #
     # Returns nil when Prism is unavailable or parsing fails, signaling
     # callers to keep every Coverage entry (no false drops).

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "1.0.0.rc3"
+  VERSION = "1.0.0.rc4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc3
+  version: 1.0.0.rc4
 platform: ruby
 authors:
 - Erik Berlin
@@ -138,6 +138,7 @@ files:
 - lib/simplecov/source_file/source_loader.rb
 - lib/simplecov/source_file/statistics.rb
 - lib/simplecov/static_coverage_extractor.rb
+- lib/simplecov/static_coverage_extractor/method_collector.rb
 - lib/simplecov/static_coverage_extractor/visitor.rb
 - lib/simplecov/useless_results_remover.rb
 - lib/simplecov/version.rb
@@ -150,9 +151,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/simplecov-ruby/simplecov/issues
   changelog_uri: https://github.com/simplecov-ruby/simplecov/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.0.rc3
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.0.rc4
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.0.rc3
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.0.rc4
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -168,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Code coverage for Ruby
 test_files: []