simplecov 0.22.0 → 1.3.0

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MaximumOverallCoverageCheck < Check
+      def exit_code
+        MAXIMUM_COVERAGE
+      end
+
+      private
+
+      def compute_violations
+        CoverageViolations.maximum_overall(result, thresholds)
+      end
+
+      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: Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected)
+        )]
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -2,52 +2,34 @@
 
 module SimpleCov
   module ExitCodes
-    class MinimumCoverageByFileCheck
-      def initialize(result, minimum_coverage_by_file)
-        @result = result
-        @minimum_coverage_by_file = minimum_coverage_by_file
-      end
-
-      def failing?
-        minimum_violations.any?
-      end
-
-      def report
-        minimum_violations.each do |violation|
-          $stderr.printf(
-            "%<criterion>s coverage by file (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
-            criterion: violation.fetch(:criterion).capitalize
-          )
-        end
+    class MinimumCoverageByFileCheck < Check
+      # `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
-
-      attr_reader :result, :minimum_coverage_by_file
+      private
 
-      def minimum_violations
-        @minimum_violations ||=
-          compute_minimum_coverage_data.select do |achieved|
-            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-          end
+      def compute_violations
+        CoverageViolations.minimum_by_file(result, thresholds, @overrides, baseline: @baseline)
       end
 
-      def compute_minimum_coverage_data
-        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
-          result.coverage_statistics_by_file.fetch(criterion).map do |actual_coverage|
-            {
-              criterion: criterion,
-              minimum_expected: expected_percent,
-              actual: SimpleCov.round_coverage(actual_coverage.percent)
-            }
-          end
-        end
+      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: 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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MinimumCoverageByGroupCheck < Check
+      def exit_code
+        MINIMUM_COVERAGE
+      end
+
+      private
+
+      def compute_violations
+        CoverageViolations.minimum_by_group(result, thresholds)
+      end
+
+      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: Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected),
+          group_name: violation.fetch(:group_name)
+        )]
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -2,51 +2,54 @@
 
 module SimpleCov
   module ExitCodes
-    class MinimumOverallCoverageCheck
-      def initialize(result, minimum_coverage)
-        @result = result
-        @minimum_coverage = minimum_coverage
+    class MinimumOverallCoverageCheck < Check
+      def exit_code
+        MINIMUM_COVERAGE
       end
 
-      def failing?
-        minimum_violations.any?
-      end
+      private
 
-      def report
-        minimum_violations.each do |violation|
-          $stderr.printf(
-            "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
-            criterion: violation.fetch(:criterion).capitalize
-          )
-        end
-      end
+      WORST_FILES_LIMIT = 5
+      private_constant :WORST_FILES_LIMIT
 
-      def exit_code
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      def compute_violations
+        CoverageViolations.minimum_overall(result, thresholds)
       end
 
-    private
-
-      attr_reader :result, :minimum_coverage
-
-      def minimum_violations
-        @minimum_violations ||= calculate_minimum_violations
+      def violation_lines(violation)
+        criterion = violation.fetch(:criterion)
+        headline = format(
+          "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
+          criterion: criterion.capitalize,
+          actual: Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected)
+        )
+        [headline, *worst_files_lines(criterion)]
       end
 
-      def calculate_minimum_violations
-        coverage_achieved = minimum_coverage.map do |criterion, percent|
-          {
-            criterion: criterion,
-            minimum_expected: percent,
-            actual: result.coverage_statistics.fetch(criterion).percent
-          }
+      def worst_files_lines(criterion)
+        worst = worst_files_for(criterion)
+        return [] if worst.empty?
+
+        ["  Lowest-coverage files (#{criterion}):"] + worst.map do |path, percent|
+          format(
+            "    %<percent>s  %<path>s",
+            percent: Color.colorize_percent(percent, format("%6.2f%%", percent)),
+            path: path
+          )
         end
+      end
 
-        coverage_achieved.select do |achieved|
-          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+      # 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 && stats.percent < 100
         end
+        with_stats.sort_by { |_path, percent| percent }.first(WORST_FILES_LIMIT)
       end
     end
   end

data/lib/simplecov/exit_codes.rb

@@ -6,10 +6,36 @@ module SimpleCov
     EXCEPTION = 1
     MINIMUM_COVERAGE = 2
     MAXIMUM_COVERAGE_DROP = 3
+    MAXIMUM_COVERAGE = 4
+
+    # 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
+      # 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"
 require_relative "exit_codes/minimum_overall_coverage_check"

data/lib/simplecov/exit_handling.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+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.
+#
+module SimpleCov
+  class << self
+    # @api private
+    CoverageLimits = Data.define(
+      :minimum_coverage,
+      :minimum_coverage_by_file,
+      :minimum_coverage_by_file_overrides,
+      :minimum_coverage_by_group,
+      :maximum_coverage,
+      :maximum_coverage_drop,
+      :maximum_missed,
+      :maximum_missed_per_file,
+      :maximum_missed_per_file_overrides,
+      :baseline
+    )
+
+    def at_exit_behavior
+      # A different process than the one that called start; don't interfere.
+      return unless started_in_this_process?
+
+      # 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?
+
+      # 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?
+
+      run_exit_tasks!(error_exit_status)
+    end
+
+    # @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
+
+      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 -- 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
+
+      if @exit_exception.is_a?(SystemExit)
+        @exit_exception.status
+      else
+        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".
+    def previous_error?(error_exit_status)
+      return false unless error_exit_status
+
+      !successful?(error_exit_status)
+    end
+
+    # @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 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
+
+    # @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
+      exit_status
+    end
+
+    # @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)
+      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
+
+    # 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
+      limits = CoverageLimits.members.to_h { |name| [name, public_send(name)] } #: Hash[Symbol, untyped]
+      CoverageLimits.new(**limits)
+    end
+  end
+end

data/lib/simplecov/file_list.rb

@@ -1,99 +1,79 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  # An array of SimpleCov SourceFile instances with additional collection helper
-  # methods for calculating coverage across them etc.
   class FileList
     include Enumerable
     extend Forwardable
 
-    def_delegators :@files,
-                   # For Enumerable
-                   :each,
-                   # also delegating methods implemented in Enumerable as they have
-                   # custom Array implementations which are presumably better/more
-                   # resource efficient
-                   :size, :map, :count,
-                   # surprisingly not in Enumerable
-                   :empty?, :length,
-                   # still act like we're kinda an array
-                   :to_a, :to_ary
+    # Enumerable's own implementations are skipped where Array has a better
+    # one, and `to_a` / `to_ary` keep this acting like the array it wraps.
+    def_delegators :@files, :each, :size, :map, :count, :empty?, :length, :to_a, :to_ary
 
     def initialize(files)
       @files = files
     end
 
-    def coverage_statistics
-      @coverage_statistics ||= compute_coverage_statistics
+    # With no argument answers the `{line:, branch:, method:}` Hash, and with a
+    # criterion symbol that one CoverageStatistics.
+    def coverage_statistics(criterion = nil)
+      stats = (@coverage_statistics ||= compute_coverage_statistics)
+      criterion ? stats[criterion] : stats
     end
 
     def coverage_statistics_by_file
       @coverage_statistics_by_file ||= compute_coverage_statistics_by_file
     end
 
-    # Returns the count of lines that have coverage
     def covered_lines
       coverage_statistics[:line]&.covered
     end
 
-    # Returns the count of lines that have been missed
     def missed_lines
       coverage_statistics[:line]&.missed
     end
 
-    # Returns the count of lines that are not relevant for coverage
     def never_lines
-      return 0.0 if empty?
-
-      map { |f| f.never_lines.count }.inject(:+)
+      sum { |f| f.never_lines.size }
     end
 
-    # Returns the count of skipped lines
     def skipped_lines
-      return 0.0 if empty?
-
-      map { |f| f.skipped_lines.count }.inject(:+)
+      sum { |f| f.skipped_lines.size }
     end
 
-    # Computes the coverage based upon lines covered and lines missed for each file
-    # Returns an array with all coverage percentages
     def covered_percentages
       map(&:covered_percent)
     end
 
-    # Finds the least covered file and returns that file's name
+    # Nil for an empty list, such as a fully filtered result.
     def least_covered_file
-      min_by(&:covered_percent).filename
+      # `covered_percent` is nil only for an unmeasured criterion, and :line
+      # is always measured, so the `|| 0.0` arm never fires at runtime; it
+      # exists to satisfy min_by's Comparable requirement.
+      min_by { |file| file.covered_percent || 0.0 }&.filename
     end
 
-    # Returns the overall amount of relevant lines of code across all files in this list
     def lines_of_code
       coverage_statistics[:line]&.total
     end
 
-    # Computes the coverage based upon lines covered and lines missed
-    # @return [Float]
-    def covered_percent
-      coverage_statistics[:line]&.percent
+    # Nil if the criterion was not measured.
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
     end
 
-    # Computes the strength (hits / line) based upon lines covered and lines missed
-    # @return [Float]
-    def covered_strength
-      coverage_statistics[:line]&.strength
+    # The strength (average hits per relevant unit) for the given criterion.
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
     end
 
-    # Return total count of branches in all files
     def total_branches
       coverage_statistics[:branch]&.total
     end
 
-    # Return total count of covered branches
     def covered_branches
       coverage_statistics[:branch]&.covered
     end
 
-    # Return total count of covered branches
     def missed_branches
       coverage_statistics[:branch]&.missed
     end
@@ -102,19 +82,54 @@ module SimpleCov
       coverage_statistics[:branch]&.percent
     end
 
-  private
+    def total_methods
+      coverage_statistics[:method]&.total
+    end
+
+    def covered_methods
+      coverage_statistics[:method]&.covered
+    end
 
+    def missed_methods
+      coverage_statistics[:method]&.missed
+    end
+
+    def method_covered_percent
+      coverage_statistics[:method]&.percent
+    end
+
+    private
+
+    # Seeded with one entry per criterion the user enabled, so an empty FileList
+    # still yields the right shape. `SourceFile#coverage_statistics` always
+    # reports all three criteria; FileList is the layer that filters to the
+    # enabled set so disabled criteria don't surface in totals, JSON, or the
+    # HTML report.
     def compute_coverage_statistics_by_file
-      @files.each_with_object(line: [], branch: []) do |file, together|
-        together[:line] << file.coverage_statistics.fetch(:line)
-        together[:branch] << file.coverage_statistics.fetch(:branch) if SimpleCov.branch_coverage?
+      seed = enabled_criteria_for_reporting.to_h do |criterion|
+        bucket = [] #: Array[CoverageStatistics]
+        [criterion, bucket]
+      end
+      each_with_object(seed) do |file, together|
+        file.coverage_statistics.each do |criterion, stats|
+          together.fetch(criterion) << stats if together.key?(criterion)
+        end
       end
     end
 
     def compute_coverage_statistics
-      coverage_statistics = {line: CoverageStatistics.from(coverage_statistics_by_file[:line])}
-      coverage_statistics[:branch] = CoverageStatistics.from(coverage_statistics_by_file[:branch]) if SimpleCov.branch_coverage?
-      coverage_statistics
+      coverage_statistics_by_file.transform_values { |stats| CoverageStatistics.from(stats) }
+    end
+
+    # `:line` (or its `:oneshot_line` synonym) is reported when either criterion
+    # is enabled; the JRuby-gated branch/method criteria are reported when they
+    # pass their own engine-support check.
+    def enabled_criteria_for_reporting
+      criteria = [] #: Array[SimpleCov::criterion]
+      criteria << :line if SimpleCov.line_coverage?
+      criteria << :branch if SimpleCov.branch_coverage?
+      criteria << :method if SimpleCov.method_coverage?
+      criteria
     end
   end
 end