simplecov 0.22.0 → 1.1.1

data/lib/simplecov/coverage_violations.rb

@@ -0,0 +1,159 @@
+# 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 = percent_for(result, criterion) or next
+          {criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      # @return [Array<Hash>] {:criterion, :expected, :actual}
+      # Tolerance: `percent_for` floors the actual percent to two decimal
+      # places (matching the existing minimum-coverage behavior), so an
+      # actual of e.g. 95.4287 is treated as 95.42 — meaning a maximum of
+      # 95.42 still passes. See issue #187 for the rationale.
+      def maximum_overall(result, thresholds)
+        thresholds.filter_map do |criterion, expected|
+          actual = percent_for(result, criterion) or next
+          {criterion: criterion, expected: expected, actual: actual} if actual > expected
+        end
+      end
+
+      # @return [Array<Hash>] {:criterion, :expected, :actual, :filename, :project_filename}
+      #
+      # `defaults` is the criterion-keyed Hash applied to every file.
+      # `overrides` is an ordered Hash<pattern, criterion_thresholds> of per-path
+      # overrides; for each file, defaults are merged with every matching override
+      # (later wins per criterion, overrides win over defaults).
+      def minimum_by_file(result, defaults, overrides = {})
+        result.files.flat_map do |file|
+          effective = effective_per_file_thresholds(file, defaults, overrides)
+          effective.filter_map { |criterion, expected| 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)
+          none = [] # : Array[Hash[Symbol, untyped]]
+          group ? group_minimum_violations(group_name, group, minimums) : none
+        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
+
+      # Look up a criterion's percent on any coverage_statistics-bearing
+      # object (Result, SourceFile, FileList). Returns nil — and the
+      # caller silently skips — when the criterion was configured but not
+      # actually measured by the runtime (e.g. `minimum_coverage branch:
+      # 100` under the "strict" profile on JRuby, where the Coverage
+      # module doesn't emit branch data). The config-time
+      # `raise_if_criterion_disabled` check still catches the genuine
+      # "forgot to enable the criterion" mistake before we ever get here.
+      def percent_for(stats_source, criterion)
+        stats = stats_source.coverage_statistics[SimpleCov.coverage_statistics_key(criterion)]
+        round(stats.percent) if stats
+      end
+
+      # Walk the overrides in declaration order, merging each one that matches
+      # the file's project path into the running effective threshold (so the
+      # most-specific or latest-declared override wins per criterion). Returns
+      # the defaults Hash unchanged when nothing matches.
+      def effective_per_file_thresholds(file, defaults, overrides)
+        return defaults if overrides.empty?
+
+        path = file.project_filename
+        overrides.reduce(defaults) do |acc, (pattern, criterion_thresholds)|
+          path_matches?(path, pattern) ? acc.merge(criterion_thresholds) : acc
+        end
+      end
+
+      # Per-path matching for `minimum_coverage_by_file` overrides. Strings
+      # ending in `/` are treated as directory prefixes; otherwise they must
+      # match `project_filename` exactly. Regexps are tested via `match?`.
+      # The configuration setter rejects anything other than String/Regexp,
+      # so no dead `else` branch is needed here.
+      def path_matches?(project_filename, pattern)
+        return project_filename.match?(pattern) if pattern.is_a?(Regexp)
+        return project_filename.start_with?(pattern) if pattern.end_with?("/")
+
+        project_filename == pattern
+      end
+
+      def file_minimum_violation(file, criterion, expected)
+        actual = percent_for(file, criterion) or return
+        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 = percent_for(group, criterion) or next
+          {group_name: group_name, criterion: criterion, expected: expected, actual: actual} if actual < expected
+        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]
+        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
+
+      def compute_drop(criterion, result, last_run)
+        stats_key = SimpleCov.coverage_statistics_key(criterion)
+        last_coverage_percent = last_run.dig(:result, stats_key)
+        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)
+      end
+
+      def round(percent)
+        SimpleCov.round_coverage(percent)
+      end
+    end
+  end
+end

data/lib/simplecov/defaults.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
-# Load default formatter gem
+require "English"
 require "pathname"
-require_relative "default_formatter"
-require_relative "profiles/root_filter"
-require_relative "profiles/test_frameworks"
-require_relative "profiles/bundler_filter"
-require_relative "profiles/hidden_filter"
-require_relative "profiles/rails"
+require_relative "formatter/html_formatter"
 
-# Default configuration
+# Default configuration. Profiles autoload on first reference via
+# `SimpleCov.profiles.fetch_proc`; the unused ones (e.g. "rails")
+# never get required unless a user opts in.
 SimpleCov.configure do
-  formatter SimpleCov::Formatter::MultiFormatter.new(
-    SimpleCov::Formatter.from_env(ENV)
-  )
+  formatter SimpleCov::Formatter::HTMLFormatter
 
   load_profile "bundler_filter"
   load_profile "hidden_filter"
-  # Exclude files outside of SimpleCov.root
+  # Exclude files outside of SimpleCov.root. Mirrors the early prune done
+  # by SimpleCov::UselessResultsRemover so the user-facing filter chain
+  # honors the same boundary; both share the regex.
   load_profile "root_filter"
+  # Exclude test framework directories (`test/`, `spec/`, `features/`,
+  # `autotest/`). The test suite runs 100% of the test files themselves,
+  # which inflates totals and obscures the application coverage that
+  # actually matters. Drop with `remove_filter %r{\A(test|features|spec|autotest)/}`
+  # if you want test files counted (e.g. to surface dead helpers).
+  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(' ')}"
-
-at_exit do
-  next if SimpleCov.external_at_exit?
-
-  SimpleCov.at_exit_behavior
-end
+SimpleCov::CommandGuesser.original_program_name = $PROGRAM_NAME
 
 # Autoload config from ~/.simplecov if present
 require_relative "load_global_config"
@@ -40,14 +40,25 @@ config_path = Pathname.new(SimpleCov.root)
 loop do
   filename = config_path.join(".simplecov")
   if filename.exist?
-    begin
-      load filename
-    rescue LoadError, StandardError
+    # `.simplecov` is a configuration file; SimpleCov.start calls inside
+    # 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.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: #{$!.message}"
+           "Error message: #{e.message}"
+      # simplecov:enable
     end
     break
   end
+  # simplecov:disable — only fires when no .simplecov is found up to
+  # the filesystem root; simplecov's own dogfood run finds the repo's
+  # .simplecov on the first iteration and breaks before getting here.
   config_path, = config_path.split
   break if config_path.root?
+  # simplecov:enable
 end

data/lib/simplecov/deprecation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Emits legacy-API deprecation warnings, deduplicated by the source
+  # location that triggered them. A deprecated method called in a loop —
+  # or a config block re-evaluated once per parallel worker / spec file —
+  # otherwise repeats the same notice until stderr is unreadable. Keying
+  # on the caller location collapses those repeats to a single line while
+  # still warning separately about each distinct call site the user needs
+  # to fix. See issue #1204.
+  module Deprecation
+  module_function
+
+    # Warn about a deprecated API. `message` is the notice without the
+    # `[DEPRECATION]` tag or location prefix (both are added here).
+    #
+    # `location` defaults to the caller of the deprecated method that
+    # called us — every shipped call site is a one-level alias such as
+    # `track_files`, so the frame two up is the user code. Pass `location:`
+    # explicitly when the relevant site isn't that frame (e.g. a source
+    # file and line discovered while parsing).
+    # `Array(...)` coerces a missing backtrace (nil) to `[]` so `.first`
+    # yields nil rather than raising — and, unlike `&.`, adds no branch for
+    # the unreachable no-caller case to the project's 100% coverage target.
+    def warn(message, location: Array(Kernel.caller(2..2)).first)
+      # Key on location when we have one (collapses a deprecated call in a
+      # loop to a single warning); fall back to the message so a missing
+      # backtrace never silently swallows every notice.
+      return unless emitted.add?(location || message)
+
+      Kernel.warn "#{"#{location}: " if location}[DEPRECATION] #{message}"
+    end
+
+    # Already-emitted dedup keys for this process. Parallel workers are
+    # separate processes with their own set, so each warns at most once.
+    def emitted
+      @emitted ||= Set.new
+    end
+
+    # @api private — reset emitted state between tests.
+    def reset!
+      @emitted = Set.new
+    end
+  end
+end

data/lib/simplecov/directive.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module SimpleCov
+  # Parses `# simplecov:disable` / `# simplecov:enable` directive comments.
+  #
+  # Two forms are supported:
+  #
+  # Block form (the directive is the entire comment on its own line) opens a
+  # region that runs until the matching `# simplecov:enable`:
+  #
+  #   # simplecov:disable line
+  #   ...
+  #   # simplecov:enable line
+  #
+  # Inline form (the directive trails real code on the same line) only affects
+  # that single line and does not need to be re-enabled:
+  #
+  #   raise "absurd" # simplecov:disable
+  #
+  # Categories are `:line`, `:branch`, and `:method`. They may be combined
+  # with commas. Omitting categories targets all three.
+  #
+  # Any text after the directive (and the optional category list) is treated
+  # as a free-form reason and discarded:
+  #
+  #   # simplecov:disable line not worth testing this glue
+  #
+  # As a consequence, an unrecognised category name silently falls into the
+  # reason bucket. `# simplecov:disable cyclomatic` is parsed as the bare
+  # form (disable everything) with reason "cyclomatic" — a deliberate
+  # over-disable so the typo is visible in the report rather than silently
+  # disabling nothing.
+  #
+  # Comment extraction goes through `Ripper.lex` so directive markers inside
+  # string literals or heredocs are correctly ignored.
+  class Directive
+    CATEGORIES = %i[line branch method].freeze
+
+    CATEGORY_PATTERN = "(?:#{CATEGORIES.join('|')})".freeze
+    CATEGORIES_PATTERN = "(?:#{CATEGORY_PATTERN}(?:\\s*,\\s*#{CATEGORY_PATTERN})*)".freeze
+    PATTERN = /
+      \#\s*simplecov\s*:\s*
+      (?<mode>disable|enable)\b
+      (?:\s+(?<categories>#{CATEGORIES_PATTERN})\b)?
+      .*?
+      \s*\z
+    /x
+
+    attr_reader :line_number, :mode, :categories
+
+    # Walk an array of source lines and return the disabled line ranges per
+    # category as `{ line: [Range, ...], branch: [...], method: [...] }`.
+    # 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 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) }
+
+      ranges
+    end
+
+    # Extract every directive in the file, in source order. Comments inside
+    # string literals or heredocs are skipped because Ripper.lex doesn't tag
+    # them as :on_comment tokens.
+    def self.directives_in(lines)
+      return [] unless source_might_contain_directive?(lines)
+
+      comments_in(lines).filter_map do |line_number, column, text|
+        parse_comment(lines, line_number, column, text)
+      end
+    end
+
+    # Cheap pre-check so we don't tokenize files that obviously can't contain
+    # a directive.
+    def self.source_might_contain_directive?(lines)
+      lines.any? do |line|
+        line.include?("simplecov")
+      rescue ArgumentError, EncodingError
+        false # simplecov:disable — defensive guard for invalid byte sequences in source
+      end
+    end
+
+    def self.parse_comment(lines, line_number, column, text)
+      match = PATTERN.match(text)
+      return nil unless match
+
+      new(
+        line_number: line_number,
+        # `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))
+      )
+    rescue ArgumentError, EncodingError
+      # E.g., comment text contains an invalid byte sequence in UTF-8.
+      nil
+    end
+
+    def self.parse_categories(text)
+      return CATEGORIES.dup if text.nil?
+
+      text.split(/\s*,\s*/).map(&:to_sym)
+    end
+
+    # Whether the directive sits after non-whitespace content on its line.
+    # `column` is the byte column of the directive's `#` in the source line,
+    # adjusted for any prefix that may precede it within the comment token
+    # (e.g., `# prefix # simplecov:disable line`).
+    def self.inline?(lines, line_number, column)
+      line = lines[line_number - 1].to_s
+      !line.byteslice(0, column).to_s.strip.empty?
+    rescue ArgumentError, EncodingError
+      false # simplecov:disable — defensive guard for invalid byte sequences
+    end
+
+    def self.comments_in(lines)
+      source = lines.map { |line| line.end_with?("\n") ? line : "#{line}\n" }.join
+      Ripper.lex(source).filter_map do |(line_number, column), type, text|
+        [line_number, column, text] if type == :on_comment
+      end
+    rescue ArgumentError, EncodingError
+      [] # simplecov:disable — Ripper.lex can raise on invalid byte sequences
+    end
+
+    private_class_method :directives_in, :source_might_contain_directive?,
+                         :parse_comment, :parse_categories, :inline?, :comments_in
+
+    def initialize(line_number:, mode:, categories:, inline:)
+      @line_number = line_number
+      @mode        = mode
+      @categories  = categories
+      @inline      = inline
+    end
+
+    def disabled?
+      mode == :disable
+    end
+
+    def inline?
+      @inline
+    end
+
+    # Apply this directive's effect to the in-flight per-category state.
+    # Inline directives mark just their line; block disables open a region;
+    # block enables close one. Re-opening an already-open block is a no-op.
+    def apply(ranges, open_starts)
+      categories.each do |category|
+        if inline?
+          ranges[category] << (line_number..line_number) if disabled?
+        elsif disabled?
+          open_starts[category] ||= line_number
+        elsif (start = open_starts.delete(category))
+          ranges[category] << (start..line_number)
+        end
+      end
+    end
+  end
+end

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/exit_code_handling.rb

@@ -2,6 +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
 
@@ -10,7 +12,7 @@ module SimpleCov
 
         failing_check = checks.find(&:failing?)
         if failing_check
-          failing_check.report
+          failing_check.report if SimpleCov.print_errors
           failing_check.exit_code
         else
           SimpleCov::ExitCodes::SUCCESS
@@ -20,7 +22,11 @@ module SimpleCov
       def coverage_checks(result, coverage_limits)
         [
           MinimumOverallCoverageCheck.new(result, coverage_limits.minimum_coverage),
-          MinimumCoverageByFileCheck.new(result, coverage_limits.minimum_coverage_by_file),
+          MinimumCoverageByFileCheck.new(
+            result, coverage_limits.minimum_coverage_by_file, coverage_limits.minimum_coverage_by_file_overrides
+          ),
+          MinimumCoverageByGroupCheck.new(result, coverage_limits.minimum_coverage_by_group),
+          MaximumOverallCoverageCheck.new(result, coverage_limits.maximum_coverage),
           MaximumCoverageDropCheck.new(result, coverage_limits.maximum_coverage_drop)
         ]
       end

data/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -2,81 +2,34 @@
 
 module SimpleCov
   module ExitCodes
-    class MaximumCoverageDropCheck
-      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?
-      end
-
-      def report
-        coverage_drop_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]
-          )
-        end
-      end
-
+    # 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
       end
 
     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
+      def compute_violations
+        SimpleCov::CoverageViolations.maximum_drop(result, thresholds)
       end
 
-      # if anyone says "max_coverage_drop 0.000000000000000001" I appologize. Please don't.
-      MAX_DROP_ACCURACY = 10
-      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)
+      # 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)
       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 message_for(violation)
+        format(
+          "%<criterion>s coverage has dropped by %<drop_percent>.2f%% since the last time " \
+          "(maximum allowed: %<max_drop>.2f%%).",
+          criterion: violation.fetch(:criterion).capitalize,
+          drop_percent: violation.fetch(:actual),
+          max_drop: violation.fetch(:maximum)
+        )
       end
     end
   end

data/lib/simplecov/exit_codes/maximum_overall_coverage_check.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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
+      end
+
+    private
+
+      def compute_violations
+        SimpleCov::CoverageViolations.maximum_overall(result, thresholds)
+      end
+
+      def report_violation(violation)
+        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,
+          actual: SimpleCov::Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected)
+        )
+      end
+    end
+  end
+end