simplecov 0.22.0 → 1.3.0

data/lib/simplecov/profiles/strict.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Every coverage criterion enabled and held to 100%. An opt-in profile rather
+# than the default (#1061), so a team that has paid down the debt can flip the
+# strict switch without re-typing the threshold trio every time.
+#
+# JRuby gracefully degrades: `enable_coverage :branch` / `:method` are accepted
+# but the runtime cannot measure them, and `CoverageViolations` skips threshold
+# lookups for criteria not in the stats, so only `:line` is enforced there.
+#
+# `:eval` is guarded on `coverage_for_eval_supported?` so the profile stays
+# quiet on engines without it, where enabling it would warn every time it loads.
+
+SimpleCov.profiles.define "strict" do
+  enable_coverage :branch
+  enable_coverage :method
+  # simplecov:disable branch — dogfood branch coverage runs on CRuby only,
+  # so the else arm (eval coverage not supported) is unreachable from CI.
+  enable_coverage :eval if coverage_for_eval_supported?
+  # simplecov:enable
+  minimum_coverage line: 100, branch: 100, method: 100
+end

data/lib/simplecov/profiles/test_frameworks.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "test_frameworks" do
-  add_filter "/test/"
-  add_filter "/features/"
-  add_filter "/spec/"
-  add_filter "/autotest/"
+  skip %r{\A(test|features|spec|autotest)/}
 end

data/lib/simplecov/profiles.rb

@@ -1,35 +1,42 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  #
-  # Profiles are SimpleCov configuration procs that can be easily
-  # loaded using SimpleCov.start :rails and defined using
-  #   SimpleCov.profiles.define :foo do
-  #     # SimpleCov configuration here, same as in  SimpleCov.configure
-  #   end
-  #
+  # Configuration procs loaded with `SimpleCov.start :rails` and defined with
+  # `SimpleCov.profiles.define`.
   class Profiles < Hash
-    #
-    # Define a SimpleCov profile:
-    #   SimpleCov.profiles.define 'rails' do
-    #     # Same as SimpleCov.configure do .. here
-    #   end
-    #
     def define(name, &blk)
       name = name.to_sym
-      raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+      raise ConfigurationError, "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
 
       self[name] = blk
     end
 
-    #
-    # Applies the profile of given name on SimpleCov.configure
-    #
     def load(name)
+      SimpleCov.configure(&fetch_proc(name))
+    end
+
+    # Lookup order: already registered via #define, then
+    # `require "simplecov/profiles/<name>"` for the bundled profiles, then
+    # `require "simplecov-profile-<name>"` for third-party plugin gems.
+    def fetch_proc(name)
       name = name.to_sym
-      raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+      autoload_profile(name) unless key?(name)
+      return fetch(name) if key?(name)
+
+      raise ConfigurationError, "Could not find SimpleCov Profile called '#{name}'"
+    end
+
+    private
 
-      SimpleCov.configure(&self[name])
+    def autoload_profile(name)
+      require "simplecov/profiles/#{name}"
+    rescue LoadError
+      begin
+        require "simplecov-profile-#{name}"
+      rescue LoadError
+        # Neither a bundled profile nor a plugin gem; `fetch_proc` raises the
+        # user-facing error.
+      end
     end
   end
 end

data/lib/simplecov/report_deferral.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# The clobber-prevention backstop: an empty process stands down instead of
+# formatting over a fresher report a sibling produced. Typically fires when
+# `SimpleCov.start` ran in a parent process that shelled out to the test runner
+# (#581).
+
+module SimpleCov
+  class << self
+    def defer_to_existing_report?
+      return false unless existing_report_newer_than_us?
+
+      res = result
+      empty = res.nil? || res.files.empty?
+      warn_about_deferred_report if empty
+      empty
+    end
+
+    # `.last_run.json` only exists after fully successful runs, so alone it left
+    # the backstop inert when the child run failed, the case where clobbering its
+    # report hurts most. The report stamp is touched by every formatting process
+    # regardless of exit status. The rescue covers a file vanishing mid-at_exit.
+    def existing_report_newer_than_us?
+      return false unless process_start_time
+
+      [LastRun.last_run_path, ReportStamp.path].any? do |path|
+        File.mtime(path) > process_start_time
+      rescue SystemCallError
+        false
+      end
+    end
+
+    def warn_about_deferred_report
+      return unless print_errors
+
+      ExitCodes.print_error Color.colorize(
+        "Skipping SimpleCov report — this process tracked no application code and a newer " \
+        "report already exists at #{coverage_path}. This usually means SimpleCov.start ran in a " \
+        "parent process (e.g. a Rakefile or Rails' Bundler.require) that shelled out to the test " \
+        "runner. See https://github.com/simplecov-ruby/simplecov/issues/581.",
+        :yellow
+      )
+    end
+  end
+end

data/lib/simplecov/report_stamp.rb

@@ -0,0 +1,25 @@
+# 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 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.
+  module ReportStamp
+    class << self
+      def path
+        File.join(SimpleCov.coverage_path, ".report_stamp")
+      end
+
+      # A read-only or vanished coverage dir must not crash reporting; the stamp
+      # only powers the deferral heuristic.
+      def touch
+        FileUtils.touch(path)
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/simplecov/result/filter_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    # 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 the project's filters or groups.
+    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
+  end
+end

data/lib/simplecov/result/missing_source_files_reporter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    # When a resultset references source files that don't exist on the local
+    # filesystem they're silently dropped, which produces an empty
+    # `0 / 0 (100.00%)` report that looks like success but isn't. This emits a
+    # single warning summarizing the drop and, when every entry was lost, points
+    # at the typical cause: `SimpleCov.collate` invoked from a machine or path
+    # different from where the resultsets were generated (#980).
+    class MissingSourceFilesReporter
+      def initialize(missing_paths, every_entry_dropped:)
+        @missing_paths = missing_paths
+        @every_entry_dropped = every_entry_dropped
+      end
+
+      def warn!
+        warn Color.colorize(message, :yellow)
+      end
+
+      def message
+        @every_entry_dropped ? all_missing_warning : partial_missing_warning
+      end
+
+      private
+
+      def all_missing_warning
+        "SimpleCov dropped all #{@missing_paths.size} source file(s) from the result — " \
+          "none of the paths in the resultset exist on this filesystem: " \
+          "#{summary}. If you're running `SimpleCov.collate`, the source " \
+          "files must be available at the same absolute paths as when the individual resultsets " \
+          "were generated."
+      end
+
+      def partial_missing_warning
+        "SimpleCov dropped #{@missing_paths.size} source file(s) from the result because " \
+          "they don't exist on this filesystem: #{summary}. They were " \
+          "tracked in the resultset but have since moved or been removed."
+      end
+
+      def summary
+        sample = @missing_paths.first(5).join(", ")
+        remaining = @missing_paths.size - 5
+        remaining.positive? ? "#{sample} (+#{remaining} more)" : sample
+      end
+    end
+  end
+end

data/lib/simplecov/result/serialization.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    module Serialization
+      def to_hash
+        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
+        data["tracked_files"] = tracked_files unless tracked_files.empty?
+        append_contexts(data)
+        {command_name => data}
+      end
+
+      private
+
+      # Serialized whenever a map was recorded, even an empty one: for the merge,
+      # the key's presence is the signal that this result tracked tests, which is
+      # what lets it tell "tracked and covered nothing" from "never tracked". The
+      # map's files are restricted to this result's post-filter universe.
+      def append_contexts(data)
+        map = contexts
+        return unless map
+
+        data["contexts"] = map.to_h(only: context_filenames)
+      end
+
+      def context_filenames
+        Set.new(filenames)
+      end
+
+      # A live result's criterion keys are Symbols while entries parsed back from
+      # `.resultset.json` carry Strings, and the combiners read only String keys.
+      # Serializing with String keys is what lets a live result merged against a
+      # stored entry contribute its counts instead of being dropped.
+      def coverage
+        original_result.slice(*filenames).transform_values do |file_coverage|
+          file_coverage.transform_keys(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/result/source_file_builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    class SourceFileBuilder
+      attr_reader :missing_source_files
+
+      def initialize(original_result, not_loaded_files:)
+        @original_result = original_result
+        @not_loaded_files = not_loaded_files
+        @missing_source_files = []
+      end
+
+      def call
+        FileList.new(
+          @original_result
+            .filter_map { |filename, coverage| build_source_file(filename, coverage) }
+            .sort_by(&:filename)
+        )
+      end
+
+      private
+
+      def build_source_file(filename, coverage)
+        unless File.file?(filename)
+          @missing_source_files << filename
+          return
+        end
+
+        SourceFile.new(
+          filename,
+          stringify_outer_keys(coverage),
+          loaded: !@not_loaded_files.include?(filename)
+        )
+      end
+
+      # `Coverage.result` returns symbol keys; resultsets loaded from disk are
+      # already string-keyed. SourceFile reads with strings and handles both Array
+      # and stringified-Array branch/method keys itself, so only the outer hash
+      # needs normalizing.
+      def stringify_outer_keys(coverage)
+        coverage.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/simplecov/result.rb

@@ -2,93 +2,169 @@
 
 require "digest/sha1"
 require "forwardable"
+require_relative "result/filter_config"
+require_relative "result/missing_source_files_reporter"
+require_relative "result/serialization"
+require_relative "result/source_file_builder"
 
 module SimpleCov
   #
-  # A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage
-  # library generates (Coverage.result).
+  # A code coverage result, initialized from the Hash Ruby's built-in coverage
+  # library generates.
   #
   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
-    attr_reader :files
-    alias source_files files
-    # Explicitly set the Time this result has been created
-    attr_writer :created_at
-    # 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
+    include Serialization
+
+    attr_reader :original_result, :files
+    # 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 config (#1250).
+    attr_reader :tracked_files
+    # Used only for parallel-result coordination. They do not change which
+    # fresh suites are merged.
+    attr_reader :run_id, :worker_id
+    alias_method :source_files, :files
+    # The `ContextMap` recorded under `track_tests`, or nil when this result
+    # carries none: tracking was off, or a merge dropped the map because not
+    # every merged result recorded one.
+    attr_reader :contexts
+
+    # The distinct run names behind this result, set by a merge so presentation
+    # can say "A and N other runs" instead of reading the joined
+    # `command_name` aloud in full. Splitting that string back apart would
+    # misread a run name that itself contains a comma.
+    attr_writer :created_at, :command_name, :command_names
+
+    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
 
-    # 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
+    # `filter_config` defaults to the SimpleCov singleton's filter / group
+    # configuration. Pass a custom FilterConfig to opt out, which is useful for
+    # tests that build synthetic Results.
+    #
+    # `tracked_files` accepts any collection that answers `to_a` (the merge
+    # passes a Set), and nil for a run that tracked nothing.
+    def initialize(original_result, command_name: nil, created_at: nil, not_loaded_files: Set.new,
+      tracked_files: nil, run_id: nil, worker_id: nil, contexts: nil, 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!
+      initialize_resultset_metadata(tracked_files, run_id, worker_id, contexts)
+      @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) 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
     def filenames
       files.map(&:filename)
     end
 
-    # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
+    # 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.eql?(target) }
+    end
+
+    # Path resolution as in `source_file_for`.
+    def coverage_for(path)
+      source_file_for(path)&.coverage_statistics
+    end
+
     def groups
-      @groups ||= SimpleCov.grouped(files)
+      @groups ||= SimpleCov.grouped(files, groups: @groups_config)
+    end
+
+    # True for a group the configuration defines, whether or not any file
+    # matched it; `groups` omits the ones that matched nothing.
+    def configured_group?(group_name)
+      @groups_config.key?(group_name)
     end
 
-    # 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 (#964).
     def format!
-      SimpleCov.formatter.new.format(self)
+      formatter = SimpleCov.formatter
+      return nil if formatter.nil?
+
+      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.
+      ReportStamp.touch
+      formatted
     end
 
-    # Defines when this result has been created. Defaults to Time.now
     def created_at
       @created_at ||= Time.now
     end
 
-    # The command name that launched this result.
-    # Delegated to SimpleCov.command_name if not set manually
     def command_name
       @command_name ||= SimpleCov.command_name
     end
 
-    # 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
-        }
-      }
+    def command_names
+      @command_names ||= [command_name]
     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.fetch("timestamp")),
+          tracked_files: data["tracked_files"], run_id: data["run_id"],
+          worker_id: data["worker_id"], contexts: ContextMap.from_hash(data["contexts"]))
       end
     end
 
-  private
+    private
+
+    def initialize_resultset_metadata(tracked_files, run_id, worker_id, contexts)
+      @tracked_files = tracked_files.to_a
+      @run_id = run_id
+      @worker_id = worker_id
+      @contexts = contexts
+    end
+
+    def warn_about_missing_source_files(missing)
+      return if missing.empty?
+
+      # Emit only from the process that writes the final report: the merged
+      # result is rebuilt in every parallel worker, so without this gate the
+      # warning prints once per worker. Intentionally not gated on
+      # print_errors, because the default at_fork sets print_errors false on
+      # workers and in many parallel runners the final-report process is itself
+      # a worker (#980, #1171).
+      return unless SimpleCov.final_result_process?
 
-    def coverage
-      keys = original_result.keys & filenames
-      Hash[keys.zip(original_result.values_at(*keys))]
+      # Every built file survives (only the missing ones are dropped), so an
+      # empty file list is exactly the "nothing was found" case.
+      MissingSourceFilesReporter.new(missing, every_entry_dropped: @files.empty?).warn!
     end
 
-    # Applies all configured SimpleCov filters on this result's source files
-    def filter!
-      @files = SimpleCov.filtered(files)
+    def apply_filters!(filters)
+      filters.each do |filter|
+        @files = FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
+      end
+    end
+
+    # 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 = FileList.new(
+        @files.select { |source_file| cover_filters.any? { |filter| filter.matches?(source_file) } }
+      )
     end
   end
 end