simplecov 1.0.0.rc2 → 1.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95cc757bf172ce50cd60e636048c88e30fade408c962d8fe8c9478465b6b2d67
-  data.tar.gz: 9ee4b98d8f3f790289415b03c3e37c436b32d1e2a9d193fd435dfdb966d4b658
+  metadata.gz: e60ecd48ca2790532fba8cdf76aaf6f29f18dd08c27fdc4d349988d2d60d6cd6
+  data.tar.gz: 600d7ca6449e36825de427633b8b6890cd77f292ad661c4a86b325e3424081bd
 SHA512:
-  metadata.gz: 719bcdfee0e3e79de52e7da4fdd955d85416b2c33c3b8bcd437d13187b9d883c6430ea55e0d52ca17c392cfe4e506f6a433278d5d285091858702bd669eb43bd
-  data.tar.gz: 4e70c6fabe5ed02ea4ece1ca811434c96b760e871507cc607a05af64710a9f0c14ee87c16dbcf82d19cdaaf23f3896d78ea0500e051130dbc15b7c6046e4b6b8
+  metadata.gz: 49db7a5cf640b63fd877832f67580a15ea384a79ce6f4778be807474170b69dde752c58f60729ce5ba2e2a9d3266a53704ff70cbf76b4f70c697d28f4553e200
+  data.tar.gz: e69d632cb5f3e0a4b8d7e65c9bbfae5bb6b779df1b37c28227374ca799a9a57910438a0bc6c32b1e34785e04db70e19ce53db33771ddf7d2bb5d4cf9c9dccb5f

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+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)
+======================
+
+## Breaking Changes
+* Dropped support for Ruby 3.1 and JRuby 9.4. The minimum is now Ruby 3.2 (and JRuby 10, which reports `RUBY_VERSION` 3.4). Ruby 3.1 reached end of life in March 2025, and a recent `i18n` release calls `Fiber[]`, a Ruby 3.2 API, at load time, so suites that load Rails no longer run on 3.1. Raising `required_ruby_version` to `>= 3.2` also excludes JRuby 9.4, which reports `RUBY_VERSION` 3.1.x. See #1171.
+
+## Enhancements
+* Added `SimpleCov.parallel_wait_timeout` (default 60 seconds), which controls how long the process that writes the final report waits for the other parallel-test workers to finish writing their resultsets before it merges. Raise it when one worker runs much heavier test files and routinely finishes well after the others, so its coverage is included in the merge and the minimum and maximum coverage checks run against the full total instead of being skipped against a partial one. See #1171.
+
+## Bugfixes
+* The "SimpleCov dropped N source file(s)" warning is now emitted at most once, from the process that writes the final report, instead of once per parallel worker. It was previously raised every time a result was built, so an eight-worker run produced eight copies. Fork-based runners that do not set `TEST_ENV_NUMBER`, such as Minitest's `parallelize`, match no parallel-test adapter, so SimpleCov now marks forked children (it already hooks `Process._fork`) and treats them as non-reporters when no adapter is active, leaving the process that did the forking to merge every slice and report once. See #1171.
+* Using `[SimpleCov::Formatter::HTMLFormatter, SimpleCov::Formatter::JSONFormatter]` together no longer prints a false "coverage.json was written after this process started" warning. As of 1.0 the HTML formatter writes `coverage.json` itself, so the JSON formatter found a file its own run had just written and mistook it for a concurrent worker about to lose data. The warning is now skipped when the existing file belongs to the same merged result. Because the HTML formatter already writes `coverage.json`, listing `JSONFormatter` alongside it is redundant and can be removed. See #1171.
+
 1.0.0.rc2 (2026-06-10)
 ======================
 

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:
 
@@ -742,6 +743,57 @@ Cached coverage data eventually goes stale, so result sets older than `SimpleCov
 merge. The default is 600 seconds (10 minutes); raise or lower it with `SimpleCov.merge_timeout 3600` (1 hour), or
 `merge_timeout 3600` inside a configure/start block. Deactivate automatic merging entirely with `SimpleCov.merging false`.
 
+In a parallel run, the process that writes the final report waits for the other workers to finish and write their
+result sets before merging. It gives up after `SimpleCov.parallel_wait_timeout` seconds (default 60) and reports
+whatever has arrived, skipping the minimum / maximum coverage checks against that partial total. If one worker runs
+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
@@ -860,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
 
@@ -1262,7 +1314,7 @@ anything; `-q` / `--quiet` suppresses status lines.
 
 ### Ruby version compatibility
 
-SimpleCov is built in [Continuous Integration] on Ruby 3.1+ and JRuby 9.4+. On CRuby, every coverage criterion
+SimpleCov is built in [Continuous Integration] on Ruby 3.2+ and JRuby 10+. On CRuby, every coverage criterion
 described above is available on the supported versions, with one exception: [eval coverage](#eval-coverage) requires
 CRuby 3.2+.
 

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. " \
@@ -70,5 +102,63 @@ module SimpleCov
       @merge_timeout = seconds if seconds.is_a?(Integer)
       @merge_timeout ||= 600
     end
+
+    #
+    # Defines how long (in seconds) the reporting process waits for the
+    # remaining parallel-test workers to write their resultsets before it
+    # proceeds with a partial merge. Default is 60 seconds. Raise it when a
+    # slow worker routinely finishes well after the others, so its coverage
+    # is still included and the minimum / maximum coverage checks aren't
+    # skipped against a partial total.
+    #
+    def parallel_wait_timeout(seconds = nil)
+      @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/deprecation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module SimpleCov
   # Emits legacy-API deprecation warnings, deduplicated by the source
   # location that triggered them. A deprecated method called in a loop —

data/lib/simplecov/exit_handling.rb

@@ -8,14 +8,13 @@ require "English"
 module SimpleCov
   class << self
     # @api private
-    CoverageLimits = Struct.new(
+    CoverageLimits = Data.define(
       :minimum_coverage,
       :minimum_coverage_by_file,
       :minimum_coverage_by_file_overrides,
       :minimum_coverage_by_group,
       :maximum_coverage,
-      :maximum_coverage_drop,
-      keyword_init: true
+      :maximum_coverage_drop
     )
 
     def at_exit_behavior
@@ -106,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/formatter/json_formatter.rb

@@ -25,7 +25,7 @@ module SimpleCov
       def format(result)
         FileUtils.mkdir_p(output_path)
         path = File.join(output_path, FILENAME)
-        warn_if_concurrent_overwrite(path)
+        warn_if_concurrent_overwrite(path, result)
         File.write(path, JSON.pretty_generate(self.class.build_hash(result)))
         # stderr, not stdout: this is a status message, not the program's
         # output. Keeps the line out of pipelines like `rspec -f json`.
@@ -46,23 +46,33 @@ module SimpleCov
       # process's start time — a strong signal that a sibling test process
       # (e.g., parallel_tests) wrote it while we were running, and that our
       # write is about to clobber their data.
-      def warn_if_concurrent_overwrite(path)
+      def warn_if_concurrent_overwrite(path, result)
         start_time = SimpleCov.process_start_time or return
-        existing_ts = existing_timestamp(path) or return
-        return unless existing_ts > start_time
+        existing = existing_meta(path) or return
+        return unless existing[:timestamp] > start_time
 
-        warn "simplecov: #{path} was written at #{existing_ts.iso8601} — after " \
+        # The HTML formatter also writes coverage.json (it shares the file as
+        # a side artifact), so when both formatters are configured the file we
+        # find was just written by our own run, not a concurrent one. A
+        # matching command_name means the same merged result, so there's
+        # nothing to lose by overwriting. See issue #1171.
+        return if existing[:command_name] == result.command_name
+
+        warn "simplecov: #{path} was written at #{existing[:timestamp].iso8601} — after " \
              "this process started at #{start_time.iso8601}. Overwriting " \
              "likely loses coverage data from a concurrent test run. For " \
              "parallel test setups, use SimpleCov::ResultMerger or run a single " \
              "collation step after all workers finish."
       end
 
-      def existing_timestamp(path)
+      def existing_meta(path)
         return nil unless File.exist?(path)
 
-        timestamp = JSON.parse(File.read(path), symbolize_names: true).dig(:meta, :timestamp)
-        timestamp && Time.iso8601(timestamp)
+        meta = JSON.parse(File.read(path), symbolize_names: true)
+        timestamp = meta.dig(:meta, :timestamp)
+        return nil unless timestamp
+
+        {timestamp: Time.iso8601(timestamp), command_name: meta.dig(:meta, :command_name)}
       rescue JSON::ParserError, ArgumentError
         nil
       end

data/lib/simplecov/lines_classifier.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require_relative "directive"
 
 module SimpleCov

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/parallel_coordination.rb

@@ -8,21 +8,16 @@
 # 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
+      # No recognized parallel-test adapter. A subprocess forked while
+      # coverage was running is never the final reporter — the process that
+      # spawned it merges every slice and produces the report. Without this,
+      # fork-based runners that don't set TEST_ENV_NUMBER (e.g. Minitest's
+      # `parallelize`) have every worker produce the final report and its
+      # warnings. See issue #1171.
+      return !forked_subprocess? unless adapter
 
       adapter.first_worker?
     end
@@ -56,11 +51,13 @@ module SimpleCov
 
     # @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.
+    # (expected <= 1) short-circuit to true with no waiting. The deadline
+    # is `SimpleCov.parallel_wait_timeout` seconds out; raise that setting
+    # when a slow worker routinely finishes well after the others.
     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
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + parallel_wait_timeout
       loop do
         seen = SimpleCov::ResultMerger.read_resultset.size
         return true if seen >= expected
@@ -85,8 +82,9 @@ module SimpleCov
 
       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.",
+        "#{parallel_wait_timeout}s, so coverage totals are partial and minimum / " \
+        "maximum coverage checks are skipped for this run. Increase " \
+        "SimpleCov.parallel_wait_timeout if a worker routinely needs longer.",
         :yellow
       )
     end

data/lib/simplecov/process.rb

@@ -22,7 +22,13 @@ module SimpleCov
       # 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
+      if pid.zero? && active
+        # Mark the child here, independent of whatever custom at_fork block
+        # the user installed, so `final_result_process?` can keep forked
+        # workers from each producing the final report. See issue #1171.
+        SimpleCov.mark_forked_subprocess!
+        SimpleCov.at_fork.call(::Process.pid)
+      end
       pid
     end
   end

data/lib/simplecov/result.rb

@@ -55,14 +55,14 @@ module SimpleCov
     # 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)
+                   report: false, filter_config: FilterConfig.new)
       @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
       @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)
+      warn_about_missing_source_files(builder.missing_source_files, original_result.size) if report
       apply_cover_filters!(filter_config.cover_filters)
       apply_filters!(filter_config.filters)
     end
@@ -138,6 +138,17 @@ module SimpleCov
     def warn_about_missing_source_files(missing, input_size)
       return if missing.empty?
 
+      # Emit only from the process that writes the final report. The merged
+      # result is rebuilt in every parallel worker (each one stores its own
+      # slice), so without this gate the warning prints once per worker — this
+      # is the same signal SimpleCov uses to pick the process that runs the
+      # report and threshold checks. It's intentionally not gated on
+      # print_errors: the default at_fork sets print_errors false on workers,
+      # and in many parallel runners the final-report process is itself a
+      # worker, so a print_errors gate would suppress the one warning we want.
+      # See issues #980 and #1171.
+      return unless SimpleCov.final_result_process?
+
       MissingSourceFilesReporter.new(
         missing,
         input_size: input_size,

data/lib/simplecov/result_adapter.rb

@@ -11,8 +11,8 @@ module SimpleCov
       @result = result
     end
 
-    def self.call(*args)
-      new(*args).adapt
+    def self.call(*)
+      new(*).adapt
     end
 
     def adapt

data/lib/simplecov/result_merger.rb

@@ -86,7 +86,11 @@ module SimpleCov
         return nil unless coverage
 
         command_name = command_names.reject(&:empty?).sort.join(", ")
-        SimpleCov::Result.new(coverage, command_name: command_name)
+        # The merged result is the authoritative one users actually see, so
+        # it's the one that warns about source files dropped because they no
+        # longer exist on disk (issue #980). The per-process slices built in
+        # `process_coverage_result` stay quiet to avoid one warning per worker.
+        SimpleCov::Result.new(coverage, command_name: command_name, report: true)
       end
 
       def merge_coverage(*results)

data/lib/simplecov/result_processing.rb

@@ -13,15 +13,18 @@ module SimpleCov
     # so all results in all files specified will be merged. Pass
     # `ignore_timeout: false` to honor it.
     #
-    def collate(result_filenames, profile = nil, ignore_timeout: true, &block)
+    def collate(result_filenames, profile = nil, ignore_timeout: true, &)
       raise ArgumentError, "There are no reports to be merged" if result_filenames.empty?
 
-      initial_setup(profile, &block)
+      initial_setup(profile, &)
 
       # 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
 
     #
@@ -31,14 +34,20 @@ module SimpleCov
     def result
       return @result if result?
 
-      # Collect our coverage result
-      process_coverage_result if defined?(Coverage) && Coverage.running?
+      use_merging = merging
+
+      # Collect our coverage result. When merging is off there is no merge
+      # step, so this per-process result is the final one and reports any
+      # dropped source files; otherwise the merged result does the reporting.
+      process_coverage_result(report: !use_merging) if defined?(Coverage) && Coverage.running?
 
       # If we're using merging of results, store the current result
       # first (if there is one), then merge the results and return those
-      if merging
-        wait_for_other_processes
+      if use_merging
         SimpleCov::ResultMerger.store_result(@result) if result?
+        return @result unless finalize_merge?
+
+        wait_for_other_processes
         @result = SimpleCov::ResultMerger.merged_result
       end
 
@@ -50,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
@@ -152,11 +166,14 @@ module SimpleCov
     end
 
     # Run all the steps that handle processing the raw coverage result.
-    def process_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.
+    def process_coverage_result(report:)
       @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
       @result = SimpleCov::ResultAdapter.call(@result)
       result, not_loaded_files = add_not_loaded_files(@result)
-      @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files)
+      @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files, report: report)
     end
   end
 end

data/lib/simplecov/source_file/skip_chunks.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module SimpleCov
   class SourceFile
     # Computes the set of line ranges that should be excluded from a

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 begin
   require "prism"
 rescue LoadError
@@ -81,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.rc2"
+  VERSION = "1.0.0.rc4"
 end

data/lib/simplecov.rb

@@ -37,6 +37,21 @@ module SimpleCov
     def next_subprocess_serial!
       @subprocess_serial = subprocess_serial + 1
     end
+
+    # @api private — true in a process that was forked while coverage was
+    # running (set by SimpleCov::ProcessForkHook in the child). Such a child
+    # stores its own slice but must not act as the final-result process: the
+    # process that forked it merges every slice and produces the report. Only
+    # consulted when no parallel-test adapter is active, since adapters answer
+    # `first_worker?` themselves. See issue #1171.
+    def forked_subprocess?
+      !!(defined?(@forked_subprocess) && @forked_subprocess)
+    end
+
+    # @api private — marked in the child immediately after a fork.
+    def mark_forked_subprocess!
+      @forked_subprocess = true
+    end
     # Should we take care of at_exit behavior or something else? Used by the
     # minitest plugin. See lib/minitest/simplecov_plugin.rb.
     attr_accessor :external_at_exit
@@ -148,7 +163,7 @@ module SimpleCov
 
     #
     # Trigger Coverage.start with the configured criteria. Every supported
-    # runtime (CRuby >= 3.1, JRuby >= 9.4, TruffleRuby >= 22) accepts the
+    # runtime (CRuby >= 3.2, JRuby >= 10, TruffleRuby >= 22) accepts the
     # criteria-hash form, so no compatibility fallback is needed.
     #
     def start_coverage_measurement
@@ -199,7 +214,6 @@ module SimpleCov
 end
 
 # requires are down here for a load order reason I'm not sure what it is about
-require "set"
 require "forwardable"
 require_relative "simplecov/color"
 require_relative "simplecov/deprecation"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  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.rc2
+  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.rc2
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.0.rc4
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -161,14 +162,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !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: []