simplecov 1.0.0.rc2 → 1.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95cc757bf172ce50cd60e636048c88e30fade408c962d8fe8c9478465b6b2d67
-  data.tar.gz: 9ee4b98d8f3f790289415b03c3e37c436b32d1e2a9d193fd435dfdb966d4b658
+  metadata.gz: eda0f749acc9b248635b6b1128c601b28bd77304994f78ebbbec0fc9097a2969
+  data.tar.gz: 8d55b00892b8f2cd47f7d3960c52e5d177c4951a77cbcd4af42282ae7ec745fa
 SHA512:
-  metadata.gz: 719bcdfee0e3e79de52e7da4fdd955d85416b2c33c3b8bcd437d13187b9d883c6430ea55e0d52ca17c392cfe4e506f6a433278d5d285091858702bd669eb43bd
-  data.tar.gz: 4e70c6fabe5ed02ea4ece1ca811434c96b760e871507cc607a05af64710a9f0c14ee87c16dbcf82d19cdaaf23f3896d78ea0500e051130dbc15b7c6046e4b6b8
+  metadata.gz: 4cafbbdb4eb3ee18f0c6fad85b865e5522d7e5b86d8d154a42b716a61bfbf57a734d2a0381f95d0d59cd6b914d910f559054725ba92ed6c3f1388421299d824e
+  data.tar.gz: 79c267679cbf76017bbbc2541ab239a226145c2b798fc75731492f7600edafc9efe7c56e3e5a769392b4a0dff7b1a3a8d808af8a9d341b6ab26b6c19b1676a6a

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+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

@@ -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/merging.rb

@@ -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/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

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

@@ -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,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/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.rc2"
+  VERSION = "1.0.0.rc3"
 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.rc3
 platform: ruby
 authors:
 - Erik Berlin
@@ -150,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.rc2
+  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.rc2
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.0.rc3
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -161,7 +161,7 @@ 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:
   - - ">="