simplecov 1.0.0.rc1 → 1.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa29d54833537aa0434a697ada8befbfbb81c97c608afc1e7cddd6971009ec79
-  data.tar.gz: df39d6ee8257c5cc7575621d83a428a96f80fc1db762bf3e247927ace5d1050d
+  metadata.gz: eda0f749acc9b248635b6b1128c601b28bd77304994f78ebbbec0fc9097a2969
+  data.tar.gz: 8d55b00892b8f2cd47f7d3960c52e5d177c4951a77cbcd4af42282ae7ec745fa
 SHA512:
-  metadata.gz: be38ab39b2d235b3a2fbdd7fcd298684f1ff43d40e966a43174489da2b2680ac99dfba059b70ebcd774353265f5feab852a126ca242c97703f6e0bffea29f3c1
-  data.tar.gz: 91e057b46a0f7be3d914af750bedd7fcc3abe174db97970a7babedd85b047bfe69a682b34723f0d60115d6d4b1f674e854c431f854ff4f054b6194c6e9ab07d3
+  metadata.gz: 4cafbbdb4eb3ee18f0c6fad85b865e5522d7e5b86d8d154a42b716a61bfbf57a734d2a0381f95d0d59cd6b914d910f559054725ba92ed6c3f1388421299d824e
+  data.tar.gz: 79c267679cbf76017bbbc2541ab239a226145c2b798fc75731492f7600edafc9efe7c56e3e5a769392b4a0dff7b1a3a8d808af8a9d341b6ab26b6c19b1676a6a

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+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)
+======================
+
+## Bugfixes
+* Forked subprocesses (for example Rails' `parallelize`) are now named by a stable per-run serial rather than the child's OS process id. Because the pid changed every run, a re-run's worker results were never named the same as the previous run's and so never overwrote them. They accumulated in `.resultset.json` until `merge_timeout` dropped them, and while several runs sat inside that window together SimpleCov merged them all. When the set of files had drifted between those runs (a deleted file, a changed filter) the stale results leaked into the report, inflating the denominator and changing the coverage percentage from one run to the next. The serial sequence is identical from one run to the next, so a re-run's workers now overwrite the previous run's entries and the resultset stays bounded. See #1171.
+* The "Excluded N result(s) older than `merge_timeout`" warning is now emitted at most once, from the reporting process, instead of once per forked worker. Every worker merges the resultset too, and the default `at_fork` sets `print_errors false` for them, but this one warning did not honor the flag, so an eight-worker run printed eight copies. See #1171.
+* Legacy-API deprecation warnings (`track_files`, `add_filter`, `add_group`, and the rest) are now deduplicated by call site and emitted at most once per source location. A deprecated method called in a loop, or a configuration block re-evaluated once per parallel worker or spec file, previously repeated the same notice until the surrounding output was unreadable. See #1204.
+
 1.0.0.rc1 (2026-06-02)
 ======================
 

data/README.md

@@ -742,6 +742,12 @@ 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.
+
 ### Merging across execution environments
 
 If your tests run in parallel across multiple build machines, download each run's `.resultset.json` and merge them into
@@ -1262,7 +1268,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/configuration/coverage_criteria.rb

@@ -110,8 +110,8 @@ module SimpleCov
 
     # DEPRECATED: prefer `enable_coverage :eval`.
     def enable_coverage_for_eval
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.enable_coverage_for_eval` is deprecated. " \
-           "Replace with `SimpleCov.enable_coverage :eval`."
+      SimpleCov::Deprecation.warn("`SimpleCov.enable_coverage_for_eval` is deprecated. " \
+                                  "Replace with `SimpleCov.enable_coverage :eval`.")
       enable_eval_coverage
     end
 

data/lib/simplecov/configuration/filters.rb

@@ -58,8 +58,8 @@ module SimpleCov
     # historical `track_files` behavior) and restricts the report to the
     # matching set.
     def track_files(glob)
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.track_files` is deprecated. " \
-           "#{track_files_replacement_hint(glob)}"
+      SimpleCov::Deprecation.warn("`SimpleCov.track_files` is deprecated. " \
+                                  "#{track_files_replacement_hint(glob)}")
       @tracked_files = glob
     end
 
@@ -102,8 +102,8 @@ module SimpleCov
     # DEPRECATED: alias for `skip`. Same matcher grammar, identical behavior.
     def add_filter(filter_argument = nil, &block)
       example = block ? "`SimpleCov.skip { ... }`" : "`SimpleCov.skip #{filter_argument.inspect}`"
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.add_filter` is deprecated. " \
-           "Replace with `SimpleCov.skip` (same arguments, same behavior). Example: #{example}."
+      SimpleCov::Deprecation.warn("`SimpleCov.add_filter` is deprecated. " \
+                                  "Replace with `SimpleCov.skip` (same arguments, same behavior). Example: #{example}.")
       skip(filter_argument, &block)
     end
 
@@ -141,8 +141,10 @@ module SimpleCov
                 else
                   "`SimpleCov.group #{group_name.inspect}, #{filter_argument.inspect}`"
                 end
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.add_group` is deprecated. " \
-           "Replace with `SimpleCov.group` (same arguments, same behavior). Example: #{example}."
+      SimpleCov::Deprecation.warn(
+        "`SimpleCov.add_group` is deprecated. " \
+        "Replace with `SimpleCov.group` (same arguments, same behavior). Example: #{example}."
+      )
       group(group_name, filter_argument, &block)
     end
 

data/lib/simplecov/configuration/formatting.rb

@@ -89,8 +89,8 @@ module SimpleCov
 
     # DEPRECATED: alias for `print_errors`. Same value, same behavior.
     def print_error_status
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.print_error_status` is deprecated. " \
-           "Replace with `SimpleCov.print_errors` (same value)."
+      SimpleCov::Deprecation.warn("`SimpleCov.print_error_status` is deprecated. " \
+                                  "Replace with `SimpleCov.print_errors` (same value).")
       defined?(@print_error_status) ? @print_error_status : true
     end
 
@@ -101,8 +101,8 @@ module SimpleCov
     # be removed in a future release.
     #
     def nocov_token(nocov_token = nil)
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.nocov_token` and `SimpleCov.skip_token` are deprecated. " \
-           "Replace with `# simplecov:disable` / `# simplecov:enable` block comments."
+      SimpleCov::Deprecation.warn("`SimpleCov.nocov_token` and `SimpleCov.skip_token` are deprecated. " \
+                                  "Replace with `# simplecov:disable` / `# simplecov:enable` block comments.")
       current_nocov_token(nocov_token)
     end
     alias skip_token nocov_token

data/lib/simplecov/configuration/merging.rb

@@ -36,8 +36,8 @@ module SimpleCov
 
     # DEPRECATED: alias for `merge_subprocesses`. Same value/behavior.
     def enable_for_subprocesses(value = nil)
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.enable_for_subprocesses` is deprecated. " \
-           "Replace with `SimpleCov.merge_subprocesses` (same value, same behavior)."
+      SimpleCov::Deprecation.warn("`SimpleCov.enable_for_subprocesses` is deprecated. " \
+                                  "Replace with `SimpleCov.merge_subprocesses` (same value, same behavior).")
       return @enable_for_subprocesses if defined?(@enable_for_subprocesses) && value.nil?
 
       @enable_for_subprocesses = value || false
@@ -56,8 +56,8 @@ module SimpleCov
 
     # DEPRECATED: alias for `merging`. Same value, same behavior.
     def use_merging(use = nil)
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.use_merging` is deprecated. " \
-           "Replace with `SimpleCov.merging` (same value, same behavior)."
+      SimpleCov::Deprecation.warn("`SimpleCov.use_merging` is deprecated. " \
+                                  "Replace with `SimpleCov.merging` (same value, same behavior).")
       @use_merging = use unless use.nil?
       @use_merging = true unless defined?(@use_merging) && @use_merging == false
     end
@@ -70,5 +70,18 @@ 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
   end
 end

data/lib/simplecov/configuration/thresholds.rb

@@ -76,8 +76,8 @@ module SimpleCov
       coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
       defaults, overrides = partition_per_file_thresholds(coverage)
 
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.minimum_coverage_by_file` is deprecated. " \
-           "Replace it with:\n#{per_file_coverage_replacement(defaults, overrides)}"
+      SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_file` is deprecated. " \
+                                  "Replace it with:\n#{per_file_coverage_replacement(defaults, overrides)}")
 
       raise_on_invalid_coverage(defaults, "minimum_coverage_by_file")
       overrides.each_value { |criteria| raise_on_invalid_coverage(criteria, "minimum_coverage_by_file") }
@@ -98,8 +98,8 @@ module SimpleCov
     def minimum_coverage_by_group(coverage = nil)
       return @minimum_coverage_by_group ||= {} unless coverage
 
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov.minimum_coverage_by_group` is deprecated. " \
-           "Replace it with:\n#{per_group_coverage_replacement(coverage)}"
+      SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_group` is deprecated. " \
+                                  "Replace it with:\n#{per_group_coverage_replacement(coverage)}")
       @minimum_coverage_by_group = coverage.dup.transform_values do |group_coverage|
         group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
         raise_on_invalid_coverage(group_coverage, "minimum_coverage_by_group")

data/lib/simplecov/configuration.rb

@@ -113,14 +113,19 @@ module SimpleCov
 
     #
     # Gets or sets the behavior to start a new forked Process.
-    # Defaults to adding " (subprocess: #{pid})" to command_name and
+    # Defaults to adding " (subprocess: #{serial})" to command_name and
     # starting SimpleCov in quiet mode.
     #
     def at_fork(&block)
       @at_fork = block if block
-      @at_fork ||= lambda { |pid|
-        # This needs a unique name so it won't be overwritten
-        SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{pid})"
+      @at_fork ||= lambda { |_pid|
+        # Needs a name that's unique per worker within a run yet identical
+        # across runs. Build it from SimpleCov's stable fork serial rather
+        # than the OS pid: with the pid, every run produced uniquely-named
+        # results that never overwrote the previous run's, so they piled up
+        # in .resultset.json until merge_timeout and the merged report's
+        # file set drifted from run to run. See issue #1171.
+        SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{SimpleCov.subprocess_serial})"
         # be quiet, the parent process will use the regular formatter
         SimpleCov.print_errors false
         SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter

data/lib/simplecov/deprecation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Emits legacy-API deprecation warnings, deduplicated by the source
+  # location that triggered them. A deprecated method called in a loop —
+  # or a config block re-evaluated once per parallel worker / spec file —
+  # otherwise repeats the same notice until stderr is unreadable. Keying
+  # on the caller location collapses those repeats to a single line while
+  # still warning separately about each distinct call site the user needs
+  # to fix. See issue #1204.
+  module Deprecation
+  module_function
+
+    # Warn about a deprecated API. `message` is the notice without the
+    # `[DEPRECATION]` tag or location prefix (both are added here).
+    #
+    # `location` defaults to the caller of the deprecated method that
+    # called us — every shipped call site is a one-level alias such as
+    # `track_files`, so the frame two up is the user code. Pass `location:`
+    # explicitly when the relevant site isn't that frame (e.g. a source
+    # file and line discovered while parsing).
+    # `Array(...)` coerces a missing backtrace (nil) to `[]` so `.first`
+    # yields nil rather than raising — and, unlike `&.`, adds no branch for
+    # the unreachable no-caller case to the project's 100% coverage target.
+    def warn(message, location: Array(Kernel.caller(2..2)).first)
+      # Key on location when we have one (collapses a deprecated call in a
+      # loop to a single warning); fall back to the message so a missing
+      # backtrace never silently swallows every notice.
+      return unless emitted.add?(location || message)
+
+      Kernel.warn "#{"#{location}: " if location}[DEPRECATION] #{message}"
+    end
+
+    # Already-emitted dedup keys for this process. Parallel workers are
+    # separate processes with their own set, so each warns at most once.
+    def emitted
+      @emitted ||= Set.new
+    end
+
+    # @api private — reset emitted state between tests.
+    def reset!
+      @emitted = Set.new
+    end
+  end
+end

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

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_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

@@ -15,8 +15,20 @@ module SimpleCov
   # the child.
   module ProcessForkHook
     def _fork
+      active = defined?(SimpleCov) && Coverage.running?
+      # Assign the next serial in the PARENT, before the fork, so the child
+      # inherits its own stable ordinal via copy-on-write. The default
+      # at_fork uses it (instead of the child pid) to name the subprocess's
+      # result, keeping that name identical across runs. See issue #1171.
+      SimpleCov.next_subprocess_serial! if active
       pid = super
-      SimpleCov.at_fork.call(::Process.pid) if pid.zero? && defined?(SimpleCov) && Coverage.running?
+      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

@@ -68,6 +68,14 @@ module SimpleCov
       end
 
       def warn_about_expired_results(expired_command_names)
+        # Subprocesses merge the resultset too (each forked worker calls
+        # `SimpleCov.result` to store its slice), and the default `at_fork`
+        # sets `print_errors false` for them. Without this guard the warning
+        # is emitted once per worker — N copies of the same message for an
+        # N-worker run. Gate on `print_errors` like every other SimpleCov
+        # warning so only the reporting process speaks up.
+        return unless SimpleCov.print_errors
+
         warn "[SimpleCov]: Excluded #{expired_command_names.size} result(s) older than " \
              "merge_timeout (#{SimpleCov.merge_timeout}s) from the merged report: " \
              "#{expired_command_names.sort.join(', ')}. " \
@@ -78,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,10 +13,10 @@ 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)
@@ -31,12 +31,16 @@ 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
+      if use_merging
         wait_for_other_processes
         SimpleCov::ResultMerger.store_result(@result) if result?
         @result = SimpleCov::ResultMerger.merged_result
@@ -152,11 +156,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/source_file.rb

@@ -123,8 +123,8 @@ module SimpleCov
 
     # DEPRECATED: use `covered_percent(:branch)`.
     def branches_coverage_percent
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
-           "Use `covered_percent(:branch)`."
+      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
+                                  "Use `covered_percent(:branch)`.")
       covered_percent(:branch)
     end
 
@@ -176,8 +176,8 @@ module SimpleCov
 
     # DEPRECATED: use `covered_percent(:method)`.
     def methods_coverage_percent
-      warn "#{Kernel.caller.first}: [DEPRECATION] `SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
-           "Use `covered_percent(:method)`."
+      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
+                                  "Use `covered_percent(:method)`.")
       covered_percent(:method)
     end
 

data/lib/simplecov/static_coverage_extractor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 begin
   require "prism"
 rescue LoadError

data/lib/simplecov/version.rb

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

data/lib/simplecov.rb

@@ -21,6 +21,37 @@ module SimpleCov
     # so JSONFormatter can detect when an existing coverage.json was written
     # by a sibling process running concurrently.
     attr_accessor :process_start_time
+
+    # A monotonically increasing serial the parent assigns to each forked
+    # subprocess (see SimpleCov::ProcessForkHook). The default `at_fork`
+    # builds the worker's command_name from this rather than the OS pid:
+    # the serial sequence is the same from one run to the next, so a re-run
+    # overwrites the previous run's resultset entries instead of writing
+    # uniquely-named ones that pile up until merge_timeout. See issue #1171.
+    def subprocess_serial
+      @subprocess_serial ||= 0
+    end
+
+    # @api private — bump the serial in the parent before a fork so the
+    # child inherits its own ordinal via copy-on-write.
+    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
@@ -132,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
@@ -183,9 +214,9 @@ 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"
 require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
 require_relative "simplecov/coverage_statistics"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc3
 platform: ruby
 authors:
 - Erik Berlin
@@ -71,6 +71,7 @@ files:
 - lib/simplecov/coverage_statistics.rb
 - lib/simplecov/coverage_violations.rb
 - lib/simplecov/defaults.rb
+- lib/simplecov/deprecation.rb
 - lib/simplecov/directive.rb
 - lib/simplecov/exit_codes.rb
 - lib/simplecov/exit_codes/exit_code_handling.rb
@@ -149,9 +150,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.rc1
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.0.rc3
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.0.rc1
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.0.rc3
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -160,14 +161,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.12
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Code coverage for Ruby
 test_files: []