simplecov 1.1.1 → 1.3.0

data/lib/simplecov/exit_codes/exit_code_handling.rb

@@ -2,10 +2,8 @@
 
 module SimpleCov
   module ExitCodes
-    # Runs every coverage check against the result and returns the exit
-    # code from the first failing one (or SUCCESS if all pass).
     module ExitCodeHandling
-    module_function
+      extend self
 
       def call(result, coverage_limits:)
         checks = coverage_checks(result, coverage_limits)
@@ -15,21 +13,36 @@ module SimpleCov
           failing_check.report if SimpleCov.print_errors
           failing_check.exit_code
         else
-          SimpleCov::ExitCodes::SUCCESS
+          SUCCESS
         end
       end
 
       def coverage_checks(result, coverage_limits)
         [
           MinimumOverallCoverageCheck.new(result, coverage_limits.minimum_coverage),
-          MinimumCoverageByFileCheck.new(
-            result, coverage_limits.minimum_coverage_by_file, coverage_limits.minimum_coverage_by_file_overrides
-          ),
+          minimum_by_file_check(result, coverage_limits),
+          BaselineCheck.new(result, coverage_limits.baseline),
           MinimumCoverageByGroupCheck.new(result, coverage_limits.minimum_coverage_by_group),
           MaximumOverallCoverageCheck.new(result, coverage_limits.maximum_coverage),
-          MaximumCoverageDropCheck.new(result, coverage_limits.maximum_coverage_drop)
+          MaximumCoverageDropCheck.new(result, coverage_limits.maximum_coverage_drop),
+          MaximumMissedCheck.new(result, coverage_limits.maximum_missed),
+          maximum_missed_per_file_check(result, coverage_limits)
         ]
       end
+
+      def minimum_by_file_check(result, coverage_limits)
+        MinimumCoverageByFileCheck.new(
+          result, coverage_limits.minimum_coverage_by_file, coverage_limits.minimum_coverage_by_file_overrides,
+          baseline: coverage_limits.baseline
+        )
+      end
+
+      def maximum_missed_per_file_check(result, coverage_limits)
+        MaximumMissedPerFileCheck.new(
+          result, coverage_limits.maximum_missed_per_file, coverage_limits.maximum_missed_per_file_overrides,
+          baseline: coverage_limits.baseline
+        )
+      end
     end
   end
 end

data/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -2,24 +2,21 @@
 
 module SimpleCov
   module ExitCodes
-    # Fails when any coverage criterion has dropped by more than the
-    # configured maximum since the last recorded run.
     class MaximumCoverageDropCheck < Check
       def exit_code
-        SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
+        MAXIMUM_COVERAGE_DROP
       end
 
-    private
+      private
 
       def compute_violations
-        SimpleCov::CoverageViolations.maximum_drop(result, thresholds)
+        CoverageViolations.maximum_drop(result, thresholds)
       end
 
-      # The "drop percent" is a delta, not a coverage level — it has no
-      # natural green/yellow/red mapping, so the whole line goes red to
-      # keep the failure visible at a glance.
-      def report_violation(violation)
-        ExitCodes.print_error SimpleCov::Color.colorize(message_for(violation), :red)
+      # The drop percent is a delta, not a coverage level, so it has no natural
+      # green/yellow/red mapping and the whole line goes red.
+      def violation_lines(violation)
+        [Color.colorize(message_for(violation), :red)]
       end
 
       def message_for(violation)

data/lib/simplecov/exit_codes/maximum_missed_check.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MaximumMissedCheck < Check
+      def exit_code
+        MINIMUM_COVERAGE
+      end
+
+      private
+
+      def compute_violations
+        CoverageViolations.maximum_missed(result, thresholds)
+      end
+
+      def violation_lines(violation)
+        [format(
+          "Missed %<units>s (%<actual>d) exceed the configured maximum_missed (%<maximum>d).",
+          units: UNITS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion))),
+          actual: violation.fetch(:actual),
+          maximum: violation.fetch(:maximum)
+        )]
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/maximum_missed_per_file_check.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MaximumMissedPerFileCheck < Check
+      def initialize(result, maximum_missed_per_file, overrides = {}, baseline: nil)
+        super(result, maximum_missed_per_file)
+        @overrides = overrides
+        @baseline = baseline
+      end
+
+      def exit_code
+        MINIMUM_COVERAGE
+      end
+
+      private
+
+      def compute_violations
+        CoverageViolations.maximum_missed_by_file(result, thresholds, @overrides, baseline: @baseline)
+      end
+
+      def violation_lines(violation)
+        [format(
+          "Missed %<units>s (%<actual>d) exceed the configured maximum_missed_per_file (%<maximum>d) " \
+          "in %<filename>s.",
+          units: UNITS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion))),
+          actual: violation.fetch(:actual),
+          maximum: violation.fetch(:maximum),
+          filename: violation.fetch(:project_filename)
+        )]
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/maximum_overall_coverage_check.rb

@@ -2,30 +2,25 @@
 
 module SimpleCov
   module ExitCodes
-    # Fails when the overall (project-wide) coverage for any criterion is
-    # above the configured maximum. Pair with
-    # `SimpleCov::ExitCodes::MinimumOverallCoverageCheck` (or use
-    # `SimpleCov.expected_coverage`) to pin coverage to an exact value
-    # and surface unexpected increases instead of silently absorbing them.
     class MaximumOverallCoverageCheck < Check
       def exit_code
-        SimpleCov::ExitCodes::MAXIMUM_COVERAGE
+        MAXIMUM_COVERAGE
       end
 
-    private
+      private
 
       def compute_violations
-        SimpleCov::CoverageViolations.maximum_overall(result, thresholds)
+        CoverageViolations.maximum_overall(result, thresholds)
       end
 
-      def report_violation(violation)
-        ExitCodes.print_error format(
+      def violation_lines(violation)
+        [format(
           "%<criterion>s coverage (%<actual>s) is above the expected maximum coverage (%<expected>.2f%%). " \
           "Time to bump the threshold!",
           criterion: violation.fetch(:criterion).capitalize,
-          actual: SimpleCov::Color.colorize_percent(violation.fetch(:actual)),
+          actual: Color.colorize_percent(violation.fetch(:actual)),
           expected: violation.fetch(:expected)
-        )
+        )]
       end
     end
   end

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -2,33 +2,34 @@
 
 module SimpleCov
   module ExitCodes
-    # Fails when any individual file falls below the configured minimum
-    # coverage for any criterion.
     class MinimumCoverageByFileCheck < Check
-      def initialize(result, minimum_coverage_by_file, overrides = {})
+      # `baseline:` exempts the file-and-criterion pairs it covers: those answer to
+      # their own floor via `BaselineCheck` instead.
+      def initialize(result, minimum_coverage_by_file, overrides = {}, baseline: nil)
         super(result, minimum_coverage_by_file)
         @overrides = overrides
+        @baseline = baseline
       end
 
       def exit_code
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+        MINIMUM_COVERAGE
       end
 
-    private
+      private
 
       def compute_violations
-        SimpleCov::CoverageViolations.minimum_by_file(result, thresholds, @overrides)
+        CoverageViolations.minimum_by_file(result, thresholds, @overrides, baseline: @baseline)
       end
 
-      def report_violation(violation)
-        ExitCodes.print_error format(
+      def violation_lines(violation)
+        [format(
           "%<criterion>s coverage by file (%<actual>s) is below the expected minimum coverage " \
           "(%<expected>.2f%%) in %<filename>s.",
           criterion: violation.fetch(:criterion).capitalize,
-          actual: SimpleCov::Color.colorize_percent(violation.fetch(:actual)),
+          actual: Color.colorize_percent(violation.fetch(:actual)),
           expected: violation.fetch(:expected),
           filename: violation.fetch(:project_filename)
-        )
+        )]
       end
     end
   end

data/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -2,28 +2,26 @@
 
 module SimpleCov
   module ExitCodes
-    # Fails when any configured group falls below its minimum coverage
-    # threshold for any criterion.
     class MinimumCoverageByGroupCheck < Check
       def exit_code
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+        MINIMUM_COVERAGE
       end
 
-    private
+      private
 
       def compute_violations
-        SimpleCov::CoverageViolations.minimum_by_group(result, thresholds)
+        CoverageViolations.minimum_by_group(result, thresholds)
       end
 
-      def report_violation(violation)
-        ExitCodes.print_error format(
+      def violation_lines(violation)
+        [format(
           "%<criterion>s coverage by group (%<actual>s) is below the expected minimum coverage " \
           "(%<expected>.2f%%) in %<group_name>s.",
           criterion: violation.fetch(:criterion).capitalize,
-          actual: SimpleCov::Color.colorize_percent(violation.fetch(:actual)),
+          actual: Color.colorize_percent(violation.fetch(:actual)),
           expected: violation.fetch(:expected),
           group_name: violation.fetch(:group_name)
-        )
+        )]
       end
     end
   end

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -2,53 +2,52 @@
 
 module SimpleCov
   module ExitCodes
-    # Fails when the overall (project-wide) coverage for any criterion is
-    # below the configured minimum.
     class MinimumOverallCoverageCheck < Check
       def exit_code
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+        MINIMUM_COVERAGE
       end
 
-    private
+      private
 
       WORST_FILES_LIMIT = 5
       private_constant :WORST_FILES_LIMIT
 
       def compute_violations
-        SimpleCov::CoverageViolations.minimum_overall(result, thresholds)
+        CoverageViolations.minimum_overall(result, thresholds)
       end
 
-      def report_violation(violation)
+      def violation_lines(violation)
         criterion = violation.fetch(:criterion)
-        actual = violation.fetch(:actual)
-        ExitCodes.print_error format(
+        headline = format(
           "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
           criterion: criterion.capitalize,
-          actual: SimpleCov::Color.colorize_percent(actual),
+          actual: Color.colorize_percent(violation.fetch(:actual)),
           expected: violation.fetch(:expected)
         )
-        report_worst_files(criterion)
+        [headline, *worst_files_lines(criterion)]
       end
 
-      def report_worst_files(criterion)
+      def worst_files_lines(criterion)
         worst = worst_files_for(criterion)
-        return if worst.empty?
+        return [] if worst.empty?
 
-        ExitCodes.print_error "  Lowest-coverage files (#{criterion}):"
-        worst.each do |path, percent|
-          ExitCodes.print_error format(
+        ["  Lowest-coverage files (#{criterion}):"] + worst.map do |path, percent|
+          format(
             "    %<percent>s  %<path>s",
-            percent: SimpleCov::Color.colorize_percent(percent, format("%6.2f%%", percent)),
+            percent: Color.colorize_percent(percent, format("%6.2f%%", percent)),
             path: path
           )
         end
       end
 
+      # The list is a hint at where to add tests, so a fully covered file has no
+      # business on it: without the filter, files at 100% padded the list out to
+      # its five entries (#1286).
       def worst_files_for(criterion)
         stats_key = SimpleCov.coverage_statistics_key(criterion)
         with_stats = result.files.filter_map do |source_file|
           stats = source_file.coverage_statistics[stats_key]
-          [source_file.project_filename, stats.percent] if stats
+          [source_file.project_filename, stats.percent] if stats && stats.percent < 100
         end
         with_stats.sort_by { |_path, percent| percent }.first(WORST_FILES_LIMIT)
       end

data/lib/simplecov/exit_codes.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # Exit statuses SimpleCov sets when coverage checks fail, and the output
-  # helper the enforcement machinery reports through.
   module ExitCodes
     SUCCESS = 0
     EXCEPTION = 1
@@ -10,25 +8,33 @@ module SimpleCov
     MAXIMUM_COVERAGE_DROP = 3
     MAXIMUM_COVERAGE = 4
 
-    # Threshold-violation reports and exit-status notices are the output of
-    # the enforcement feature, not Ruby warnings: routing them through
-    # `Kernel#warn` made `-W0` swallow the explanation for a failing exit
-    # code, let `Warning.warn` hooks (warning trackers, raise-on-warning
-    # test setups) intercept them mid-`at_exit`, and fed colorized text to
+    # The plural unit each criterion's misses count in, for the checks that report
+    # counts rather than percents.
+    UNITS = {line: "lines", branch: "branches", method: "methods"}.freeze
+
+    # Threshold-violation reports and exit-status notices are the output of the
+    # enforcement feature, not Ruby warnings: routing them through `Kernel#warn`
+    # made `-W0` swallow the explanation for a failing exit code, let
+    # `Warning.warn` hooks intercept them mid-at_exit, and fed colorized text to
     # warning logs. `print_errors false` remains the intended opt-out.
+    #
+    # A parallel runner can close a worker's stderr before its at_exit hooks
+    # run, hence the rescue.
     def self.print_error(message)
       $stderr.puts message # rubocop:disable Style/StderrPuts
     rescue IOError
-      # A parallel runner can close a worker's stderr before its at_exit
-      # hooks run (rspec-conductor does). The violation still has to set
-      # the exit status even when its explanation cannot be printed.
+      # The violation still has to set the exit status even when its
+      # explanation cannot be printed.
     end
   end
 end
 
 require_relative "exit_codes/check"
+require_relative "exit_codes/baseline_check"
 require_relative "exit_codes/exit_code_handling"
 require_relative "exit_codes/maximum_coverage_drop_check"
+require_relative "exit_codes/maximum_missed_check"
+require_relative "exit_codes/maximum_missed_per_file_check"
 require_relative "exit_codes/maximum_overall_coverage_check"
 require_relative "exit_codes/minimum_coverage_by_file_check"
 require_relative "exit_codes/minimum_coverage_by_group_check"

data/lib/simplecov/exit_handling.rb

@@ -2,9 +2,11 @@
 
 require "English"
 
-# `at_exit` orchestration: post-suite report generation, threshold
-# checks, deferral when a sibling subprocess already wrote a fresher
-# report, and exit-status propagation.
+#
+# `at_exit` orchestration: post-suite report generation, threshold checks,
+# deferral when a sibling subprocess already wrote a fresher report, and
+# exit-status propagation.
+#
 module SimpleCov
   class << self
     # @api private
@@ -14,38 +16,59 @@ module SimpleCov
       :minimum_coverage_by_file_overrides,
       :minimum_coverage_by_group,
       :maximum_coverage,
-      :maximum_coverage_drop
+      :maximum_coverage_drop,
+      :maximum_missed,
+      :maximum_missed_per_file,
+      :maximum_missed_per_file_overrides,
+      :baseline
     )
 
     def at_exit_behavior
-      # If we are in a different process than called start, don't interfere.
-      return if SimpleCov.pid != Process.pid
+      # A different process than the one that called start; don't interfere.
+      return unless started_in_this_process?
 
-      # If Coverage is no longer running (e.g. someone manually stopped it
-      # or a test consumed the result) then don't run exit tasks.
+      # Coverage is no longer running (someone stopped it manually, or a test
+      # consumed the result), so don't run exit tasks.
       return unless Coverage.running?
 
-      # Capture the suite's exit status BEFORE the deferral probe: its
-      # freshness check rescues filesystem errors, and completing any
-      # rescue inside an at_exit handler resets $ERROR_INFO to nil.
+      # Captured BEFORE the deferral probe: its freshness check rescues
+      # filesystem errors, and completing any rescue inside an at_exit handler
+      # resets $ERROR_INFO to nil.
       error_exit_status = exit_status_from_exception
 
       # Stand down when we'd only clobber a fresher report (#581).
       return if defer_to_existing_report?
 
-      SimpleCov.run_exit_tasks!(error_exit_status)
+      run_exit_tasks!(error_exit_status)
     end
 
-    # @api private — called from the at_exit block (which pre-captures
-    # the status, see there) and by `collate` (the default argument).
-    def run_exit_tasks!(error_exit_status = exit_status_from_exception)
+    # @api private -- everything the end of a measured run does, answered as the
+    # exit status the process should end with rather than performed as an exit.
+    # The one side effect left to the caller is ending the process, which is
+    # what makes this whole path answerable from inside a test.
+    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?
+      if previous_error?(error_exit_status)
+        report_previous_error
+        error_exit_status
+      elsif ready_to_process_results?
+        report_processing_failure(process_result(result))
+      else
+        ExitCodes::SUCCESS
+      end
     end
 
-    # @api private — returns the exit status from the exit exception.
+    # @api private -- the exiting adapter over `run_exit_tasks`, called from the
+    # at_exit block (which pre-captures the status, see there) and by `collate`.
+    def run_exit_tasks!(error_exit_status = exit_status_from_exception)
+      status = run_exit_tasks(error_exit_status)
+
+      # Force exit with stored status (#5).
+      Kernel.exit(status) unless successful?(status)
+    end
+
+    # @api private
     def exit_status_from_exception
       @exit_exception = $ERROR_INFO
       return nil unless @exit_exception
@@ -53,76 +76,88 @@ module SimpleCov
       if @exit_exception.is_a?(SystemExit)
         @exit_exception.status
       else
-        SimpleCov::ExitCodes::EXCEPTION
+        ExitCodes::EXCEPTION
       end
     end
 
-    # @api private — strict boolean so rspec-mocks 4's predicate matcher
-    # accepts it. test_unit sets status 0 on success, so SUCCESS must
-    # also be treated as "not a previous error".
+    # @api private -- strict boolean so rspec-mocks 4's predicate matcher
+    # accepts it. test_unit sets status 0 on success, so SUCCESS must also be
+    # treated as "not a previous error".
     def previous_error?(error_exit_status)
-      !!(error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS)
+      return false unless error_exit_status
+
+      !successful?(error_exit_status)
     end
 
-    # @api private
-    def exit_and_report_previous_error(exit_status)
-      if print_errors
-        ExitCodes.print_error SimpleCov::Color.colorize(
-          "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
-          :yellow
-        )
-      end
-      Kernel.exit(exit_status)
+    # @api private -- the notice alone; the status it accompanies is the
+    # caller's to answer with.
+    def report_previous_error
+      return unless print_errors
+
+      ExitCodes.print_error Color.colorize(
+        "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
+        :yellow
+      )
     end
 
-    # @api private — the process that owns final merge processing is the
-    # only one that reports against thresholds, and only when its
-    # `wait_for_other_processes` confirmed every sibling reported.
-    # When the wait times out, the merged total is partial and
-    # comparing it against `minimum_coverage` / `maximum_coverage`
-    # would surface a spurious "below minimum" violation about the
-    # missing slice rather than a real shortfall.
+    # @api private. The process that owns final merge processing is the only one
+    # that reports against thresholds, and only when its
+    # `wait_for_other_processes` confirmed every sibling reported. When the wait
+    # times out the merged total is partial, and comparing it against the
+    # thresholds would surface a spurious violation about the missing slice.
     def ready_to_process_results?
       merge_finalization_owner? && result? &&
         (collating_result? || parallel_results_complete?)
     end
 
-    def process_results_and_report_error
-      exit_status = process_result(result)
-
-      # Force exit with stored status (see github issue #5)
-      return unless exit_status.positive?
-
-      if print_errors
-        ExitCodes.print_error SimpleCov::Color.colorize(
+    # @api private -- answers the status it was handed, explaining it first when
+    # it is a coverage failure worth explaining.
+    def report_processing_failure(exit_status)
+      if exit_status.positive? && print_errors
+        ExitCodes.print_error Color.colorize(
           "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
         )
       end
-      Kernel.exit exit_status
+      exit_status
     end
 
-    # @api private — `exit_status = SimpleCov.process_result(SimpleCov.result)`.
+    # @api private. The history entry is recorded on the same successful-run
+    # condition `.last_run.json` uses, so a run that failed its thresholds
+    # becomes neither the drop baseline nor a data point in the trend.
     def process_result(result)
       result_exit_status = result_exit_status(result)
-      write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
+      if successful?(result_exit_status)
+        write_last_run(result)
+        History.record(result)
+      end
       result_exit_status
     end
 
+    # mutant:disable -- a pid is an Integer, and Integers answer ==, eql? and
+    # equal? alike for the same value.
+    def started_in_this_process?
+      SimpleCov.pid == Process.pid
+    end
+
+    # Asked as a predicate rather than compared against `ExitCodes::SUCCESS`,
+    # because two equal Integers are equal through every spelling of the
+    # comparison.
+    def successful?(status)
+      status.zero?
+    end
+
     def result_exit_status(result)
       ExitCodes::ExitCodeHandling.call(result, coverage_limits: build_coverage_limits)
     end
 
-  private
+    private
 
+    # Every CoverageLimits member is named after the configuration reader that
+    # supplies it, so a new limit only has to be added to the Data definition
+    # and the checks.
     def build_coverage_limits
-      CoverageLimits.new(
-        minimum_coverage: minimum_coverage,
-        minimum_coverage_by_file: minimum_coverage_by_file,
-        minimum_coverage_by_file_overrides: minimum_coverage_by_file_overrides,
-        minimum_coverage_by_group: minimum_coverage_by_group,
-        maximum_coverage: maximum_coverage,
-        maximum_coverage_drop: maximum_coverage_drop
-      )
+      limits = CoverageLimits.members.to_h { |name| [name, public_send(name)] } #: Hash[Symbol, untyped]
+      CoverageLimits.new(**limits)
     end
   end
 end