simplecov 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26a19b5934dcf245f7e9cd50f8bc86224c4a7e8f02be43d813596d1de36e637d
-  data.tar.gz: b20bbfed696e333c5b41647b96202cf86b0a9375e529871052ecf3522cb37ae0
+  metadata.gz: 14c29bfd96c91bb39e5893969a5f35a320e0d3b23b3ae47161aabc21a182f69f
+  data.tar.gz: 2436a11c76e48df0df5c7432e1c1163f0bf36f9090e04d035017c99769e74b7d
 SHA512:
-  metadata.gz: 5f97c41bad62008a68ad3fb02919be7728e1f0c1f61049ff2d47f57455ef4d86530271ad4a7f7704b022ffd44366f0c41ebe4f051631ce5d67acff7b9e31a9c2
-  data.tar.gz: 5aeb18029dcb5aafad9dc878aa218113cbe26643db1bf8a1f5b1eabe09855ba0a91605a68c874bbc11f38d969d2c972090a6888ef1692d6f8c7d8bce0124d0fb
+  metadata.gz: 13bdde3f26f987d864caf3c2a861c479cac8e03c12fcf12752aad70b0ca55793e1dc529490d5ad9fc6250c780d6131fd78264ddaf0ca3158ae4cea5ffdb3b3b5
+  data.tar.gz: 21239f67622ae18b306783d6a355dd728247128ece00935601334b82f4f7f8948150768d0ac949c1db5c859c23187b4a9f568b7a45a49bf5a7a1ab40a8178951

data/lib/simplecov/cli/coverage.rb

@@ -28,7 +28,7 @@ module SimpleCov
       end
 
       def parse(args, stderr:)
-        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false}
+        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false} #: Hash[Symbol, untyped]
         rest =
           OptionParser.new do |o|
             o.on("--input PATH") { |v| opts[:input] = v }
@@ -45,7 +45,8 @@ module SimpleCov
         return stderr.puts("simplecov coverage: #{opts[:input]} not found") && nil unless File.exist?(opts[:input])
 
         data = JSON.parse(File.read(opts[:input]))
-        match = lookup(data.fetch("coverage", {}), opts[:path])
+        none = {} #: Hash[String, untyped]
+        match = lookup(data.fetch("coverage", none), opts[:path])
         return match if match
 
         stderr.puts("simplecov coverage: no entry for #{opts[:path]} in #{opts[:input]}")
@@ -65,7 +66,8 @@ module SimpleCov
       def emit(match, opts, stdout)
         filename, payload = match
         if opts[:json]
-          stdout.puts(JSON.pretty_generate(filename => payload))
+          entry = {filename => payload} #: Hash[untyped, untyped]
+          stdout.puts(JSON.pretty_generate(entry))
         else
           print_human(filename, payload, stdout, SimpleCov::CLI.color_enabled?(opts, stdout))
         end

data/lib/simplecov/cli/diff.rb

@@ -68,7 +68,8 @@ module SimpleCov
       end
 
       def load_coverage(path, stderr)
-        return normalize_keys(JSON.parse(File.read(path)).fetch("coverage", {})) if File.exist?(path)
+        no_coverage = {} #: Hash[String, untyped]
+        return normalize_keys(JSON.parse(File.read(path)).fetch("coverage", no_coverage)) if File.exist?(path)
 
         stderr.puts("simplecov diff: #{path} not found")
         nil

data/lib/simplecov/cli/dotfile.rb

@@ -57,8 +57,8 @@ module SimpleCov
       end
 
       def with_simplecov_loaded
-        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil)
-        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil)
+        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil) #: String?
+        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil) #: String?
         ENV["SIMPLECOV_NO_DEFAULTS"] = "1"
         # SIMPLECOV_CLI lets a project's `.simplecov` opt some config into
         # CLI-only behavior — e.g. simplecov itself sets `coverage_dir`
@@ -67,6 +67,8 @@ module SimpleCov
         require "simplecov"
         yield
       ensure
+        # @type var previous_no_defaults: String?
+        # @type var previous_cli: String?
         ENV["SIMPLECOV_NO_DEFAULTS"] = previous_no_defaults
         ENV["SIMPLECOV_CLI"]         = previous_cli
       end
@@ -79,20 +81,23 @@ module SimpleCov
       def load_with_start_neutered(path)
         klass = SimpleCov.singleton_class
         names = %i[start_tracking install_at_exit_hook]
-        stash = names.to_h { |name| [name, klass.instance_method(name)] }
+        stash = names.to_h { |name| [name, klass.instance_method(name)] } #: Hash[Symbol, UnboundMethod]
         # define_method over an existing method emits a "method redefined"
         # warning under $VERBOSE; the override and restore are intentional.
         silence_verbose { names.each { |name| klass.define_method(name) { nil } } }
         load path
       ensure
+        # @type var stash: Hash[Symbol, UnboundMethod]
+        # @type var klass: Class
         silence_verbose { stash.each { |name, method| klass.define_method(name, method) } }
       end
 
       def silence_verbose
-        previous = $VERBOSE
+        previous = $VERBOSE #: bool?
         $VERBOSE = nil
         yield
       ensure
+        # @type var previous: bool?
         $VERBOSE = previous
       end
     end

data/lib/simplecov/cli/merge.rb

@@ -57,7 +57,8 @@ module SimpleCov
       # generic "no mergeable results" into a message that points at
       # the specific input causing the failure.
       def parse_inputs(files, stderr)
-        files.each_with_object({}) do |path, memo|
+        parsed = {} #: Hash[String, Hash[String, untyped]]
+        files.each_with_object(parsed) do |path, memo|
           data = parse_input(path, stderr) or return nil
 
           memo[path] = data
@@ -85,8 +86,9 @@ module SimpleCov
       # mistake for "no merge happened." Surface the overlap so the
       # operator can rename the workers or accept the merge knowingly.
       def warn_about_duplicate_command_names(parsed, stderr)
-        files_per_command = parsed.each_with_object({}) do |(path, data), memo|
-          data.each_key { |command_name| (memo[command_name] ||= []) << path }
+        files_per_command = {} #: Hash[String, Array[String]]
+        parsed.each do |path, data|
+          data.each_key { |command_name| (files_per_command[command_name] ||= []) << path }
         end
         files_per_command.each do |command_name, paths|
           next if paths.size < 2

data/lib/simplecov/cli/report.rb

@@ -45,8 +45,9 @@ module SimpleCov
       end
 
       def emit_text(stdout, data, color)
-        emit_totals(stdout, "All Files", data.fetch("total", {}), color)
-        data.fetch("groups", {}).each { |name, group| emit_totals(stdout, name, group, color) }
+        none = {} #: Hash[String, untyped]
+        emit_totals(stdout, "All Files", data.fetch("total", none), color)
+        data.fetch("groups", none).each { |name, group| emit_totals(stdout, name, group, color) }
       end
 
       def emit_totals(stdout, label, totals, color)
@@ -66,17 +67,21 @@ module SimpleCov
       end
 
       def emit_json(stdout, data)
-        payload = {"All Files" => collect_section(data.fetch("total", {}))}
-        data.fetch("groups", {}).each { |name, group| payload[name] = collect_section(group) }
+        none = {} #: Hash[String, untyped]
+        payload = {"All Files" => collect_section(data.fetch("total", none))}
+        data.fetch("groups", none).each { |name, group| payload[name] = collect_section(group) }
         stdout.puts(JSON.pretty_generate(payload))
       end
 
       def collect_section(totals)
-        SECTIONS.each_with_object({}) do |(_, key), out|
+        sections = {} #: Hash[String, untyped]
+        SECTIONS.each_with_object(sections) do |(_, key), out|
           section = totals[key]
           next unless section.is_a?(Hash) && section["total"].to_i.positive?
 
-          out[key] = {"percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]}
+          out[key.to_s] = {
+            "percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]
+          }
         end
       end
     end

data/lib/simplecov/cli/run.rb

@@ -8,7 +8,7 @@ module SimpleCov
     # without a test_helper that already calls SimpleCov.start (e.g.
     # plain `bundle exec rake test` on an unconfigured library).
     module Run
-      AUTOSTART = File.expand_path("../autostart", __dir__)
+      AUTOSTART = File.expand_path("../autostart", __dir__.to_s)
 
     module_function
 

data/lib/simplecov/cli/serve.rb

@@ -36,16 +36,26 @@ module SimpleCov
         return error(stderr, "#{dir} doesn't exist; run your test suite first") unless File.directory?(dir)
 
         require "socket"
-        server = TCPServer.new(opts[:host], opts[:port])
-        announce(stdout, server, dir)
-        serve_loop(server, dir, stdout)
-        0
-      ensure
-        server&.close
+        with_server(opts) do |server|
+          announce(stdout, server, dir)
+          serve_loop(server, dir, stdout)
+          0
+        end
+      end
+
+      def with_server(opts)
+        # The receiver cast works around an rbs stdlib gap: TCPSocket's
+        # explicit `self.new` shadows TCPServer#initialize's (host, port) form.
+        server = (_ = TCPServer).new(opts[:host], opts[:port]) #: TCPServer
+        begin
+          yield server
+        ensure
+          server.close
+        end
       end
 
       def parse(args)
-        opts = {port: 0, host: "127.0.0.1"}
+        opts = {port: 0, host: "127.0.0.1"} #: Hash[Symbol, untyped]
         OptionParser.new do |o|
           o.on("--port N", Integer) { |v| opts[:port] = v }
           o.on("--host HOST")       { |v| opts[:host] = v }

data/lib/simplecov/cli/uncovered.rb

@@ -33,7 +33,8 @@ module SimpleCov
       def report(opts, keys, stdout, stderr)
         return 1 unless (data = Report.load_data(opts[:input], stderr))
 
-        files = rank(data.fetch("coverage", {}), opts[:threshold], keys).first(opts[:top])
+        none = {} #: Hash[String, untyped]
+        files = rank(data.fetch("coverage", none), opts[:threshold], keys).first(opts[:top])
         return stdout.puts(empty_message(opts[:json])) || 0 if files.empty?
 
         emit(stdout, files, opts)

data/lib/simplecov/combine/branches_combiner.rb

@@ -24,7 +24,8 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        combined = [coverage_a, coverage_b].each_with_object({}) do |coverage, memo|
+        merged = {} #: Hash[untyped, [untyped, Hash[untyped, untyped]]]
+        combined = [coverage_a, coverage_b].each_with_object(merged) do |coverage, memo|
           coverage.each do |condition, branches_inside|
             condition_key = tuple_identity(condition)
             condition_tuple, merged_branches = memo[condition_key] ||= [condition, {}]

data/lib/simplecov/combine/results_combiner.rb

@@ -21,7 +21,8 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(*results)
-        results.reduce({}) do |combined_results, next_result|
+        initial = {} #: Hash[untyped, untyped]
+        results.reduce(initial) do |combined_results, next_result|
           combine_result_sets(combined_results, next_result)
         end
       end

data/lib/simplecov/configuration/coverage.rb

@@ -42,7 +42,9 @@ module SimpleCov
     #
     def coverage(criterion, primary: false, enabled: true, oneshot: false, **thresholds, &block)
       criterion = enable_coverage_criterion(criterion, enabled: enabled, oneshot: oneshot)
-      primary_coverage(criterion) if primary
+      # The cast admits :eval, which primary_coverage rejects at runtime
+      # (it is enable-only and never in the enabled-criteria set).
+      primary_coverage(_ = criterion) if primary
 
       configurator = CoverageCriterion.new(self, criterion)
       apply_threshold_options(configurator, thresholds)
@@ -164,7 +166,9 @@ module SimpleCov
 
       # Make this criterion the report's primary (leading) criterion.
       def primary
-        @config.primary_coverage(@criterion)
+        # @criterion is Symbol-wide because this receiver is also built for
+        # :eval; primary_coverage validates at runtime.
+        @config.primary_coverage(_ = @criterion)
       end
     end
   end

data/lib/simplecov/configuration/coverage_criteria.rb

@@ -134,7 +134,9 @@ module SimpleCov
     def default_primary_coverage
       return DEFAULT_COVERAGE_CRITERION if coverage_criterion_enabled?(DEFAULT_COVERAGE_CRITERION)
 
-      coverage_criteria.first
+      # Set#first types as nilable, but an empty criteria set is rejected at
+      # start_tracking before any caller can observe a nil here.
+      _ = coverage_criteria.first
     end
 
     def raise_if_criterion_disabled(criterion)

data/lib/simplecov/configuration/formatting.rb

@@ -17,22 +17,32 @@ module SimpleCov
     # overhead.
     #
     def formatter(formatter = :__no_arg__)
-      return @formatter if formatter == :__no_arg__
-
-      @formatter = formatter || nil # normalize `false` to `nil`
+      case formatter
+      when :__no_arg__
+        @formatter
+      else
+        @formatter = formatter || nil # normalize `false` to `nil`
+      end
     end
 
     # Sets the configured formatters. Pass `[]` to opt out of
     # formatting entirely; see `formatter` for the rationale.
     def formatters(formatters = :__no_arg__)
-      return Array(formatter) if formatters == :__no_arg__
-
-      self.formatters = formatters
-      formatters
+      case formatters
+      when :__no_arg__
+        configured = formatter
+        configured ? [configured] : []
+      else
+        self.formatters = formatters
+        formatters
+      end
     end
 
     # Sets the configured formatters. Equivalent to `formatters [...]`.
+    # Accepts a single formatter as well as an Array, matching the pre-1.0 behavior
+    # where `MultiFormatter.new` normalized its input.
     def formatters=(formatters)
+      formatters = Array(formatters)
       @formatter = formatters.empty? ? nil : SimpleCov::Formatter::MultiFormatter.new(formatters)
     end
 

data/lib/simplecov/configuration/thresholds.rb

@@ -123,7 +123,11 @@ module SimpleCov
     # 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 +147,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 +159,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
@@ -80,17 +80,24 @@ module SimpleCov
     # prepending SimpleCov to each config method.
     #
     def configure(&block)
-      block_context = block.binding.receiver
+      # Both locals are read in the ensure clause, where flow analysis
+      # cannot see the assignments below; anchor their types up front.
+      saved = nil # : Hash[Symbol, untyped]?
+      block_context = block.binding.receiver # : untyped
 
-      # If the block was defined in our own context, instance_exec is sufficient
-      return instance_exec(&block) if equal?(block_context)
+      # If the block was defined in our own context, instance_exec is
+      # sufficient. The `_ =` erases the block's self-binding, which RBS
+      # can express but `instance_exec`'s core signature cannot accept.
+      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)
+      instance_exec(&(_ = block))
     ensure
-      restore_ivars(block_context, saved) if defined?(saved) && saved
+      # @type var block_context: untyped
+      # @type var saved: Hash[Symbol, untyped]?
+      restore_ivars(block_context, saved) if saved
     end
 
     #
@@ -100,7 +107,8 @@ 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
@@ -144,7 +152,8 @@ 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("_", " ")
@@ -156,7 +165,7 @@ module SimpleCov
     # of ours that would be clobbered. Returns the saved values for
     # later restoration.
     def swap_ivars_from(block_context)
-      saved = {}
+      saved = {} # : Hash[Symbol, untyped]
       our_ivars = instance_variables
       block_context.instance_variables.each do |ivar|
         saved[ivar] = instance_variable_get(ivar) if our_ivars.include?(ivar)

data/lib/simplecov/coverage_statistics.rb

@@ -14,9 +14,12 @@ module SimpleCov
   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
 

data/lib/simplecov/defaults.rb

@@ -41,12 +41,12 @@ loop do
     # it are intercepted and converted to configuration, with a deprecation
     # warning. 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

@@ -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/maximum_coverage_drop_check.rb

@@ -15,7 +15,7 @@ module SimpleCov
       end
 
       def report
-        violations.each { |violation| warn SimpleCov::Color.colorize(message_for(violation), :red) }
+        violations.each { |violation| ExitCodes.print_error SimpleCov::Color.colorize(message_for(violation), :red) }
       end
 
       def exit_code

data/lib/simplecov/exit_codes/maximum_overall_coverage_check.rb

@@ -32,7 +32,7 @@ module SimpleCov
       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

@@ -17,7 +17,7 @@ module SimpleCov
 
       def report
         violations.each do |violation|
-          warn format(
+          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,

data/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -16,7 +16,7 @@ module SimpleCov
 
       def report
         violations.each do |violation|
-          warn format(
+          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,

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -34,7 +34,7 @@ module SimpleCov
       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 +47,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

data/lib/simplecov/exit_codes.rb

@@ -1,12 +1,24 @@
 # 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
     MINIMUM_COVERAGE = 2
     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
+    # warning logs. `print_errors false` remains the intended opt-out.
+    def self.print_error(message)
+      $stderr.puts message # rubocop:disable Style/StderrPuts
+    end
   end
 end
 

data/lib/simplecov/exit_handling.rb

@@ -56,7 +56,7 @@ module SimpleCov
     def warn_about_deferred_report
       return unless print_errors
 
-      warn SimpleCov::Color.colorize(
+      ExitCodes.print_error SimpleCov::Color.colorize(
         "Skipping SimpleCov report — this process tracked no application code and a newer " \
         "report already exists at #{coverage_path}. This usually means SimpleCov.start ran in a " \
         "parent process (e.g. a Rakefile or Rails' Bundler.require) that shelled out to the test " \
@@ -97,7 +97,7 @@ module SimpleCov
     # @api private
     def exit_and_report_previous_error(exit_status)
       if print_errors
-        warn SimpleCov::Color.colorize(
+        ExitCodes.print_error SimpleCov::Color.colorize(
           "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
           :yellow
         )
@@ -124,7 +124,7 @@ module SimpleCov
       return unless exit_status.positive?
 
       if print_errors
-        warn SimpleCov::Color.colorize(
+        ExitCodes.print_error SimpleCov::Color.colorize(
           "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
         )
       end