simplecov 0.22.0 → 1.0.2

data/lib/simplecov/result.rb

@@ -2,6 +2,8 @@
 
 require "digest/sha1"
 require "forwardable"
+require_relative "result/missing_source_files_reporter"
+require_relative "result/source_file_builder"
 
 module SimpleCov
   #
@@ -10,9 +12,11 @@ module SimpleCov
   #
   class Result
     extend Forwardable
+
     # Returns the original Coverage.result used for this instance of SimpleCov::Result
     attr_reader :original_result
-    # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+    # Returns all files that are applicable to this result (sans filters!) as instances of
+    # SimpleCov::SourceFile. Aliased as :source_files
     attr_reader :files
     alias source_files files
     # Explicitly set the Time this result has been created
@@ -20,20 +24,47 @@ module SimpleCov
     # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
     attr_writer :command_name
 
-    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics, :coverage_statistics_by_file
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength,
+                   :covered_lines, :missed_lines,
+                   :total_branches, :covered_branches, :missed_branches,
+                   :total_methods, :covered_methods, :missed_methods,
+                   :coverage_statistics, :coverage_statistics_by_file
     def_delegator :files, :lines_of_code, :total_lines
 
+    # Bundles the filter and grouping configuration a Result applies to its
+    # source files after building them. Each field defaults to the SimpleCov
+    # singleton's configuration, so ordinary callers never construct one;
+    # tests pass a custom instance to opt out of (or extend) the project's
+    # filters or groups (e.g. `filters: []` to keep every file). Grouping the
+    # three together keeps Result#initialize's parameter list small.
+    class FilterConfig
+      attr_reader :filters, :cover_filters, :groups
+
+      def initialize(filters: SimpleCov.filters, cover_filters: SimpleCov.cover_filters, groups: SimpleCov.groups)
+        @filters = filters
+        @cover_filters = cover_filters
+        @groups = groups
+      end
+    end
+
     # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
-    # coverage data)
-    def initialize(original_result, command_name: nil, created_at: nil)
-      result = original_result
-      @original_result = result.freeze
+    # coverage data).
+    #
+    # `filter_config` defaults to the SimpleCov singleton's filter / group
+    # configuration so existing call sites are unchanged. Pass a custom
+    # 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)
+      @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
-      @files = SimpleCov::FileList.new(result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
-      end.compact.sort_by(&:filename))
-      filter!
+      @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) if report
+      apply_cover_filters!(filter_config.cover_filters)
+      apply_filters!(filter_config.filters)
     end
 
     # Returns all filenames for source files contained in this result
@@ -41,14 +72,37 @@ module SimpleCov
       files.map(&:filename)
     end
 
-    # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
+    # Returns the SimpleCov::SourceFile for the given path, or nil if no
+    # matching file is in this result. The path is resolved against
+    # SimpleCov.root, so callers can pass either an absolute path or a
+    # project-relative one.
+    def source_file_for(path)
+      target = File.expand_path(path, SimpleCov.root)
+      files.find { |file| file.filename == target }
+    end
+
+    # Returns the {line:/branch:/method:} coverage_statistics hash for the
+    # given file path, or nil if no matching source file is in this
+    # result. See SimpleCov::Result#source_file_for for path resolution.
+    def coverage_for(path)
+      source_file_for(path)&.coverage_statistics
+    end
+
+    # Returns a Hash of groups for this result. Define groups using SimpleCov.group 'Models', 'app/models'
     def groups
-      @groups ||= SimpleCov.grouped(files)
+      @groups ||= SimpleCov.grouped(files, groups: @groups_config)
     end
 
-    # Applies the configured SimpleCov.formatter on this result
+    # Applies the configured SimpleCov.formatter on this result. Returns
+    # nil if formatting has been opted out of (`SimpleCov.formatter false`
+    # / `SimpleCov.formatters []`) — the cheap path for non-final
+    # processes in a parallel CI run, which only need their
+    # `.resultset.json` on disk. See #964.
     def format!
-      SimpleCov.formatter.new.format(self)
+      formatter = SimpleCov.formatter
+      return nil if formatter.nil?
+
+      formatter.new.format(self)
     end
 
     # Defines when this result has been created. Defaults to Time.now
@@ -81,14 +135,49 @@ module SimpleCov
 
   private
 
+    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,
+        every_entry_dropped: @files.empty? && missing.size == input_size
+      ).warn!
+    end
+
     def coverage
-      keys = original_result.keys & filenames
-      Hash[keys.zip(original_result.values_at(*keys))]
+      original_result.slice(*filenames)
     end
 
-    # Applies all configured SimpleCov filters on this result's source files
-    def filter!
-      @files = SimpleCov.filtered(files)
+    # Applies the given filter chain to `@files`, dropping each source
+    # file that any filter matches.
+    def apply_filters!(filters)
+      filters.each do |filter|
+        @files = SimpleCov::FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
+      end
+    end
+
+    # When any `cover` matcher is configured, restrict `@files` to source
+    # files matching at least one of them. With no cover matchers configured
+    # this is a no-op, preserving the historical "everything required, then
+    # filtered" universe.
+    def apply_cover_filters!(cover_filters)
+      return if cover_filters.empty?
+
+      @files = SimpleCov::FileList.new(
+        @files.select { |source_file| cover_filters.any? { |filter| filter.matches?(source_file) } }
+      )
     end
   end
 end

data/lib/simplecov/result_adapter.rb

@@ -11,20 +11,117 @@ module SimpleCov
       @result = result
     end
 
-    def self.call(*args)
-      new(*args).adapt
+    def self.call(*)
+      new(*).adapt
     end
 
     def adapt
       return unless result
 
-      result.each_with_object({}) do |(file_name, cover_statistic), adapted_result|
-        if cover_statistic.is_a?(Array)
-          adapted_result.merge!(file_name => {"lines" => cover_statistic})
-        else
-          adapted_result.merge!(file_name => cover_statistic)
-        end
+      result.to_h do |file_name, cover_statistic|
+        [file_name, adapt_one(file_name, cover_statistic)]
       end
     end
+
+  private
+
+    # Pre-0.18 resultsets pointed each filename straight at a line-coverage
+    # array; everything since uses the `{lines:, branches:, methods:}`
+    # shape. Newer entries also need their methods and branches tables
+    # massaged before downstream code reports or merges them.
+    def adapt_one(file_name, cover_statistic)
+      return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
+
+      adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      normalize_method_keys(cover_statistic)
+      aggregate_duplicated_branches(cover_statistic)
+      cover_statistic
+    end
+
+    # Normalize memory addresses in method coverage keys so that results
+    # from different processes can be merged. Anonymous class names like
+    # "#<Class:0x00007ff19ab24790>" get inconsistent addresses across runs.
+    # Address widths vary by runtime (32-bit hosts: 8 hex chars; 64-bit
+    # CRuby: 16; some JVM/TruffleRuby formats may differ), so match any
+    # length of hex digits and collapse to a single placeholder.
+    ADDRESS_PATTERN = /0x\h+/
+    private_constant :ADDRESS_PATTERN
+
+    ADDRESS_PLACEHOLDER = "0x0"
+    private_constant :ADDRESS_PLACEHOLDER
+
+    # Strip the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
+    # method keys. `module_function` and class methods get recorded both as
+    # singleton (`[#<Class:Foo>, :m, …]`) and instance/module (`[Foo, :m, …]`)
+    # entries pointing at the same source location; only one of the two is
+    # ever reachable at runtime, so we merge them. Only applies to named
+    # constants — anonymous-class addresses like `#<Class:0x0>` are left
+    # alone (handled by ADDRESS_PATTERN above).
+    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.
+    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]
+      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
+    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
+    # several `[:if, id, location]` conditions at identical coordinates in
+    # the same file, each counting only the renders that flowed through that
+    # compile. Reported as-is they inflate the branch denominator and turn a
+    # side covered under a different compile into a phantom miss (issue
+    # #1235). Aggregate them by (type, location) — combining a branches hash
+    # with an empty one dedups within it, since BranchesCombiner keys arms
+    # on location identity. Regular (non-eval) source can never produce two
+    # conditions at the same location, so this is a no-op outside eval.
+    def aggregate_duplicated_branches(cover_statistic)
+      branches = cover_statistic[:branches]
+      return unless branches
+
+      cover_statistic[:branches] = Combine::BranchesCombiner.combine(branches, {})
+    end
+
+    def adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      return unless cover_statistic.key?(:oneshot_lines)
+
+      oneshot_lines = cover_statistic.delete(:oneshot_lines)
+      line_stub     = build_line_stub(file_name, oneshot_lines)
+      oneshot_lines.each { |covered_line| line_stub[covered_line - 1] = 1 }
+      cover_statistic[:lines] = line_stub
+    end
+
+    def build_line_stub(file_name, oneshot_lines)
+      Coverage.line_stub(file_name)
+    rescue Errno::ENOENT, SyntaxError
+      Array.new(oneshot_lines.max || 0, nil)
+    end
   end
 end

data/lib/simplecov/result_merger/legacy_format_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    # We changed the format of the raw result data in simplecov, as people
+    # are likely to have "old" resultsets lying around (but not too old so
+    # that they're still considered we can adapt them). See
+    # https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
+    module LegacyFormatAdapter
+    module_function
+
+      def call(result)
+        pre_0_18?(result) ? upgrade(result) : result
+      end
+
+      # Pre-0.18 coverage data pointed from file directly to an array of
+      # line coverage rather than a `{"lines" => [...]}` hash.
+      def pre_0_18?(result)
+        _key, data = result.first
+        data.is_a?(Array)
+      end
+
+      def upgrade(result)
+        result.transform_values { |line_coverage_data| {"lines" => line_coverage_data} }
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger/resultset_file.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+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.
+    module ResultsetFile
+    module_function
+
+      def parse(path)
+        data = read(path)
+        decode(data)
+      end
+
+      def read(path)
+        return unless File.exist?(path)
+
+        data = File.read(path)
+        return if data.nil? || data.length < 2
+
+        data
+      end
+
+      def decode(content)
+        return {} unless content
+
+        JSON.parse(content) || {}
+      rescue StandardError
+        warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
+        {}
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger/resultset_store.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module SimpleCov
+  module ResultMerger
+    # Reads and writes the persistent `.resultset.json` cache, including
+    # file-lock synchronization between processes and atomic temp-file
+    # renames so concurrent readers don't observe a truncated file.
+    module ResultsetStore
+    module_function
+
+      def resultset_path
+        File.join(SimpleCov.coverage_path, ".resultset.json")
+      end
+
+      def writelock_path
+        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
+      end
+
+      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)
+      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.
+      def synchronize(&)
+        return yield if @locked
+
+        @locked = true
+        with_flock(&)
+      ensure
+        @locked = false
+      end
+
+      def with_flock
+        FileUtils.mkdir_p(SimpleCov.coverage_path)
+        File.open(writelock_path, "w+") do |f|
+          f.flock(File::LOCK_EX)
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
+require_relative "result_merger/legacy_format_adapter"
+require_relative "result_merger/resultset_file"
+require_relative "result_merger/resultset_store"
 
 module SimpleCov
   #
@@ -10,13 +12,8 @@ module SimpleCov
   #
   module ResultMerger
     class << self
-      # The path to the .resultset.json cache file
       def resultset_path
-        File.join(SimpleCov.coverage_path, ".resultset.json")
-      end
-
-      def resultset_writelock
-        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
+        ResultsetStore.resultset_path
       end
 
       def merge_and_store(*file_paths, ignore_timeout: false)
@@ -44,57 +41,56 @@ module SimpleCov
       end
 
       def valid_results(file_path, ignore_timeout: false)
-        results = parse_file(file_path)
-        merge_valid_results(results, ignore_timeout: ignore_timeout)
-      end
-
-      def parse_file(path)
-        data = read_file(path)
-        parse_json(data)
-      end
-
-      def read_file(path)
-        return unless File.exist?(path)
-
-        data = File.read(path)
-        return if data.nil? || data.length < 2
-
-        data
-      end
-
-      def parse_json(content)
-        return {} unless content
-
-        JSON.parse(content) || {}
-      rescue StandardError
-        warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
-        {}
+        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout)
       end
 
       def merge_valid_results(results, ignore_timeout: false)
-        results = results.select { |_command_name, data| within_merge_timeout?(data) } unless ignore_timeout
+        results = drop_expired_results(results) unless ignore_timeout
 
         command_plus_coverage = results.map do |command_name, data|
-          [[command_name], adapt_result(data.fetch("coverage"))]
+          [[command_name], LegacyFormatAdapter.call(data.fetch("coverage"))]
         end
 
         # one file itself _might_ include multiple test runs
         merge_coverage(*command_plus_coverage)
       end
 
+      def drop_expired_results(results)
+        fresh, expired = results.partition { |_command_name, data| within_merge_timeout?(data) }
+        return results if expired.empty?
+
+        warn_about_expired_results(expired.map(&:first))
+        fresh.to_h
+      end
+
       def within_merge_timeout?(data)
-        time_since_result_creation(data) < SimpleCov.merge_timeout
+        (Time.now - Time.at(data.fetch("timestamp"))) < SimpleCov.merge_timeout
       end
 
-      def time_since_result_creation(data)
-        Time.now - Time.at(data.fetch("timestamp"))
+      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(', ')}. " \
+             "Increase SimpleCov.merge_timeout to include them."
       end
 
       def create_result(command_names, coverage)
         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)
@@ -104,9 +100,7 @@ module SimpleCov
         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)
-          merged_command = memo_command + command
-
-          [merged_command, merged_coverage]
+          [memo_command + command, merged_coverage]
         end
       end
 
@@ -115,79 +109,53 @@ 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
-        # conceptually this is just doing `merge_results(resultset_path)`
-        # it's more involved to make syre `synchronize_resultset` is only used around reading
-        resultset_hash = read_resultset
-        command_names, coverage = merge_valid_results(resultset_hash)
-
+        command_names, coverage = merge_valid_results(read_resultset)
         create_result(command_names, coverage)
       end
 
       def read_resultset
-        resultset_content =
-          synchronize_resultset do
-            read_file(resultset_path)
-          end
-
-        parse_json(resultset_content)
+        content = synchronize_resultset { ResultsetFile.read(resultset_path) }
+        ResultsetFile.decode(content)
       end
 
       # Saves the given SimpleCov::Result in the resultset cache
-      def store_result(result)
+      def store_result(result) # rubocop:disable Naming/PredicateMethod
         synchronize_resultset do
           # Ensure we have the latest, in case it was already cached
           new_resultset = read_resultset
 
           # A single result only ever has one command_name, see `SimpleCov::Result#to_hash`
           command_name, data = result.to_hash.first
-          new_resultset[command_name] = data
-          File.open(resultset_path, "w+") do |f_|
-            f_.puts JSON.pretty_generate(new_resultset)
-          end
+          new_resultset[command_name] = merged_entry(new_resultset[command_name], data)
+
+          ResultsetStore.write(new_resultset)
         end
         true
       end
 
-      # Ensure only one process is reading or writing the resultset at any
-      # given time
-      def synchronize_resultset
-        # make it reentrant
-        return yield if defined?(@resultset_locked) && @resultset_locked
-
-        begin
-          @resultset_locked = true
-          File.open(resultset_writelock, "w+") do |f|
-            f.flock(File::LOCK_EX)
-            yield
-          end
-        ensure
-          @resultset_locked = false
-        end
-      end
+      # If an entry with the same command_name was written AFTER our process
+      # started, a sibling test runner (typically a subprocess our parent
+      # process shelled out to) wrote it. Combine coverage data rather than
+      # 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)
 
-      # We changed the format of the raw result data in simplecov, as people are likely
-      # to have "old" resultsets lying around (but not too old so that they're still
-      # considered we can adapt them).
-      # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
-      def adapt_result(result)
-        if pre_simplecov_0_18_result?(result)
-          adapt_pre_simplecov_0_18_result(result)
-        else
-          result
-        end
+        incoming.merge(
+          "coverage" => Combine.combine(Combine::ResultsCombiner, existing["coverage"], incoming["coverage"])
+        )
       end
 
-      # pre 0.18 coverage data pointed from file directly to an array of line coverage
-      def pre_simplecov_0_18_result?(result)
-        _key, data = result.first
+      def concurrent_runner_entry?(entry)
+        return false unless entry.is_a?(Hash)
 
-        data.is_a?(Array)
+        timestamp = entry["timestamp"]
+        process_start = SimpleCov.process_start_time
+        timestamp && process_start && timestamp.to_i >= process_start.to_i
       end
 
-      def adapt_pre_simplecov_0_18_result(result)
-        result.transform_values do |line_coverage_data|
-          {"lines" => line_coverage_data}
-        end
+      def synchronize_resultset(&)
+        ResultsetStore.synchronize(&)
       end
     end
   end