simplecov 0.22.0 → 1.0.2

data/lib/simplecov.rb

@@ -1,452 +1,244 @@
 # frozen_string_literal: true
 
-require "English"
-
-# Coverage may be inaccurate under JRUBY.
-if defined?(JRUBY_VERSION) && defined?(JRuby) && !org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
-
-  # @see https://github.com/jruby/jruby/issues/1196
-  # @see https://github.com/metricfu/metric_fu/pull/226
-  # @see https://github.com/simplecov-ruby/simplecov/issues/420
-  # @see https://github.com/simplecov-ruby/simplecov/issues/86
-  # @see https://jira.codehaus.org/browse/JRUBY-6106
-
-  warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
-    ' or do JRUBY_OPTS="--debug"' \
-    ' or set the "debug.fullTrace=true" option in your .jrubyrc'
-end
-
 #
 # Code coverage for ruby. Please check out README for a full introduction.
 #
 module SimpleCov
-  class << self
-    attr_accessor :running, :pid
+  # Raised when a user's configuration is internally inconsistent — e.g.
+  # every coverage criterion has been disabled.
+  class ConfigurationError < StandardError; end
+
+  # Maps SimpleCov's criterion names to the keys `Coverage.start` expects.
+  # Lives at module scope (not inside `class << self`) so it can be
+  # declared in the RBS signatures; lexical scoping keeps every existing
+  # reference inside the singleton class working.
+  CRITERION_TO_RUBY_COVERAGE = {
+    branch: :branches,
+    line: :lines,
+    method: :methods,
+    oneshot_line: :oneshot_lines
+  }.freeze
 
-    # Basically, should we take care of at_exit behavior or something else?
-    # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb
+  class << self
+    attr_accessor :pid
+    # When this process started tracking coverage. Captured by SimpleCov.start
+    # so JSONFormatter can detect when an existing coverage.json was written
+    # by a sibling process running concurrently.
+    attr_accessor :process_start_time
+
+    # A monotonically increasing serial the parent assigns to each forked
+    # subprocess (see SimpleCov::ProcessForkHook). The default `at_fork`
+    # builds the worker's command_name from this rather than the OS pid:
+    # the serial sequence is the same from one run to the next, so a re-run
+    # overwrites the previous run's resultset entries instead of writing
+    # uniquely-named ones that pile up until merge_timeout. See issue #1171.
+    def subprocess_serial
+      @subprocess_serial ||= 0
+    end
+
+    # @api private — bump the serial in the parent before a fork so the
+    # child inherits its own ordinal via copy-on-write.
+    def next_subprocess_serial!
+      @subprocess_serial = subprocess_serial + 1
+    end
+
+    # @api private — true in a process that was forked while coverage was
+    # running (set by SimpleCov::ProcessForkHook in the child). Such a child
+    # stores its own slice but must not act as the final-result process: the
+    # process that forked it merges every slice and produces the report. Only
+    # consulted when no parallel-test adapter is active, since adapters answer
+    # `first_worker?` themselves. See issue #1171.
+    def forked_subprocess?
+      !!(defined?(@forked_subprocess) && @forked_subprocess)
+    end
+
+    # @api private — marked in the child immediately after a fork.
+    def mark_forked_subprocess!
+      @forked_subprocess = true
+    end
+    # Should we take care of at_exit behavior or something else? Used by the
+    # minitest plugin. See lib/minitest/simplecov_plugin.rb.
     attr_accessor :external_at_exit
-    alias external_at_exit? external_at_exit
-
-    #
-    # Sets up SimpleCov to run against your project.
-    # You can optionally specify a profile to use as well as configuration with a block:
-    #   SimpleCov.start
-    #    OR
-    #   SimpleCov.start 'rails' # using rails profile
-    #    OR
-    #   SimpleCov.start do
-    #     add_filter 'test'
-    #   end
-    #     OR
-    #   SimpleCov.start 'rails' do
-    #     add_filter 'test'
-    #   end
-    #
-    # Please check out the RDoc for SimpleCov::Configuration to find about available config options
-    #
-    def start(profile = nil, &block)
-      require "coverage"
-      initial_setup(profile, &block)
-      require_relative "./simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
-                                                ::Process.respond_to?(:fork)
-
-      make_parallel_tests_available
-
-      @result = nil
-      self.pid = Process.pid
-
-      start_coverage_measurement
-    end
-
-    #
-    # Collate a series of SimpleCov result files into a single SimpleCov output.
-    #
-    # You can optionally specify configuration with a block:
-    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
-    #    OR
-    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' # using rails profile
-    #    OR
-    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] do
-    #     add_filter 'test'
-    #   end
-    #    OR
-    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do
-    #     add_filter 'test'
-    #   end
-    #
-    # Please check out the RDoc for SimpleCov::Configuration to find about
-    # available config options, or checkout the README for more in-depth
-    # information about coverage collation
-    #
-    # By default `collate` ignores the merge_timeout so all results of all files specified will be
-    # merged together. If you want to honor the merge_timeout then provide the keyword argument
-    # `ignore_timeout: false`.
-    #
-    def collate(result_filenames, profile = nil, ignore_timeout: true, &block)
-      raise "There are no reports to be merged" if result_filenames.empty?
-
-      initial_setup(profile, &block)
-
-      # Use the ResultMerger to produce a single, merged result, ready to use.
-      @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
-
-      run_exit_tasks!
-    end
-
-    #
-    # Returns the result for the current coverage run, merging it across test suites
-    # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
-    #
-    def result
-      return @result if result?
-
-      # Collect our coverage result
-      process_coverage_result if running
-
-      # If we're using merging of results, store the current result
-      # first (if there is one), then merge the results and return those
-      if use_merging
-        wait_for_other_processes
-        SimpleCov::ResultMerger.store_result(@result) if result?
-        @result = SimpleCov::ResultMerger.merged_result
-      end
-
-      @result
-    ensure
-      self.running = false
-    end
-
-    #
-    # Returns nil if the result has not been computed
-    # Otherwise, returns the result
-    #
-    def result?
-      defined?(@result) && @result
-    end
 
-    #
-    # Applies the configured filters to the given array of SimpleCov::SourceFile items
-    #
-    def filtered(files)
-      result = files.clone
-      filters.each do |filter|
-        result = result.reject { |source_file| filter.matches?(source_file) }
-      end
-      SimpleCov::FileList.new result
+    # `:oneshot_line` data is folded into the `:line` bucket of
+    # `coverage_statistics` by `ResultAdapter`, so use `:line` to look
+    # up stats for either criterion.
+    def coverage_statistics_key(criterion)
+      criterion == :oneshot_line ? :line : criterion
     end
 
-    #
-    # Applies the configured groups to the given array of SimpleCov::SourceFile items
-    #
-    def grouped(files)
-      grouped = {}
-      grouped_files = []
-      groups.each do |name, filter|
-        grouped[name] = SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
-        grouped_files += grouped[name]
-      end
-      if !groups.empty? && !(other_files = files.reject { |source_file| grouped_files.include?(source_file) }).empty?
-        grouped["Ungrouped"] = SimpleCov::FileList.new(other_files)
-      end
-      grouped
+    # Coerce to a proper boolean so rspec-mocks 4's predicate matcher
+    # (`expect(...).not_to be_external_at_exit`) accepts the result.
+    def external_at_exit?
+      !!@external_at_exit
     end
 
     #
-    # Applies the profile of given name on SimpleCov configuration
-    #
-    def load_profile(name)
-      profiles.load(name)
-    end
-
-    def load_adapter(name)
-      warn "#{Kernel.caller.first}: [DEPRECATION] #load_adapter is deprecated. Use #load_profile instead."
-      load_profile(name)
-    end
-
+    # Sets up SimpleCov to run against your project. See README for
+    # the full DSL, or:
     #
-    # Clear out the previously cached .result. Primarily useful in testing
+    #     SimpleCov.start
+    #     SimpleCov.start 'rails'                # using a profile
+    #     SimpleCov.start { add_filter 'test' }  # with a config block
     #
-    def clear_result
-      @result = nil
-    end
+    def start(profile = nil, &)
+      warn_about_start_in_dot_simplecov if @autoloading_dot_simplecov
 
-    def at_exit_behavior
-      # If we are in a different process than called start, don't interfere.
-      return if SimpleCov.pid != Process.pid
-
-      # If SimpleCov is no longer running then don't run exit tasks
-      SimpleCov.run_exit_tasks! if SimpleCov.running
+      initial_setup(profile, &)
+      start_tracking
+      install_at_exit_hook
     end
 
     # @api private
     #
-    # Called from at_exit block
-    #
-    def run_exit_tasks!
-      error_exit_status = exit_status_from_exception
-
-      at_exit.call
-
-      exit_and_report_previous_error(error_exit_status) if previous_error?(error_exit_status)
-      process_results_and_report_error if ready_to_process_results?
+    # Mark the duration of a `.simplecov` auto-load so any `SimpleCov.start`
+    # call inside the file can warn about the impending migration to a
+    # config-only file. Tracking still begins for backward compatibility;
+    # the warning is the cue to move `SimpleCov.start` into a test helper.
+    # See #581.
+    def with_dot_simplecov_autoload
+      # Read in the ensure clause, where flow analysis cannot see the
+      # assignment above; anchor the type here.
+      previous = @autoloading_dot_simplecov # : bool?
+      @autoloading_dot_simplecov = true
+      yield
+    ensure
+      # @type var previous: bool?
+      @autoloading_dot_simplecov = previous
     end
 
-    #
-    # @api private
-    #
-    # Returns the exit status from the exit exception
-    #
-    def exit_status_from_exception
-      # Capture the current exception if it exists
-      @exit_exception = $ERROR_INFO
-      return nil unless @exit_exception
-
-      if @exit_exception.is_a?(SystemExit)
-        @exit_exception.status
-      else
-        SimpleCov::ExitCodes::EXCEPTION
-      end
-    end
+    def warn_about_start_in_dot_simplecov
+      return if @dot_simplecov_start_warned
 
-    # @api private
-    def previous_error?(error_exit_status)
-      # Normally it'd be enough to check for previous error but when running test_unit
-      # status is 0
-      error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS
+      @dot_simplecov_start_warned = true
+      warn "[DEPRECATION] Calling `SimpleCov.start` from `.simplecov` is deprecated and will " \
+           "be removed in a future release. `.simplecov` should contain configuration only; " \
+           "move the `SimpleCov.start` call into your `spec_helper.rb` / `test_helper.rb`. " \
+           "Coverage tracking still begins for backward compatibility, but a future release " \
+           "will require the explicit `SimpleCov.start` from a test helper. " \
+           "See https://github.com/simplecov-ruby/simplecov/issues/581."
     end
 
     #
-    # @api private
+    # Install the at_exit hook that formats results and runs exit-code
+    # checks. `SimpleCov.start` calls this automatically. Idempotent —
+    # safe to call multiple times. Callers that drive the formatting
+    # pipeline themselves (e.g., dogfood test setups) can skip it by
+    # using `start_tracking` directly instead of `start`.
     #
-    # Thinking: Move this behavior earlier so if there was an error we do nothing?
-    def exit_and_report_previous_error(exit_status)
-      warn("Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected") if print_error_status
-      Kernel.exit(exit_status)
-    end
+    def install_at_exit_hook
+      return if @at_exit_hook_installed
 
-    # @api private
-    def ready_to_process_results?
-      final_result_process? && result?
-    end
+      @at_exit_hook_installed = true
+      # Never defer in a forked child: Minitest pins its after_run at_exit
+      # to the pid that armed autorun, so the deferral target can't fire
+      # there and the child's resultset would be silently dropped. See
+      # issue #1227.
+      defer_to_minitest_after_run if minitest_autorun_pending? && !forked_subprocess?
+      Kernel.at_exit do
+        next if SimpleCov.external_at_exit?
 
-    def process_results_and_report_error
-      exit_status = process_result(result)
-
-      # Force exit with stored status (see github issue #5)
-      if exit_status.positive?
-        warn("SimpleCov failed with exit #{exit_status} due to a coverage related error") if print_error_status
-        Kernel.exit exit_status
+        SimpleCov.at_exit_behavior
       end
     end
 
-    # @api private
-    #
-    # Usage:
-    #   exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
-    #
-    def process_result(result)
-      result_exit_status = result_exit_status(result)
-      write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
-      result_exit_status
-    end
-
-    # @api private
-    CoverageLimits = Struct.new(:minimum_coverage, :minimum_coverage_by_file, :maximum_coverage_drop, keyword_init: true)
-    def result_exit_status(result)
-      coverage_limits = CoverageLimits.new(
-        minimum_coverage: minimum_coverage, minimum_coverage_by_file: minimum_coverage_by_file,
-        maximum_coverage_drop: maximum_coverage_drop
-      )
-
-      ExitCodes::ExitCodeHandling.call(result, coverage_limits: coverage_limits)
-    end
-
-    #
-    # @api private
-    #
-    def final_result_process?
-      # checking for ENV["TEST_ENV_NUMBER"] to determine if the tests are being run in parallel
-      !defined?(ParallelTests) || !ENV["TEST_ENV_NUMBER"] || ParallelTests.last_process?
-    end
-
     #
-    # @api private
+    # Begin coverage tracking without applying configuration. Pairs with
+    # `SimpleCov.configure { ... }` for callers that want to separate
+    # the two — for example a dogfood test that has already started
+    # `Coverage` itself before requiring simplecov, but still wants the
+    # process_start_time / pid / fork-hook bookkeeping.
     #
-    def wait_for_other_processes
-      return unless defined?(ParallelTests) && final_result_process?
-
-      ParallelTests.wait_for_other_processes_to_finish
-    end
+    def start_tracking
+      require "coverage"
+      warn_if_jruby_full_trace_disabled
+      validate_coverage_criteria!
+      # simplecov:disable — fork-hook is enabled via SimpleCov.enable_for_subprocesses, off by default
+      require_relative "simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
+                                              ::Process.respond_to?(:_fork)
+      # simplecov:enable
+
+      # Trigger adapter selection now so the (possibly lazy) parallel_tests
+      # gem load happens at start_tracking time rather than mid-suite.
+      # `current` is memoized; subsequent calls are cheap.
+      SimpleCov::ParallelAdapters.current
 
-    #
-    # @api private
-    #
-    def write_last_run(result)
-      SimpleCov::LastRun.write(result:
-        result.coverage_statistics.transform_values do |stats|
-          round_coverage(stats.percent)
-        end)
-    end
+      @result = nil
+      self.pid = Process.pid
+      self.process_start_time = Time.now
 
-    #
-    # @api private
-    #
-    # Rounding down to be extra strict, see #679
-    def round_coverage(coverage)
-      coverage.floor(2)
+      start_coverage_measurement
     end
 
   private
 
-    def initial_setup(profile, &block)
-      load_profile(profile) if profile
-      configure(&block) if block_given?
-      self.running = true
-    end
-
     #
-    # Trigger Coverage.start depends on given config coverage_criterion
-    #
-    # With Positive branch it supports all coverage measurement types
-    # With Negative branch it supports only line coverage measurement type
+    # Trigger Coverage.start with the configured criteria. Every supported
+    # runtime (CRuby >= 3.2, JRuby >= 10, TruffleRuby >= 22) accepts the
+    # criteria-hash form, so no compatibility fallback is needed.
     #
     def start_coverage_measurement
-      # This blog post gives a good run down of the coverage criterias introduced
-      # in Ruby 2.5: https://blog.bigbinary.com/2018/04/11/ruby-2-5-supports-measuring-branch-and-method-coverages.html
-      # There is also a nice writeup of the different coverage criteria made in this
-      # comment  https://github.com/simplecov-ruby/simplecov/pull/692#discussion_r281836176 :
-      # Ruby < 2.5:
-      # https://github.com/ruby/ruby/blob/v1_9_3_374/ext/coverage/coverage.c
-      # traditional mode (Array)
-      #
-      # Ruby 2.5:
-      # https://bugs.ruby-lang.org/issues/13901
-      # https://github.com/ruby/ruby/blob/v2_5_3/ext/coverage/coverage.c
-      # default: traditional/compatible mode (Array)
-      # :lines - like traditional mode but using Hash
-      # :branches
-      # :methods
-      # :all - same as lines + branches + methods
-      #
-      # Ruby >= 2.6:
-      # https://bugs.ruby-lang.org/issues/15022
-      # https://github.com/ruby/ruby/blob/v2_6_3/ext/coverage/coverage.c
-      # default: traditional/compatible mode (Array)
-      # :lines - like traditional mode but using Hash
-      # :branches
-      # :methods
-      # :oneshot_lines - can not be combined with lines
-      # :all - same as lines + branches + methods
-      #
-      if coverage_start_arguments_supported?
-        start_coverage_with_criteria
-      else
-        Coverage.start unless Coverage.running?
+      start_arguments = coverage_criteria.to_h do |criterion|
+        [CRITERION_TO_RUBY_COVERAGE.fetch(criterion), true]
       end
-    end
-
-    def start_coverage_with_criteria
-      start_arguments = coverage_criteria.map do |criterion|
-        [lookup_corresponding_ruby_coverage_name(criterion), true]
-      end.to_h
 
       start_arguments[:eval] = true if coverage_for_eval_enabled?
 
-      Coverage.start(start_arguments) unless Coverage.running?
-    end
-
-    CRITERION_TO_RUBY_COVERAGE = {
-      branch: :branches,
-      line: :lines
-    }.freeze
-    def lookup_corresponding_ruby_coverage_name(criterion)
-      CRITERION_TO_RUBY_COVERAGE.fetch(criterion)
+      Coverage.start(**start_arguments) unless Coverage.running?
     end
 
-    #
-    # Finds files that were to be tracked but were not loaded and initializes
-    # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).
-    #
-    def add_not_loaded_files(result)
-      if tracked_files
-        result = result.dup
-        Dir[tracked_files].each do |file|
-          absolute_path = File.expand_path(file)
-          result[absolute_path] ||= SimulateCoverage.call(absolute_path)
-        end
-      end
+    # `Rake::TestTask` runs `ruby -e 'require "minitest/autorun"; ...'`,
+    # which means Minitest's at_exit registers before SimpleCov's. Since
+    # at_exit fires LIFO, SimpleCov's hook would otherwise run *before*
+    # Minitest gets a chance to invoke the tests — and format an empty
+    # resultset. When we can see that Minitest is loaded and its autorun
+    # is armed, route the report through `Minitest.after_run` instead,
+    # which fires after the suite completes. See issues #1099 and #1112.
+    def minitest_autorun_pending?
+      return false unless defined?(Minitest) && Minitest.respond_to?(:after_run)
+      return false unless Minitest.class_variable_defined?(:@@installed_at_exit)
 
-      result
+      Minitest.class_variable_get(:@@installed_at_exit)
     end
 
-    #
-    # Call steps that handle process coverage result
-    #
-    # @return [Hash]
-    #
-    def process_coverage_result
-      adapt_coverage_result
-      remove_useless_results
-      result_with_not_loaded_files
+    def defer_to_minitest_after_run
+      self.external_at_exit = true
+      Minitest.after_run { SimpleCov.at_exit_behavior }
     end
 
-    #
-    # Unite the result so it wouldn't matter what coverage type was called
-    #
-    # @return [Hash]
-    #
-    def adapt_coverage_result
-      @result = SimpleCov::ResultAdapter.call(Coverage.result)
-    end
-
-    #
-    # Filter coverage result
-    # The result before filter also has result of coverage for files
-    # are not related to the project like loaded gems coverage.
-    #
-    # @return [Hash]
-    #
-    def remove_useless_results
-      @result = SimpleCov::UselessResultsRemover.call(@result)
-    end
+    # JRuby coverage data is unreliable unless full-trace mode is enabled.
+    # @see https://github.com/jruby/jruby/issues/1196
+    # @see https://github.com/simplecov-ruby/simplecov/issues/420
+    # @see https://github.com/simplecov-ruby/simplecov/issues/86
+    def warn_if_jruby_full_trace_disabled
+      return unless defined?(JRUBY_VERSION) && defined?(JRuby) # simplecov:disable — JRuby-only branch
 
-    #
-    # Initialize result with files that are not included by coverage
-    # and added inside the config block
-    #
-    # @return [Hash]
-    #
-    def result_with_not_loaded_files
-      @result = SimpleCov::Result.new(add_not_loaded_files(@result))
-    end
-
-    # parallel_tests isn't always available, see: https://github.com/grosser/parallel_tests/issues/772
-    def make_parallel_tests_available
-      return if defined?(ParallelTests)
-      return unless probably_running_parallel_tests?
-
-      require "parallel_tests"
-    rescue LoadError
-      warn("SimpleCov guessed you were running inside parallel tests but couldn't load it. Please file a bug report with us!")
-    end
+      # simplecov:disable — JRuby-only branches; unreachable from CRuby
+      # `org` is JRuby's Java-package entry point; it does not exist on
+      # CRuby, so no RBS declaration can be truthful here.
+      return if org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED # steep:ignore NoMethod
 
-    def probably_running_parallel_tests?
-      ENV["TEST_ENV_NUMBER"] && ENV["PARALLEL_TEST_GROUPS"]
+      warn 'Coverage may be inaccurate; set the "--debug" command line option, ' \
+           'or do JRUBY_OPTS="--debug" ' \
+           'or set the "debug.fullTrace=true" option in your .jrubyrc'
+      # simplecov:enable
     end
   end
 end
 
-# requires are down here here for a load order reason I'm not sure what it is about
-require "set"
+# requires are down here for a load order reason I'm not sure what it is about
 require "forwardable"
+require_relative "simplecov/color"
+require_relative "simplecov/deprecation"
 require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
 require_relative "simplecov/coverage_statistics"
+require_relative "simplecov/coverage_violations"
 require_relative "simplecov/exit_codes"
 require_relative "simplecov/profiles"
 require_relative "simplecov/source_file/line"
 require_relative "simplecov/source_file/branch"
+require_relative "simplecov/source_file/method"
 require_relative "simplecov/source_file"
 require_relative "simplecov/file_list"
 require_relative "simplecov/result"
@@ -455,16 +247,22 @@ require_relative "simplecov/formatter"
 require_relative "simplecov/last_run"
 require_relative "simplecov/lines_classifier"
 require_relative "simplecov/result_merger"
+require_relative "simplecov/parallel_adapters"
 require_relative "simplecov/command_guesser"
 require_relative "simplecov/version"
 require_relative "simplecov/result_adapter"
 require_relative "simplecov/combine"
 require_relative "simplecov/combine/branches_combiner"
+require_relative "simplecov/combine/methods_combiner"
 require_relative "simplecov/combine/files_combiner"
 require_relative "simplecov/combine/lines_combiner"
 require_relative "simplecov/combine/results_combiner"
 require_relative "simplecov/useless_results_remover"
 require_relative "simplecov/simulate_coverage"
+require_relative "simplecov/result_processing"
+require_relative "simplecov/exit_handling"
+require_relative "simplecov/parallel_coordination"
 
 # Load default config
+# simplecov:disable — env-var only set by aruba feature tests
 require_relative "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]

data/lib/simplecov_json_formatter.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Backward-compatibility shim: simplecov_json_formatter is now part of simplecov.
+require_relative "simplecov/formatter/json_formatter"