Extract CoverageViolations module for threshold checks

The four ExitCodes::*Check classes and the JSON formatter's
`errors` section each reimplemented the same logic: iterate
configured thresholds, fetch per-criterion actuals, round via
`SimpleCov.round_coverage`, and filter where `actual` fails the
threshold.

Centralize that in `SimpleCov::CoverageViolations` with four module
methods (`minimum_overall`, `minimum_by_file`, `minimum_by_group`,
`maximum_drop`). Each returns an array of canonical violation hashes
with consistent `:criterion`/`:expected`/`:actual` keys (plus
`:filename`/`:project_filename` or `:group_name`/`:maximum` as
appropriate).

Exit-code checks shrink to thin wrappers that render the violations;
the JSON formatter's four error-formatting methods collapse to a
single call + map each.

Author: sferik

lib/simplecov.rb

@@ -478,6 +478,7 @@ def probably_running_parallel_tests?
 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"

lib/simplecov/coverage_violations.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Computes coverage threshold violations for a given result. Shared by
+  # the exit-code checks and the JSON formatter's `errors` section.
+  #
+  # Each method returns an array of violation hashes. All percents are
+  # rounded via `SimpleCov.round_coverage` so downstream consumers don't
+  # need to round again.
+  module CoverageViolations
+    class << self
+      # @return [Array<Hash>] {:criterion, :expected, :actual}
+      def minimum_overall(result, thresholds)
+        thresholds.filter_map do |criterion, expected|
+          actual = round(result.coverage_statistics.fetch(criterion).percent)
+          {criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      # @return [Array<Hash>] {:criterion, :expected, :actual, :filename, :project_filename}
+      def minimum_by_file(result, thresholds)
+        thresholds.flat_map do |criterion, expected|
+          result.files.filter_map { |file| file_minimum_violation(file, criterion, expected) }
+        end
+      end
+
+      # @return [Array<Hash>] {:group_name, :criterion, :expected, :actual}
+      def minimum_by_group(result, thresholds)
+        thresholds.flat_map do |group_name, minimums|
+          group = lookup_group(result, group_name)
+          group ? group_minimum_violations(group_name, group, minimums) : []
+        end
+      end
+
+      # @return [Array<Hash>] {:criterion, :maximum, :actual} where `actual`
+      #   is the observed drop (in percentage points) vs. the last run.
+      def maximum_drop(result, thresholds, last_run: SimpleCov::LastRun.read)
+        return [] unless last_run
+
+        thresholds.filter_map do |criterion, maximum|
+          actual = compute_drop(criterion, result, last_run)
+          {criterion: criterion, maximum: maximum, actual: actual} if actual && actual > maximum
+        end
+      end
+
+    private
+
+      def file_minimum_violation(file, criterion, expected)
+        actual = round(file.coverage_statistics.fetch(criterion).percent)
+        return unless actual < expected
+
+        {
+          criterion: criterion,
+          expected: expected,
+          actual: actual,
+          filename: file.filename,
+          project_filename: file.project_filename
+        }
+      end
+
+      def group_minimum_violations(group_name, group, minimums)
+        minimums.filter_map do |criterion, expected|
+          actual = round(group.coverage_statistics.fetch(criterion).percent)
+          {group_name: group_name, criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      def lookup_group(result, group_name)
+        group = result.groups[group_name]
+        warn "minimum_coverage_by_group: no group named '#{group_name}' exists. Available groups: #{result.groups.keys.join(', ')}" unless group
+        group
+      end
+
+      def compute_drop(criterion, result, last_run)
+        last_coverage_percent = last_run.dig(:result, criterion)
+        last_coverage_percent ||= last_run.dig(:result, :covered_percent) if criterion == :line
+        return unless last_coverage_percent
+
+        current = round(result.coverage_statistics.fetch(criterion).percent)
+        (last_coverage_percent - current).floor(10)
+      end
+
+      def round(percent)
+        SimpleCov.round_coverage(percent)
+      end
+    end
+  end
+end

lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -3,26 +3,22 @@
 module SimpleCov
   module ExitCodes
     class MaximumCoverageDropCheck
-      MAX_DROP_ACCURACY = 10
-
       def initialize(result, maximum_coverage_drop)
         @result = result
         @maximum_coverage_drop = maximum_coverage_drop
       end
 
       def failing?
-        return false unless maximum_coverage_drop && last_run
-
-        coverage_drop_violations.any?
+        violations.any?
       end
 
       def report
-        coverage_drop_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
-            criterion: violation[:criterion].capitalize,
-            drop_percent: SimpleCov.round_coverage(violation[:drop_percent]),
-            max_drop: violation[:max_drop]
+            criterion: violation.fetch(:criterion).capitalize,
+            drop_percent: violation.fetch(:actual),
+            max_drop: violation.fetch(:maximum)
           )
         end
       end
@@ -33,50 +29,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :maximum_coverage_drop
-
-      def last_run
-        return @last_run if defined?(@last_run)
-
-        @last_run = SimpleCov::LastRun.read
-      end
-
-      def coverage_drop_violations
-        @coverage_drop_violations ||=
-          compute_coverage_drop_data.select do |achieved|
-            achieved.fetch(:max_drop) < achieved.fetch(:drop_percent)
-          end
-      end
-
-      def compute_coverage_drop_data
-        maximum_coverage_drop.map do |criterion, percent|
-          {
-            criterion: criterion,
-            max_drop: percent,
-            drop_percent: drop_percent(criterion)
-          }
-        end
-      end
-
-      def drop_percent(criterion)
-        drop = last_coverage(criterion) -
-               SimpleCov.round_coverage(
-                 result.coverage_statistics.fetch(criterion).percent
-               )
-
-        # floats, I tell ya.
-        # irb(main):001:0* 80.01 - 80.0
-        # => 0.010000000000005116
-        drop.floor(MAX_DROP_ACCURACY)
-      end
-
-      def last_coverage(criterion)
-        last_coverage_percent = last_run[:result][criterion]
-
-        # fallback for old file format
-        last_coverage_percent = last_run[:result][:covered_percent] if !last_coverage_percent && criterion == :line
-
-        last_coverage_percent || 0
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.maximum_drop(@result, @maximum_coverage_drop)
       end
     end
   end

lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -9,17 +9,17 @@ def initialize(result, minimum_coverage_by_file)
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage by file (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%) in %<filename>s.\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
+            covered: violation.fetch(:actual),
+            minimum_coverage: violation.fetch(:expected),
             criterion: violation.fetch(:criterion).capitalize,
-            filename: violation.fetch(:filename)
+            filename: violation.fetch(:project_filename)
           )
         end
       end
@@ -30,27 +30,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :minimum_coverage_by_file
-
-      def minimum_violations
-        @minimum_violations ||=
-          compute_minimum_coverage_data.select do |achieved|
-            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-          end
-      end
-
-      def compute_minimum_coverage_data
-        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
-          result.files.map do |file|
-            actual_coverage = file.coverage_statistics.fetch(criterion)
-            {
-              criterion: criterion,
-              minimum_expected: expected_percent,
-              actual: SimpleCov.round_coverage(actual_coverage.percent),
-              filename: file.project_filename
-            }
-          end
-        end
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_by_file(@result, @minimum_coverage_by_file)
       end
     end
   end

lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -9,16 +9,16 @@ def initialize(result, minimum_coverage_by_group)
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage by group (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%) in %<group_name>s.\n",
             group_name: violation.fetch(:group_name),
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
+            covered: violation.fetch(:actual),
+            minimum_coverage: violation.fetch(:expected),
             criterion: violation.fetch(:criterion).capitalize
           )
         end
@@ -30,41 +30,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :minimum_coverage_by_group
-
-      def minimum_violations
-        @minimum_violations ||=
-          compute_minimum_coverage_data.select do |achieved|
-            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-          end
-      end
-
-      def compute_minimum_coverage_data
-        minimum_coverage_by_group.flat_map do |group_name, minimum_group_coverage|
-          group = find_group(group_name)
-          next [] unless group
-
-          minimum_group_coverage.map do |criterion, expected_percent|
-            actual_coverage = group.coverage_statistics.fetch(criterion)
-            minimum_coverage_hash(group_name, criterion, expected_percent, SimpleCov.round_coverage(actual_coverage.percent))
-          end
-        end
-      end
-
-      def find_group(group_name)
-        result.groups[group_name] || begin
-          warn "minimum_coverage_by_group: no group named '#{group_name}' exists. Available groups: #{result.groups.keys.join(', ')}"
-          nil
-        end
-      end
-
-      def minimum_coverage_hash(group_name, criterion, minimum_expected, actual)
-        {
-          group_name: group_name,
-          criterion: criterion,
-          minimum_expected: minimum_expected,
-          actual: actual
-        }
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_by_group(@result, @minimum_coverage_by_group)
       end
     end
   end

lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -9,15 +9,15 @@ def initialize(result, minimum_coverage)
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
+        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),
+            covered: violation.fetch(:actual),
+            minimum_coverage: violation.fetch(:expected),
             criterion: violation.fetch(:criterion).capitalize
           )
         end
@@ -29,24 +29,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :minimum_coverage
-
-      def minimum_violations
-        @minimum_violations ||= calculate_minimum_violations
-      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
-          }
-        end
-
-        coverage_achieved.select do |achieved|
-          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-        end
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_overall(@result, @minimum_coverage)
       end
     end
   end