simplecov 1.0.3 → 1.1.0

data/lib/simplecov/result_merger/resultset_file.rb

@@ -5,9 +5,10 @@ require "json"
 module SimpleCov
   module ResultMerger
     # Read + parse a `.resultset.json` file with the same tolerance the
-    # historical `ResultMerger` had: missing file returns `{}`, an empty
-    # or unparseable file warns and returns `{}`, parse success returns
-    # the decoded Hash.
+    # historical `ResultMerger` had: a missing or empty file quietly
+    # returns `{}`, an unparseable one warns and returns `{}`, and parse
+    # success returns the decoded Hash with any malformed entries
+    # warned about and dropped.
     module ResultsetFile
     module_function
 
@@ -16,20 +17,55 @@ module SimpleCov
         decode(data)
       end
 
+      # A missing or blank file quietly means "no results yet"; anything
+      # else — a 1-byte truncation included — flows through decode so
+      # corruption warns instead of silently vanishing (the old
+      # `length < 2` check swallowed exactly those). Read first and
+      # rescue rather than check exist? (racy against a concurrent
+      # clean).
       def read(path)
-        return unless File.exist?(path)
-
         data = File.read(path)
-        return if data.nil? || data.length < 2
+        return if data.match?(/\A\s*\z/)
 
         data
+      rescue Errno::ENOENT
+        nil
       end
 
       def decode(content)
         return {} unless content
 
-        JSON.parse(content) || {}
+        parsed = JSON.parse(content)
+        return {} if parsed.nil? # a "null" file has long meant an empty resultset
+
+        # Valid JSON need not be an object ("[1,2]" and "\"x\"" parse
+        # fine), but everything downstream iterates command => data
+        # pairs, so anything else would crash out of the middle of a
+        # merge. Same tolerance as a parse failure: warn and move on.
+        parsed.is_a?(Hash) ? drop_malformed_entries(parsed) : invalid_resultset
       rescue StandardError
+        invalid_resultset
+      end
+
+      # Each surviving entry must have the shape every consumer relies
+      # on: a Hash carrying a Numeric "timestamp" (the merge-timeout
+      # check) and a Hash "coverage" (the merge fold). A truncated or
+      # hand-edited entry would otherwise crash out of the middle of an
+      # at_exit merge, so it gets the same warn-and-move-on treatment
+      # as an unparseable file.
+      def drop_malformed_entries(resultset)
+        malformed, valid = resultset.partition { |_command_name, data| !well_formed_entry?(data) }
+        return resultset if malformed.empty?
+
+        warn "[SimpleCov]: Warning! Ignoring malformed resultset entries: #{malformed.map(&:first).sort.join(', ')}"
+        valid.to_h
+      end
+
+      def well_formed_entry?(data)
+        data.is_a?(Hash) && data["timestamp"].is_a?(Numeric) && data["coverage"].is_a?(Hash)
+      end
+
+      def invalid_resultset
         warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
         {}
       end

data/lib/simplecov/result_merger/resultset_run_identity.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    # Run/worker metadata queries used by resultset storage and parallel
+    # coordination. Kept separate from the coverage-folding implementation.
+    module ResultsetRunIdentity
+      # One namespaced identity per distinct worker that wrote to the
+      # current run: `[:worker, id]` for entries that carry a worker id,
+      # `[:legacy, command_name]` for fresh entries written without one
+      # (an old SimpleCov writing to the same resultset). Pairs rather
+      # than mangled strings, so a resultset mixing both kinds can never
+      # alias a real worker id to a synthesized legacy identity.
+      def worker_identities_for_run(results, run_id, started_at)
+        results.filter_map do |command_name, data|
+          next unless current_run_entry?(data, run_id, started_at)
+
+          worker_id = data["worker_id"]
+          worker_id.to_s.empty? ? [:legacy, command_name] : [:worker, worker_id.to_s]
+        end.uniq
+      end
+
+      def current_run_entry?(entry, run_id, started_at)
+        return false unless entry.is_a?(Hash)
+
+        entry_run_id = entry["run_id"]
+        return fresh_entry?(entry, started_at) unless entry_run_id
+        return false unless run_id && entry_run_id == run_id
+        return true if SimpleCov::RunIdentity.authoritative?
+
+        fresh_entry?(entry, started_at)
+      end
+
+      def fresh_entry?(entry, started_at)
+        timestamp = entry["timestamp"]
+        timestamp.is_a?(Numeric) && started_at && timestamp >= started_at.to_f
+      end
+
+      # Whether `entry` was written by a runner concurrent with this
+      # process: either it shares our run id (`current_run_entry?`), or it
+      # was written strictly after our process started. A mismatched run
+      # id must not defeat the timestamp check — a subprocess we shelled
+      # out to (fork+exec) generates its own random run id, and its
+      # freshly written entry is exactly the data issue #581 protects
+      # from being clobbered. Strict id matching is reserved for worker
+      # counting (`worker_identities_for_run`), where admitting a stale
+      # entry would end a sibling wait early.
+      def concurrent_runner_entry?(entry, incoming = nil)
+        return false unless entry.is_a?(Hash)
+
+        incoming_run_id = incoming["run_id"] if incoming.is_a?(Hash)
+        started_at = SimpleCov.process_start_time
+        return true if current_run_entry?(entry, incoming_run_id, started_at)
+
+        written_after_start?(entry, started_at)
+      end
+
+      # Strictly after, unlike `fresh_entry?`: an entry stamped at the
+      # exact instant we started is treated as leftover from a previous
+      # run, so a same-second stale entry is still overwritten.
+      def written_after_start?(entry, started_at)
+        timestamp = entry["timestamp"]
+        timestamp.is_a?(Numeric) && started_at && timestamp > started_at.to_f
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger/resultset_store.rb

@@ -2,6 +2,8 @@
 
 require "fileutils"
 require "json"
+require "monitor"
+require_relative "../atomic_file"
 
 module SimpleCov
   module ResultMerger
@@ -9,6 +11,9 @@ module SimpleCov
     # file-lock synchronization between processes and atomic temp-file
     # renames so concurrent readers don't observe a truncated file.
     module ResultsetStore
+      LOCK_MONITOR = Monitor.new
+      private_constant :LOCK_MONITOR
+
     module_function
 
       def resultset_path
@@ -19,23 +24,21 @@ module SimpleCov
         File.join(SimpleCov.coverage_path, ".resultset.json.lock")
       end
 
+      # Compact JSON, not pretty-printed: this is a machine-read cache
+      # that every parallel worker rewrites wholesale, and on a large
+      # project pretty printing nearly doubles the bytes written, read
+      # back, and parsed on each of those store-merge round trips.
       def write(resultset)
-        FileUtils.mkdir_p(SimpleCov.coverage_path)
-        temp_path = "#{resultset_path}.#{Process.pid}.tmp"
-        File.open(temp_path, "w") { |f| f.puts JSON.pretty_generate(resultset) }
-        File.rename(temp_path, resultset_path)
+        AtomicFile.write(resultset_path, "#{JSON.generate(resultset)}\n")
       end
 
-      # Ensure only one process is reading or writing the resultset at
-      # any given time. Reentrant: the lock is acquired once per outer
-      # call no matter how deeply nested.
+      # Serialize threads before taking the process-wide file lock. Nested
+      # calls by the owning thread bypass flock so they cannot deadlock on a
+      # second descriptor for the same lock file.
       def synchronize(&)
-        return yield if @locked
+        return yield if LOCK_MONITOR.mon_owned?
 
-        @locked = true
-        with_flock(&)
-      ensure
-        @locked = false
+        LOCK_MONITOR.synchronize { with_flock(&) }
       end
 
       def with_flock

data/lib/simplecov/result_merger/unloaded_files.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    # The merge step's half of unloaded-file handling: the policy of when
+    # to inject and which criteria simulated files carry. The mechanism —
+    # expanding globs and simulating each file — is
+    # `SimpleCov::UnloadedFileInjector`, an easy name to confuse with this
+    # one.
+    #
+    # Injection moved here from the individual processes because only the union
+    # of what they all loaded says what was really never loaded. Doing it per
+    # process meant N workers simulated the same file up to N times and the
+    # merge threw all but one away. See #1250.
+    module UnloadedFiles
+    module_function
+
+      # The union of what every contributing process was told to track. Absent
+      # from resultsets written before this was recorded, in which case those
+      # processes injected their own unloaded files and the data is already in
+      # the coverage hash.
+      # A collector for the merge to hand `merge_valid_results`, gathering the
+      # tracked paths of every resultset that survives the merge timeout.
+      def collector(into)
+        ->(surviving) { into.merge(tracked_in(surviving)) }
+      end
+
+      def tracked_in(resultset)
+        resultset.each_with_object(Set.new) do |(_command_name, data), set|
+          set.merge(Array(data["tracked_files"]))
+        end
+      end
+
+      # Concurrent workers sharing a command name may have been told to track
+      # different sets, so keep both rather than letting the later write win.
+      def carry_tracked(entry, existing, incoming)
+        tracked = Array(existing["tracked_files"]) | Array(incoming["tracked_files"])
+        tracked.empty? ? entry : entry.merge("tracked_files" => tracked)
+      end
+
+      # Simulate each tracked file the merged coverage doesn't already carry.
+      # The paths come from the resultsets rather than this process's own
+      # configuration, which a standalone `collate` would not have: it never ran
+      # `SimpleCov.start`, so it has no `cover` glob to expand. Idempotent, so
+      # resultsets from an older SimpleCov (or from a `merging false` process)
+      # that already carry their unloaded files pass through untouched.
+      def inject(coverage, tracked_files)
+        SimpleCov.inject_unloaded_files(
+          coverage, tracked_files.to_a,
+          synthesize: carries?(coverage, "branches") || carries?(coverage, "methods"),
+          lines: carries?(coverage, "lines")
+        )
+      end
+
+      # A simulated file should have the same shape as the files it is being
+      # merged alongside, so the criteria come from the merged data rather than
+      # from this process's configuration, which is not necessarily the
+      # configuration any contributing process measured under: `simplecov merge`
+      # never ran `SimpleCov.start` at all. Giving injected files fewer tables
+      # than their neighbours is what inflates the percentage #1059 fixed.
+      #
+      # Falls back to the configuration when there is nothing to be consistent
+      # with, which is a merge of resultsets that carried no files.
+      def carries?(coverage, criterion)
+        return SimpleCov.public_send(CRITERION_PREDICATES.fetch(criterion)) if coverage.empty?
+
+        coverage.any? { |_filename, file_coverage| file_coverage[criterion] }
+      end
+
+      CRITERION_PREDICATES = {
+        "lines" => :line_coverage?,
+        "branches" => :branch_coverage?,
+        "methods" => :method_coverage?
+      }.freeze
+      private_constant :CRITERION_PREDICATES
+
+      # Which files no contributing process ever loaded. Injection reports the
+      # ones it added, but a file can also arrive already simulated from a
+      # resultset this merge didn't inject into, so the merged line counts are
+      # still consulted, using the same signal
+      # `Combine::CoverageAccumulator` reconciles synthesized tuples on.
+      #
+      # A file is judged only when it has a relevant line. A branch-only or
+      # method-only run reports no line data at all for the files it loaded,
+      # and a loaded file with no executable lines (a comment-only constants
+      # stub, say) reports every line as `nil` — either would otherwise read
+      # as "never executed" and mark a genuinely loaded file not loaded,
+      # turning its branch and method coverage into #902's 0%.
+      # `SimulateCoverage` omits lines under those criteria too and gives a
+      # simulated file a `0` on every relevant line, so genuinely unloaded
+      # files still carry judgeable data, and a simulated file with none is
+      # already flagged by injection reporting it.
+      def never_executed(coverage)
+        coverage.each_with_object(Set.new) do |(filename, file_coverage), set|
+          counts = Array(file_coverage["lines"]) #: Array[Integer?]
+          next unless counts.any? { |count| !count.nil? }
+
+          set << filename unless Combine::CoverageAccumulator.executed?(file_coverage["lines"])
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger.rb

@@ -2,7 +2,9 @@
 
 require_relative "result_merger/legacy_format_adapter"
 require_relative "result_merger/resultset_file"
+require_relative "result_merger/resultset_run_identity"
 require_relative "result_merger/resultset_store"
+require_relative "result_merger/unloaded_files"
 
 module SimpleCov
   #
@@ -11,6 +13,8 @@ module SimpleCov
   # upon multiple test suites.
   #
   module ResultMerger
+    extend ResultsetRunIdentity
+
     class << self
       def resultset_path
         ResultsetStore.resultset_path
@@ -23,29 +27,58 @@ module SimpleCov
       end
 
       def merge_results(*file_paths, ignore_timeout: false)
-        # It is intentional here that files are only read in and parsed one at a time.
-        #
-        # In big CI setups you might deal with 100s of CI jobs and each one producing Megabytes
-        # of data. Reading them all in easily produces Gigabytes of memory consumption which
-        # we want to avoid.
-        #
-        # For similar reasons a SimpleCov::Result is only created in the end as that'd create
-        # even more data especially when it also reads in all source files.
-        initial_memo = valid_results(file_paths.shift, ignore_timeout: ignore_timeout)
-
-        command_names, coverage = file_paths.reduce(initial_memo) do |memo, file_path|
-          merge_coverage(memo, valid_results(file_path, ignore_timeout: ignore_timeout))
-        end
+        # Tracked paths are collected as each resultset is parsed, so files are
+        # still read and discarded one at a time. See #1250.
+        tracked_files = Set.new
+        command_names, coverage = absorb_results(file_paths, ignore_timeout: ignore_timeout,
+                                                 &UnloadedFiles.collector(tracked_files))
+        create_result(command_names, coverage, tracked_files: tracked_files)
+      end
 
-        create_result(command_names, coverage)
+      #
+      # Reads every resultset and folds it into one merged coverage, stopping
+      # short of building a `SimpleCov::Result`.
+      #
+      # It is intentional here that files are only read in and parsed one at a time.
+      #
+      # In big CI setups you might deal with 100s of CI jobs and each one producing Megabytes
+      # of data. Reading them all in easily produces Gigabytes of memory consumption which
+      # we want to avoid.
+      #
+      # For similar reasons a SimpleCov::Result is only created in the end as that'd create
+      # even more data especially when it also reads in all source files.
+      #
+      # One accumulator absorbs the whole run, rather than folding each file
+      # into the merged-so-far pairwise: the pairwise form rebuilt every
+      # file's coverage once per resultset, which is what made merging a
+      # large parallel run's results the dominant cost of `collate`.
+      # Absorbing is still one resultset at a time, so the memory ceiling
+      # above is unchanged.
+      #
+      # `file_paths` is only ever iterated, so a caller that wants to observe
+      # the merge as it goes can hand in any Enumerable — `benchmarks/collate`
+      # passes an Enumerator that reports progress — rather than reimplement
+      # this loop and risk timing something other than what ships.
+      #
+      # @return [Array] the command names and the merged coverage
+      #
+      def absorb_results(file_paths, ignore_timeout: false, &on_parse)
+        Combine::CoverageAccumulator.fold(
+          file_paths.lazy.map { |file_path| valid_results(file_path, ignore_timeout: ignore_timeout, &on_parse) }
+        )
       end
 
-      def valid_results(file_path, ignore_timeout: false)
-        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout)
+      # Yields the surviving entries before they are reduced.
+      def valid_results(file_path, ignore_timeout: false, &on_parse)
+        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout, &on_parse)
       end
 
+      # Yields the entries that survived the merge timeout, so a caller that
+      # wants to observe what a resultset carried sees only what is being
+      # merged. An expired entry contributes nothing, tracked paths included.
       def merge_valid_results(results, ignore_timeout: false)
         results = drop_expired_results(results) unless ignore_timeout
+        yield results if block_given?
 
         command_plus_coverage = results.map do |command_name, data|
           [[command_name], LegacyFormatAdapter.call(data.fetch("coverage"))]
@@ -68,12 +101,9 @@ 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.
+        # Respect quiet configurations and keep this consistent with every
+        # other SimpleCov diagnostic. Ordinary parallel workers only store
+        # their own slice; the selected final process performs this merge.
         return unless SimpleCov.print_errors
 
         warn "[SimpleCov]: Excluded #{expired_command_names.size} result(s) older than " \
@@ -82,26 +112,29 @@ module SimpleCov
              "Increase SimpleCov.merge_timeout to include them."
       end
 
-      def create_result(command_names, coverage)
+      def create_result(command_names, coverage, tracked_files: Set.new)
         return nil unless coverage
 
         command_name = command_names.reject(&:empty?).sort.join(", ")
+        coverage, injected = UnloadedFiles.inject(coverage, tracked_files)
         # 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)
+        SimpleCov::Result.new(
+          coverage,
+          command_name: command_name,
+          not_loaded_files: UnloadedFiles.never_executed(coverage) | injected,
+          tracked_files: tracked_files.to_a,
+          report: true
+        )
       end
 
       def merge_coverage(*results)
         return [[""], nil] if results.empty?
         return results.first if results.size == 1
 
-        results.reduce do |(memo_command, memo_coverage), (command, coverage)|
-          # timestamp is dropped here, which is intentional (we merge it, it gets a new time stamp as of now)
-          merged_coverage = Combine.combine(Combine::ResultsCombiner, memo_coverage, coverage)
-          [memo_command + command, merged_coverage]
-        end
+        Combine::CoverageAccumulator.fold(results)
       end
 
       #
@@ -109,8 +142,9 @@ module SimpleCov
       # SimpleCov::Result with merged coverage data and the command_name
       # for the result consisting of a join on all source result's names
       def merged_result
-        command_names, coverage = merge_valid_results(read_resultset)
-        create_result(command_names, coverage)
+        tracked_files = Set.new
+        command_names, coverage = merge_valid_results(read_resultset, &UnloadedFiles.collector(tracked_files))
+        create_result(command_names, coverage, tracked_files: tracked_files)
       end
 
       def read_resultset
@@ -139,19 +173,12 @@ module SimpleCov
       # overwriting, so an empty parent-process result doesn't clobber the
       # subprocess's real data. See https://github.com/simplecov-ruby/simplecov/issues/581.
       def merged_entry(existing, incoming)
-        return incoming unless concurrent_runner_entry?(existing)
+        return incoming unless concurrent_runner_entry?(existing, incoming)
 
-        incoming.merge(
-          "coverage" => Combine.combine(Combine::ResultsCombiner, existing["coverage"], incoming["coverage"])
+        merged = incoming.merge(
+          "coverage" => Combine::ResultsCombiner.combine(existing["coverage"], incoming["coverage"])
         )
-      end
-
-      def concurrent_runner_entry?(entry)
-        return false unless entry.is_a?(Hash)
-
-        timestamp = entry["timestamp"]
-        process_start = SimpleCov.process_start_time
-        timestamp && process_start && timestamp.to_i >= process_start.to_i
+        UnloadedFiles.carry_tracked(merged, existing, incoming)
       end
 
       def synchronize_resultset(&)