simplecov 1.0.2 → 1.1.0

data/lib/simplecov/report_stamp.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module SimpleCov
+  # Touches coverage/.report_stamp whenever a report is formatted, no
+  # matter how the run ends. The clobber-prevention backstop
+  # (`SimpleCov.defer_to_existing_report?`) needs an on-disk signal that
+  # a fresher report exists, and `.last_run.json` can't be it alone:
+  # that file is only written after fully successful runs, which left
+  # the backstop inert exactly when the child run failed and its report
+  # mattered most.
+  module ReportStamp
+    class << self
+      def path
+        File.join(SimpleCov.coverage_path, ".report_stamp")
+      end
+
+      def touch
+        FileUtils.touch(path)
+      rescue SystemCallError
+        # A read-only or vanished coverage dir must not crash reporting;
+        # the stamp only powers the deferral heuristic.
+        nil
+      end
+    end
+  end
+end

data/lib/simplecov/result.rb

@@ -15,6 +15,13 @@ module SimpleCov
 
     # Returns the original Coverage.result used for this instance of SimpleCov::Result
     attr_reader :original_result
+    # Every path the producing process was told to track, loaded or not. Carried
+    # into the resultset so a merge elsewhere can inject the ones nobody loaded
+    # without needing that process's `cover` / `track_files` config. See #1250.
+    attr_reader :tracked_files
+    # Invocation and top-level worker identities used only for parallel-result
+    # coordination. They do not change which fresh suites are merged.
+    attr_reader :run_id, :worker_id
     # Returns all files that are applicable to this result (sans filters!) as instances of
     # SimpleCov::SourceFile. Aliased as :source_files
     attr_reader :files
@@ -55,10 +62,11 @@ 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,
-                   report: false, filter_config: FilterConfig.new)
+                   tracked_files: [], run_id: nil, worker_id: nil, report: false, filter_config: FilterConfig.new)
       @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
+      initialize_coordination_metadata(tracked_files, run_id, worker_id)
       @groups_config = filter_config.groups
       builder = SourceFileBuilder.new(original_result, not_loaded_files: not_loaded_files)
       @files = builder.call
@@ -102,7 +110,13 @@ module SimpleCov
       formatter = SimpleCov.formatter
       return nil if formatter.nil?
 
-      formatter.new.format(self)
+      formatted = Formatter.format(formatter, self)
+      # Recorded regardless of how the run ends, so a parent process's
+      # clobber-prevention backstop can tell a report was produced even
+      # when this run's checks or tests failed (unlike .last_run.json,
+      # which only successful runs write).
+      SimpleCov::ReportStamp.touch
+      formatted
     end
 
     # Defines when this result has been created. Defaults to Time.now
@@ -118,23 +132,32 @@ module SimpleCov
 
     # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {
-        command_name => {
-          "coverage" => coverage,
-          "timestamp" => created_at.to_i
-        }
-      }
+      data = {"coverage" => coverage, "timestamp" => created_at.to_f} #: Hash[String, untyped]
+      data["run_id"] = run_id if run_id
+      data["worker_id"] = worker_id if worker_id
+      # Omitted when empty so a run that tracks nothing writes the shape it
+      # always has, and so the key only appears where it carries information.
+      data["tracked_files"] = tracked_files unless tracked_files.empty?
+      {command_name => data}
     end
 
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       hash.map do |command_name, data|
-        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]),
+                                    tracked_files: data["tracked_files"] || [], run_id: data["run_id"],
+                                    worker_id: data["worker_id"])
       end
     end
 
   private
 
+    def initialize_coordination_metadata(tracked_files, run_id, worker_id)
+      @tracked_files = tracked_files.to_a
+      @run_id = run_id
+      @worker_id = worker_id
+    end
+
     def warn_about_missing_source_files(missing, input_size)
       return if missing.empty?
 
@@ -156,8 +179,15 @@ module SimpleCov
       ).warn!
     end
 
+    # A live result's criterion keys are Symbols (`:lines`, `:branches`),
+    # while entries parsed back from `.resultset.json` carry Strings, and
+    # the combiners read only String keys. Serialize with String keys so a
+    # live result merged against a stored entry contributes its counts
+    # instead of being silently dropped for every shared file.
     def coverage
-      original_result.slice(*filenames)
+      original_result.slice(*filenames).transform_values do |file_coverage|
+        file_coverage.transform_keys(&:to_s)
+      end
     end
 
     # Applies the given filter chain to `@files`, dropping each source

data/lib/simplecov/result_adapter.rb

@@ -60,37 +60,69 @@ module SimpleCov
     SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
     private_constant :SINGLETON_WRAPPER_PATTERN
 
-    # Ruby's method coverage records one entry per RECEIVER, not per source
-    # location: a block handed to `define_method` / `define_singleton_method`
-    # from a shared code path (a module's `included` hook, a builder) yields
-    # a separate `[receiver, name, location]` entry for every class it's
-    # defined on, all pointing at the same source. A file-based report can
-    # only express "was the method at this location ever executed", so
-    # entries are aggregated by (name, location), summing hits — otherwise
-    # each receiver whose copy never ran shows as a phantom uncovered method
-    # on a line whose line coverage is 100% (issue #1234). The first entry's
-    # (normalized) receiver is kept for display.
+    # Ruby's method coverage records one entry per DEFINED METHOD, not per
+    # source location: a block handed to `define_method` /
+    # `define_singleton_method` from a shared code path yields a separate
+    # `[receiver, name, location]` entry for every class it's defined on
+    # (a module's `included` hook defining onto each descendant) AND for
+    # every name it's defined under (a builder looping `define_method key`
+    # over a container), all pointing at the same source. A file-based
+    # report can only express "was the method at this location ever
+    # executed", so entries are aggregated by location alone, summing
+    # hits — otherwise each receiver or name whose generated copy never
+    # ran shows as a phantom uncovered method on a line whose line
+    # coverage is 100%. Regular `def`s map one location to one name, so
+    # they are unaffected. The first entry's (normalized) key is kept for
+    # display. See issue #1234.
     def normalize_method_keys(cover_statistic)
       methods = cover_statistic[:methods]
       return unless methods
 
       aggregated = {} #: Hash[untyped, [untyped, Integer]]
       methods.each_with_object(aggregated) do |(key, count), memo|
-        identity = key[1..] #: Array[untyped]
-        retained_key, existing = memo[identity] || [normalize_method_key(key), 0]
-        memo[identity] = [retained_key, existing + count]
+        location = key[2..] #: Array[untyped]
+        retained_key, existing = memo[location] || [normalize_method_key(key), 0]
+        memo[location] = [retained_key, existing + count]
       end
       cover_statistic[:methods] = aggregated.values.to_h
     end
 
     def normalize_method_key(key)
       normalized_key = key.dup
-      normalized_key[0] = key[0].to_s
-                                .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
-                                .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+      normalized_key[0] = class_display_name(key[0])
+                          .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                          .sub(SINGLETON_WRAPPER_PATTERN, '\1')
       normalized_key
     end
 
+    # Rendering a class name can execute user code: a singleton class's
+    # `to_s` renders its attached object via `#inspect`, which a module can
+    # shadow with an incompatible signature (Liquid::Utils defines
+    # `inspect(value, max_depth = 2)` as a module_function, so rendering
+    # `#<Class:Liquid::Utils>` raises ArgumentError). A coverage report
+    # must never crash the host suite over that, so on failure rebuild the
+    # singleton wrapper from `Module#name` via bound methods (which cannot
+    # be shadowed), falling back to the address form, which
+    # ADDRESS_PATTERN then normalizes. See issue #1236.
+    def class_display_name(klass)
+      klass.to_s
+    rescue StandardError
+      singleton_wrapper_name(klass) || Object.instance_method(:to_s).bind_call(klass)
+    end
+
+    def singleton_wrapper_name(klass)
+      return nil unless klass.is_a?(Class) && klass.singleton_class?
+
+      attached = klass.attached_object
+      # simplecov:disable branch — CRuby only reaches the rescue via a
+      # Module/Class attached object (instance singletons render from the
+      # class name chain without calling user inspect), so the non-Module
+      # arm is defensive.
+      name = Module.instance_method(:name).bind_call(attached) if attached.is_a?(Module)
+      # simplecov:enable branch
+      name && "#<Class:#{name}>"
+    end
+
     # Ruby's eval coverage records a fresh set of branch entries for every
     # COMPILE of an eval'd string: a template rendered through multiple view
     # classes (e.g. hanami-view compiles each template once per view) yields

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