simplecov 1.0.0 → 1.1.1

data/lib/simplecov/configuration/thresholds.rb

@@ -14,9 +14,7 @@ module SimpleCov
     def minimum_coverage(coverage = nil)
       return @minimum_coverage ||= {} unless coverage
 
-      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage, "minimum_coverage")
-      @minimum_coverage = coverage
+      @minimum_coverage = normalized_threshold(coverage, "minimum_coverage")
     end
 
     def raise_on_invalid_coverage(coverage, coverage_setting)
@@ -35,9 +33,7 @@ module SimpleCov
     def maximum_coverage(coverage = nil)
       return @maximum_coverage ||= {} unless coverage
 
-      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage, "maximum_coverage")
-      @maximum_coverage = coverage
+      @maximum_coverage = normalized_threshold(coverage, "maximum_coverage")
     end
 
     #
@@ -58,9 +54,7 @@ module SimpleCov
     def maximum_coverage_drop(coverage_drop = nil)
       return @maximum_coverage_drop ||= {} unless coverage_drop
 
-      coverage_drop = {primary_coverage => coverage_drop} if coverage_drop.is_a?(Numeric)
-      raise_on_invalid_coverage(coverage_drop, "maximum_coverage_drop")
-      @maximum_coverage_drop = coverage_drop
+      @maximum_coverage_drop = normalized_threshold(coverage_drop, "maximum_coverage_drop")
     end
 
     #
@@ -100,10 +94,8 @@ module SimpleCov
 
       SimpleCov::Deprecation.warn("`SimpleCov.minimum_coverage_by_group` is deprecated. " \
                                   "Replace it with:\n#{per_group_coverage_replacement(coverage)}")
-      @minimum_coverage_by_group = coverage.dup.transform_values do |group_coverage|
-        group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
-        raise_on_invalid_coverage(group_coverage, "minimum_coverage_by_group")
-        group_coverage
+      @minimum_coverage_by_group = coverage.to_h do |group_name, group_coverage|
+        [GroupNames.normalize(group_name), normalized_threshold(group_coverage, "minimum_coverage_by_group")]
       end
     end
 
@@ -117,13 +109,26 @@ module SimpleCov
 
   private
 
+    # Shared normalize-and-validate step behind every threshold setter:
+    # a bare Numeric targets the primary criterion, and the resulting
+    # per-criterion hash is validated before it is stored.
+    def normalized_threshold(coverage, setting)
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+      raise_on_invalid_coverage(coverage, setting)
+      coverage
+    end
+
     # Split a `minimum_coverage_by_file` argument into Symbol-keyed
     # criterion defaults and String/Regexp-keyed per-path overrides;
     # normalize Numeric override values to `{primary_coverage => N}`
     # so downstream code only has one shape to handle.
     def partition_per_file_thresholds(coverage)
       coverage.each_key { |key| validate_per_file_key(key) }
-      defaults, raw = coverage.partition { |key, _| key.is_a?(Symbol) }.map(&:to_h)
+      pairs = coverage.partition { |key, _| key.is_a?(Symbol) }
+      # The assertions restate what the partition predicate guarantees:
+      # Symbol keys carry per-criterion Numeric defaults, the rest are paths.
+      defaults = pairs[0].to_h #: coverage_thresholds
+      raw = pairs[1].to_h #: Hash[String | Regexp, Numeric | coverage_thresholds]
       overrides = raw.transform_values { |value| value.is_a?(Numeric) ? {primary_coverage => value} : value }
       [defaults, overrides]
     end
@@ -143,11 +148,11 @@ module SimpleCov
     # `minimum_coverage_by_file` argument so the deprecation warning can be
     # copy-pasted verbatim into the user's config.
     def per_file_coverage_replacement(defaults, overrides)
-      by_criterion = Hash.new { |hash, criterion| hash[criterion] = [] }
-      defaults.each { |criterion, percent| by_criterion[criterion] << "minimum_per_file #{percent}" }
+      by_criterion = {} #: Hash[Symbol, Array[String]]
+      defaults.each { |criterion, percent| (by_criterion[criterion] ||= []) << "minimum_per_file #{percent}" }
       overrides.each do |target, criteria|
         criteria.each do |criterion, percent|
-          by_criterion[criterion] << "minimum_per_file #{percent}, only: #{target.inspect}"
+          (by_criterion[criterion] ||= []) << "minimum_per_file #{percent}, only: #{target.inspect}"
         end
       end
       render_coverage_blocks(by_criterion)
@@ -155,11 +160,11 @@ module SimpleCov
 
     # Same, for a (deprecated) `minimum_coverage_by_group` argument.
     def per_group_coverage_replacement(coverage)
-      by_criterion = Hash.new { |hash, criterion| hash[criterion] = [] }
-      coverage.each do |group_name, group_coverage|
-        group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
-        group_coverage.each do |criterion, percent|
-          by_criterion[criterion] << "minimum_per_group #{percent}, only: #{group_name.inspect}"
+      by_criterion = {} #: Hash[Symbol, Array[String]]
+      coverage.each do |group_name, thresholds|
+        normalized = (thresholds.is_a?(Numeric) ? {primary_coverage => thresholds} : thresholds) #: coverage_thresholds
+        normalized.each do |criterion, percent|
+          (by_criterion[criterion] ||= []) << "minimum_per_group #{percent}, only: #{group_name.inspect}"
         end
       end
       render_coverage_blocks(by_criterion)

data/lib/simplecov/configuration.rb

@@ -51,9 +51,10 @@ module SimpleCov
     #
     def coverage_path(path = nil)
       if path
-        @coverage_path = File.expand_path(path)
+        expanded = File.expand_path(path)
+        @coverage_path = expanded
         @coverage_path_explicit = true
-        FileUtils.mkdir_p @coverage_path
+        FileUtils.mkdir_p expanded
       end
 
       @coverage_path ||= File.expand_path(coverage_dir, root)
@@ -65,9 +66,8 @@ module SimpleCov
     # with SimpleCov.command_name("test:units").
     #
     def command_name(name = nil)
-      @name = name unless name.nil?
-      @name ||= SimpleCov::CommandGuesser.guess
-      @name
+      @command_name = name unless name.nil?
+      @command_name ||= SimpleCov::CommandGuesser.guess
     end
 
     # Returns the hash of available profiles
@@ -77,20 +77,18 @@ module SimpleCov
 
     #
     # Allows you to configure simplecov in a block instead of
-    # prepending SimpleCov to each config method.
+    # prepending SimpleCov to each config method. Parameterized blocks retain
+    # their caller context and receive this configuration target explicitly.
     #
     def configure(&block)
-      block_context = block.binding.receiver
+      raise ArgumentError, "configuration block required" unless block
 
-      # If the block was defined in our own context, instance_exec is sufficient
-      return instance_exec(&block) if equal?(block_context)
-
-      # Copy the caller's instance variables in so that references like @filter
-      # inside the block resolve to the caller's values, not ours.
-      saved = swap_ivars_from(block_context)
-      instance_exec(&block)
-    ensure
-      restore_ivars(block_context, saved) if defined?(saved) && saved
+      if block.parameters.empty?
+        instance_exec(&(_ = block))
+      else
+        yield self
+      end
+      self
     end
 
     #
@@ -100,12 +98,13 @@ module SimpleCov
     #
     def at_exit(&block)
       @at_exit = block if block
-      return @at_exit if @at_exit
+      configured = @at_exit
+      return configured if configured
       return proc {} unless active_session?
 
       @at_exit = proc do
         result = SimpleCov.result
-        result.format! if result && SimpleCov.merge_finalization_owner? && SimpleCov.final_result_process?
+        result.format! if result && SimpleCov.merge_finalization_owner?
       end
     end
 
@@ -144,40 +143,20 @@ module SimpleCov
     # SimpleCov.root, capitalized with underscores → spaces.
     #
     def project_name(new_name = nil)
-      return @project_name if defined?(@project_name) && @project_name && new_name.nil?
+      current = defined?(@project_name) ? @project_name : nil
+      return current if current && new_name.nil?
 
       @project_name = new_name if new_name.is_a?(String)
       @project_name ||= File.basename(root).capitalize.tr("_", " ")
     end
-
-  private
-
-    # Copy instance variables from block_context into self, saving any
-    # of ours that would be clobbered. Returns the saved values for
-    # later restoration.
-    def swap_ivars_from(block_context)
-      saved = {}
-      our_ivars = instance_variables
-      block_context.instance_variables.each do |ivar|
-        saved[ivar] = instance_variable_get(ivar) if our_ivars.include?(ivar)
-        instance_variable_set(ivar, block_context.instance_variable_get(ivar))
-      end
-      saved
-    end
-
-    # Copy instance variables back to block_context and restore our saved values.
-    def restore_ivars(block_context, saved)
-      block_context.instance_variables.each do |ivar|
-        block_context.instance_variable_set(ivar, instance_variable_get(ivar))
-      end
-      saved.each { |ivar, value| instance_variable_set(ivar, value) }
-    end
   end
 end
 
 require_relative "configuration/coverage"
 require_relative "configuration/coverage_criteria"
+require_relative "configuration/eval_coverage"
 require_relative "configuration/filters"
+require_relative "configuration/groups"
 require_relative "configuration/formatting"
 require_relative "configuration/ignored_entries"
 require_relative "configuration/merging"

data/lib/simplecov/coverage_json.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SimpleCov
+  # Shared parser for coverage.json consumers. It enforces the encoding and
+  # stable outermost shape while leaving command- or viewer-specific fields to
+  # their respective callers.
+  module CoverageJSON
+    class Error < StandardError; end
+
+    def self.load(path)
+      source = File.binread(path).force_encoding(Encoding::UTF_8)
+      raise Error, "input is not valid UTF-8" unless source.valid_encoding?
+
+      document = JSON.parse(source)
+      return document if document.is_a?(Hash)
+
+      raise Error, "top-level value must be an object"
+    rescue JSON::ParserError => e
+      raise Error, e.message
+    end
+  end
+end

data/lib/simplecov/coverage_statistics.rb

@@ -10,13 +10,16 @@ module SimpleCov
   # * missed - how many of the coverables are missed
   # * omitted - how many lines cannot be covered (blank lines/comments); only meaningful for line coverage
   # * percent - percentage as covered/missed
-  # * strength - average hits per/coverable (will not exist for one shot lines format)
+  # * strength - average hits per coverable unit (will not exist for one shot lines format)
   class CoverageStatistics
     attr_reader :total, :covered, :missed, :omitted, :strength, :percent
 
+    # Seed for the reduce in `.from`: covered, missed, omitted, strength.
+    ZERO_STATS = [0, 0, 0, 0.0].freeze #: [Integer, Integer, Integer, Float]
+
     def self.from(coverage_statistics)
       sum_covered, sum_missed, sum_omitted, sum_total_strength =
-        coverage_statistics.reduce([0, 0, 0, 0.0]) do |(covered, missed, omitted, total_strength), stats|
+        coverage_statistics.reduce(ZERO_STATS) do |(covered, missed, omitted, total_strength), stats|
           [
             covered + stats.covered,
             missed + stats.missed,

data/lib/simplecov/coverage_violations.rb

@@ -46,7 +46,8 @@ module SimpleCov
       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) : []
+          none = [] # : Array[Hash[Symbol, untyped]]
+          group ? group_minimum_violations(group_name, group, minimums) : none
         end
       end
 
@@ -121,11 +122,15 @@ module SimpleCov
         end
       end
 
+      # The misconfiguration notice is enforcement output, not a Ruby
+      # warning: like every other enforcement message it must survive
+      # `-W0` and `Warning.warn` hooks (see ExitCodes.print_error) and
+      # honor the `print_errors` opt-out.
       def lookup_group(result, group_name)
         group = result.groups[group_name]
-        unless group
-          warn "minimum_coverage_by_group: no group named '#{group_name}' exists. " \
-               "Available groups: #{result.groups.keys.join(', ')}"
+        if group.nil? && SimpleCov.print_errors
+          ExitCodes.print_error "minimum_coverage_by_group: no group named '#{group_name}' exists. " \
+                                "Available groups: #{result.groups.keys.join(', ')}"
         end
         group
       end
@@ -133,8 +138,14 @@ module SimpleCov
       def compute_drop(criterion, result, last_run)
         stats_key = SimpleCov.coverage_statistics_key(criterion)
         last_coverage_percent = last_run.dig(:result, stats_key)
-        last_coverage_percent ||= last_run.dig(:result, :covered_percent) if stats_key == :line
-        return unless last_coverage_percent
+        if last_coverage_percent.nil? && stats_key == :line
+          last_coverage_percent = last_run.dig(:result, :covered_percent)
+        end
+        # A hand-edited .last_run.json can carry any value type, and
+        # LastRun.read only vouches for the top level being a Hash.
+        # Treat a non-numeric percent like a missing one instead of
+        # raising out of the at_exit hook.
+        return unless last_coverage_percent.is_a?(Numeric)
 
         current = percent_for(result, criterion) or return
         (last_coverage_percent - current).floor(10)

data/lib/simplecov/defaults.rb

@@ -24,8 +24,11 @@ SimpleCov.configure do
   load_profile "test_frameworks"
 end
 
-# Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
+# Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info.
+# The program name is kept separately as well: the join below is lossy for a
+# path containing a space, and the guesser reads the executable from it.
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
+SimpleCov::CommandGuesser.original_program_name = $PROGRAM_NAME
 
 # Autoload config from ~/.simplecov if present
 require_relative "load_global_config"
@@ -38,15 +41,16 @@ loop do
   filename = config_path.join(".simplecov")
   if filename.exist?
     # `.simplecov` is a configuration file; SimpleCov.start calls inside
-    # it are intercepted and converted to configuration, with a deprecation
-    # warning. See `SimpleCov.with_dot_simplecov_autoload` and issue #581.
+    # it draw a deprecation warning, and tracking still begins for
+    # backward compatibility. See `SimpleCov.with_dot_simplecov_autoload`
+    # and issue #581.
     SimpleCov.with_dot_simplecov_autoload do
-      load filename
-    rescue LoadError, StandardError
+      load filename.to_s
+    rescue LoadError, StandardError => e
       # simplecov:disable — only fires when .simplecov is unreadable
       # or raises during load
       warn "Warning: Error occurred while trying to load #{filename}. " \
-           "Error message: #{$ERROR_INFO.message}"
+           "Error message: #{e.message}"
       # simplecov:enable
     end
     break

data/lib/simplecov/directive.rb

@@ -43,7 +43,7 @@ module SimpleCov
     PATTERN = /
       \#\s*simplecov\s*:\s*
       (?<mode>disable|enable)\b
-      (?:\s+(?<categories>#{CATEGORIES_PATTERN}))?
+      (?:\s+(?<categories>#{CATEGORIES_PATTERN})\b)?
       .*?
       \s*\z
     /x
@@ -55,8 +55,11 @@ module SimpleCov
     # An unclosed `disable` block extends to the end of the file.
     def self.disabled_ranges(src_lines)
       lines = src_lines.to_a
-      ranges = CATEGORIES.to_h { |category| [category, []] }
-      open_starts = {}
+      ranges = CATEGORIES.to_h do |category|
+        empty = [] # : Array[Range[Integer]]
+        [category, empty]
+      end
+      open_starts = {} # : Hash[Symbol, Integer]
 
       directives_in(lines).each { |directive| directive.apply(ranges, open_starts) }
       open_starts.each { |category, start| ranges[category] << (start..lines.size) }
@@ -91,7 +94,9 @@ module SimpleCov
 
       new(
         line_number: line_number,
-        mode: match[:mode].to_sym,
+        # `to_s` is a no-op: the pattern requires the `mode` group, so it
+        # is present whenever `match` is; it also satisfies the type checker.
+        mode: match[:mode].to_s.to_sym,
         categories: parse_categories(match[:categories]),
         inline: inline?(lines, line_number, column + match.begin(0))
       )

data/lib/simplecov/exit_codes/check.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    # Shared skeleton for the threshold checks: stash the result and the
+    # threshold configuration, fail when any violation exists, and
+    # report one message per violation. Subclasses supply `exit_code`,
+    # `compute_violations` (memoized here — `failing?` and `report` both
+    # consult it), and `report_violation`.
+    class Check
+      def initialize(result, thresholds)
+        @result = result
+        @thresholds = thresholds
+      end
+
+      def failing?
+        violations.any?
+      end
+
+      def report
+        violations.each { |violation| report_violation(violation) }
+      end
+
+    private
+
+      attr_reader :result, :thresholds
+
+      def violations
+        @violations ||= compute_violations
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -4,29 +4,24 @@ module SimpleCov
   module ExitCodes
     # Fails when any coverage criterion has dropped by more than the
     # configured maximum since the last recorded run.
-    class MaximumCoverageDropCheck
-      def initialize(result, maximum_coverage_drop)
-        @result = result
-        @maximum_coverage_drop = maximum_coverage_drop
-      end
-
-      def failing?
-        violations.any?
-      end
-
-      def report
-        violations.each { |violation| warn SimpleCov::Color.colorize(message_for(violation), :red) }
-      end
-
+    class MaximumCoverageDropCheck < Check
       def exit_code
         SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
       end
 
     private
 
+      def compute_violations
+        SimpleCov::CoverageViolations.maximum_drop(result, thresholds)
+      end
+
       # The "drop percent" is a delta, not a coverage level — it has no
-      # natural green/yellow/red mapping. Callers color the whole line red
-      # so the failure is still visible at a glance.
+      # 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)
+      end
+
       def message_for(violation)
         format(
           "%<criterion>s coverage has dropped by %<drop_percent>.2f%% since the last time " \
@@ -36,10 +31,6 @@ module SimpleCov
           max_drop: violation.fetch(:maximum)
         )
       end
-
-      def violations
-        @violations ||= SimpleCov::CoverageViolations.maximum_drop(@result, @maximum_coverage_drop)
-      end
     end
   end
 end

data/lib/simplecov/exit_codes/maximum_overall_coverage_check.rb

@@ -7,32 +7,19 @@ module SimpleCov
     # `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
-      def initialize(result, maximum_coverage)
-        @result = result
-        @maximum_coverage = maximum_coverage
-      end
-
-      def failing?
-        violations.any?
-      end
-
-      def report
-        violations.each { |violation| report_violation(violation) }
-      end
-
+    class MaximumOverallCoverageCheck < Check
       def exit_code
         SimpleCov::ExitCodes::MAXIMUM_COVERAGE
       end
 
     private
 
-      def violations
-        @violations ||= SimpleCov::CoverageViolations.maximum_overall(@result, @maximum_coverage)
+      def compute_violations
+        SimpleCov::CoverageViolations.maximum_overall(result, thresholds)
       end
 
       def report_violation(violation)
-        warn format(
+        ExitCodes.print_error format(
           "%<criterion>s coverage (%<actual>s) is above the expected maximum coverage (%<expected>.2f%%). " \
           "Time to bump the threshold!",
           criterion: violation.fetch(:criterion).capitalize,

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -4,39 +4,30 @@ module SimpleCov
   module ExitCodes
     # Fails when any individual file falls below the configured minimum
     # coverage for any criterion.
-    class MinimumCoverageByFileCheck
+    class MinimumCoverageByFileCheck < Check
       def initialize(result, minimum_coverage_by_file, overrides = {})
-        @result = result
-        @minimum_coverage_by_file = minimum_coverage_by_file
+        super(result, minimum_coverage_by_file)
         @overrides = overrides
       end
 
-      def failing?
-        violations.any?
-      end
-
-      def report
-        violations.each do |violation|
-          warn 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)),
-            expected: violation.fetch(:expected),
-            filename: violation.fetch(:project_filename)
-          )
-        end
-      end
-
       def exit_code
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       end
 
     private
 
-      def violations
-        @violations ||= SimpleCov::CoverageViolations.minimum_by_file(
-          @result, @minimum_coverage_by_file, @overrides
+      def compute_violations
+        SimpleCov::CoverageViolations.minimum_by_file(result, thresholds, @overrides)
+      end
+
+      def report_violation(violation)
+        ExitCodes.print_error 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)),
+          expected: violation.fetch(:expected),
+          filename: violation.fetch(:project_filename)
         )
       end
     end

data/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -4,37 +4,26 @@ module SimpleCov
   module ExitCodes
     # Fails when any configured group falls below its minimum coverage
     # threshold for any criterion.
-    class MinimumCoverageByGroupCheck
-      def initialize(result, minimum_coverage_by_group)
-        @result = result
-        @minimum_coverage_by_group = minimum_coverage_by_group
-      end
-
-      def failing?
-        violations.any?
-      end
-
-      def report
-        violations.each do |violation|
-          warn 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)),
-            expected: violation.fetch(:expected),
-            group_name: violation.fetch(:group_name)
-          )
-        end
-      end
-
+    class MinimumCoverageByGroupCheck < Check
       def exit_code
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       end
 
     private
 
-      def violations
-        @violations ||= SimpleCov::CoverageViolations.minimum_by_group(@result, @minimum_coverage_by_group)
+      def compute_violations
+        SimpleCov::CoverageViolations.minimum_by_group(result, thresholds)
+      end
+
+      def report_violation(violation)
+        ExitCodes.print_error 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)),
+          expected: violation.fetch(:expected),
+          group_name: violation.fetch(:group_name)
+        )
       end
     end
   end

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -4,20 +4,7 @@ module SimpleCov
   module ExitCodes
     # Fails when the overall (project-wide) coverage for any criterion is
     # below the configured minimum.
-    class MinimumOverallCoverageCheck
-      def initialize(result, minimum_coverage)
-        @result = result
-        @minimum_coverage = minimum_coverage
-      end
-
-      def failing?
-        violations.any?
-      end
-
-      def report
-        violations.each { |violation| report_violation(violation) }
-      end
-
+    class MinimumOverallCoverageCheck < Check
       def exit_code
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       end
@@ -27,14 +14,14 @@ module SimpleCov
       WORST_FILES_LIMIT = 5
       private_constant :WORST_FILES_LIMIT
 
-      def violations
-        @violations ||= SimpleCov::CoverageViolations.minimum_overall(@result, @minimum_coverage)
+      def compute_violations
+        SimpleCov::CoverageViolations.minimum_overall(result, thresholds)
       end
 
       def report_violation(violation)
         criterion = violation.fetch(:criterion)
         actual = violation.fetch(:actual)
-        warn format(
+        ExitCodes.print_error format(
           "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
           criterion: criterion.capitalize,
           actual: SimpleCov::Color.colorize_percent(actual),
@@ -47,9 +34,9 @@ module SimpleCov
         worst = worst_files_for(criterion)
         return if worst.empty?
 
-        warn "  Lowest-coverage files (#{criterion}):"
+        ExitCodes.print_error "  Lowest-coverage files (#{criterion}):"
         worst.each do |path, percent|
-          warn format(
+          ExitCodes.print_error format(
             "    %<percent>s  %<path>s",
             percent: SimpleCov::Color.colorize_percent(percent, format("%6.2f%%", percent)),
             path: path
@@ -59,7 +46,7 @@ module SimpleCov
 
       def worst_files_for(criterion)
         stats_key = SimpleCov.coverage_statistics_key(criterion)
-        with_stats = @result.files.filter_map do |source_file|
+        with_stats = result.files.filter_map do |source_file|
           stats = source_file.coverage_statistics[stats_key]
           [source_file.project_filename, stats.percent] if stats
         end