simplecov 1.1.1 → 1.3.0

data/lib/simplecov/defaults.rb

@@ -4,46 +4,27 @@ require "English"
 require "pathname"
 require_relative "formatter/html_formatter"
 
-# 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::HTMLFormatter
 
   load_profile "bundler_filter"
   load_profile "hidden_filter"
-  # 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.
-# 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(' ')}"
+# Stashed as early as possible, before rake or test/unit tamper with ARGV
+# (#110). The program name is kept separately as well: the join 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"
 
-# Autoload config from .simplecov if present
-# Recurse upwards until we find .simplecov or reach the root directory
-
 config_path = Pathname.new(SimpleCov.root)
 loop do
   filename = config_path.join(".simplecov")
   if filename.exist?
-    # `.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

data/lib/simplecov/deprecation.rb

@@ -1,45 +1,63 @@
 # frozen_string_literal: true
 
+require_relative "configuration_error"
+
 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.
+  # 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, otherwise repeats the same
+  # notice until stderr is unreadable. Keying on the caller location collapses
+  # those repeats while still warning separately about each distinct call site
+  # the user needs to fix (#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.
+    extend self
+
+    MODES = %i[warn raise].freeze
+
+    # The mode lives here rather than on the configuration singleton so that
+    # `warn` depends on nothing but itself. `SimpleCov.deprecations` is the
+    # front door that writes it, and the CLI, which loads none of the
+    # configuration surface, can still warn.
+    def mode
+      @mode ||= :warn
+    end
+
+    def mode=(mode)
+      raise ConfigurationError, "deprecations takes :warn or :raise, got #{mode.inspect}" unless MODES.include?(mode)
+
+      @mode = mode
+    end
+
+    # `message` is the notice without the `[DEPRECATION]` tag or location
+    # prefix, both of which are added here. `deprecations :raise` turns every
+    # deprecated API into an error before the dedup: an error is not a notice to
+    # collapse, and a CI guard must fail on the second offender as surely as on
+    # the first. A missing backtrace falls back to keying on the message, so it
+    # never silently swallows every notice.
+    def warn(message, location: caller_location)
+      raise ConfigurationError, message if mode.equal?(:raise)
+
       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.
+    # Every shipped call site is a one-level alias such as `track_files`, so the
+    # frame three up from here is the user's own code. `Array(...)` coerces a
+    # missing backtrace to `[]` so `.first` yields nil rather than raising.
+    def caller_location
+      Array(Kernel.caller(3..3)).first
+    end
+
+    # 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
+      @mode = :warn
     end
   end
 end

data/lib/simplecov/directive/erb.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Directive
+    # The Ruby an ERB template holds, at the template's own line numbers, so
+    # directive comments in a template are found the way they are in a `.rb`
+    # file. Lexing the template itself as Ruby is not an option: `%>` opens a
+    # percent literal that swallows everything up to the next `>`, so comments
+    # after the first tag are never tokenized.
+    #
+    # Text outside the tags is blanked and the tag delimiters become spaces, so
+    # every token keeps its line and column. A comment tag becomes a Ruby
+    # comment, which makes `<%# simplecov:disable %>` the template's own form of
+    # the directive.
+    module Erb
+      SEGMENT = /
+        (?<escaped><%%)
+        | <%(?<kind>\#|==?|-)?(?<body>.*?)(?<close>-?%>)
+        | (?<text>[^<]+|<)
+      /mx
+
+      def self.ruby_lines(lines)
+        source = lines.map { |line| line.end_with?("\n") ? line : "#{line}\n" }.join
+        source.gsub(SEGMENT) { convert(Regexp.last_match) }.lines
+      rescue ArgumentError, EncodingError
+        lines
+      end
+
+      def self.convert(match)
+        body = match[:body]
+        return blank(match[0]) if body.nil?
+        return "  #" + body.gsub("\n", "\n#") + blank(match[:close]) if match[:kind].eql?("#")
+
+        blank("<%" + match[:kind].to_s) + body + blank(match[:close]).sub(" ", ";")
+      end
+
+      def self.blank(text)
+        Template.blank(text)
+      end
+
+      private_class_method :convert, :blank
+    end
+  end
+end

data/lib/simplecov/directive/haml.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "indented_template"
+
+module SimpleCov
+  class Directive
+    # The Ruby a Haml template holds. Script lines (`-`, `=`, and their `!`,
+    # `&`, and `~` variants) and the script a tag outputs keep their Ruby with
+    # the markers blanked, a `-#` comment becomes a Ruby comment, a `:ruby`
+    # filter's lines are Ruby as written, and everything else is blanked.
+    module Haml
+      include IndentedTemplate
+      extend self
+
+      SCRIPT = /\A[!&]?[-=~]/
+      TAG_SCRIPT = /\A[%.#][\w:.#-]*(?:\{[^{}]*\}|\([^()]*\)|\[[^\[\]]*\])*[<>]*[!&]?[=~]/
+
+      def convert(indent, rest)
+        if rest.start_with?("-#")
+          ["#{indent} ##{rest[2..]}", COMMENT]
+        elsif rest.match?(/\A:ruby[ \t]*\n\z/)
+          [Template.blank(indent + rest), RUBY]
+        elsif rest.start_with?(":")
+          [Template.blank(indent + rest), TEXT]
+        elsif (marker = rest[SCRIPT] || rest[TAG_SCRIPT])
+          [indent + Template.blank(marker) + rest[marker.length..]]
+        else
+          [Template.blank(indent + rest)]
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/directive/indented_template.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Directive
+    # The driver the line-oriented template languages share. Each line is
+    # converted on its own unless the line above it opened a block, which the
+    # language decides by answering a continuation alongside the converted
+    # text: `COMMENT` for a comment marker, whose deeper-indented lines
+    # continue the comment, `RUBY` for an embedded Ruby block, whose lines are
+    # Ruby as written, and `TEXT` for any other embedded block, whose lines are
+    # blanked. A blank line neither ends a block nor belongs to it.
+    module IndentedTemplate
+      COMMENT = ->(line) { line.start_with?("\n") ? line : "##{line[1..]}" }
+      RUBY = ->(line) { line }
+      TEXT = ->(line) { Template.blank(line) }
+
+      def ruby_lines(lines)
+        open = nil #: untyped
+        lines.map do |line|
+          line = "#{line}\n" unless line.end_with?("\n")
+          indent = line[/\A[ \t]*/].length
+          rest = line[indent..]
+          if open && (rest.eql?("\n") || indent > open.last)
+            open.first.call(line)
+          else
+            converted = convert(line[0, indent], rest)
+            continuation = converted.at(1)
+            open = continuation && [continuation, indent]
+            converted.fetch(0)
+          end
+        end
+      rescue ArgumentError, EncodingError
+        lines
+      end
+    end
+  end
+end

data/lib/simplecov/directive/slim.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "indented_template"
+
+module SimpleCov
+  class Directive
+    # The Ruby a Slim template holds. Control and output lines (`-`, `=`, `==`,
+    # and their whitespace variants) and the output a bare tag carries keep
+    # their Ruby with the markers blanked, a `/` comment becomes a Ruby
+    # comment, a `ruby:` block's lines are Ruby as written, and everything else
+    # is blanked. A tag with attributes is blanked whole, since `=` inside them
+    # is not the output marker.
+    module Slim
+      include IndentedTemplate
+      extend self
+
+      CODE = /\A(?:-|={1,2}[<>']*)(?=\s)/
+      TAG_CODE = /\A[\w.#-]+\s*={1,2}[<>']*(?=\s)/
+
+      def convert(indent, rest)
+        if rest.start_with?("/")
+          ["#{indent}##{rest[1..]}", COMMENT]
+        elsif rest.match?(/\Aruby:[ \t]*\n\z/)
+          [Template.blank(indent + rest), RUBY]
+        elsif rest.match?(/\A\w+:[ \t]*\n\z/)
+          [Template.blank(indent + rest), TEXT]
+        elsif (marker = rest[CODE] || rest[TAG_CODE])
+          [indent + Template.blank(marker) + rest[marker.length..]]
+        else
+          [Template.blank(indent + rest)]
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/directive/template.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "erb"
+require_relative "haml"
+require_relative "slim"
+
+module SimpleCov
+  class Directive
+    # Hands a template's lines to the extractor for its language, so the
+    # directive scan sees only the Ruby a template holds, at the template's own
+    # line numbers. A file in no template language is Ruby already.
+    module Template
+      EXTRACTORS = {".erb" => Erb, ".haml" => Haml, ".slim" => Slim}.freeze
+
+      def self.template?(filename)
+        EXTRACTORS.key?(File.extname(filename))
+      end
+
+      def self.ruby_lines(filename, lines)
+        extractor = EXTRACTORS[File.extname(filename)]
+        extractor ? extractor.ruby_lines(lines) : lines
+      end
+
+      def self.blank(text)
+        text.gsub(/[^\n]/, " ")
+      end
+    end
+  end
+end

data/lib/simplecov/directive.rb

@@ -1,44 +1,27 @@
 # frozen_string_literal: true
 
 require "ripper"
+require_relative "directive/template"
 
 module SimpleCov
-  # Parses `# simplecov:disable` / `# simplecov:enable` directive comments.
+  # Parses `# simplecov:disable` / `# simplecov:enable` directive comments, in
+  # both the block form (the directive is the entire comment on its own line,
+  # opening a region that runs until the matching enable) and the inline form
+  # (the directive trails real code, affecting that line alone).
   #
-  # 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.
+  # Categories are `:line`, `:branch`, and `:method`, combinable with commas.
+  # Omitting categories targets all three. Any text after the directive is a
+  # free-form reason and is discarded, so an unrecognised category name
+  # silently falls into the reason bucket and disables everything: 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
+    CATEGORY_PATTERN = "(?:#{CATEGORIES.join("|")})".freeze
     CATEGORIES_PATTERN = "(?:#{CATEGORY_PATTERN}(?:\\s*,\\s*#{CATEGORY_PATTERN})*)".freeze
     PATTERN = /
       \#\s*simplecov\s*:\s*
@@ -50,11 +33,9 @@ module SimpleCov
 
     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
+    # The disabled line ranges per category. An unclosed `disable` block
+    # extends to the end of the file.
+    def self.disabled_ranges(lines)
       ranges = CATEGORIES.to_h do |category|
         empty = [] # : Array[Range[Integer]]
         [category, empty]
@@ -62,14 +43,14 @@ module SimpleCov
       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) }
+      open_starts.each { |category, start| ranges.fetch(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.
+    # 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)
 
@@ -78,13 +59,13 @@ module SimpleCov
       end
     end
 
-    # Cheap pre-check so we don't tokenize files that obviously can't contain
-    # a directive.
+    # Cheap pre-check, so files that obviously can't contain a directive are
+    # never tokenized.
     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
+        false
       end
     end
 
@@ -94,72 +75,76 @@ module SimpleCov
 
       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,
+        # The pattern admits exactly two modes, so asking whether this one is
+        # `disable` names the other by elimination. Comparing the captured text
+        # also keeps the nilable capture out of `to_sym`.
+        mode: match[:mode].eql?("disable") ? :disable : :enable,
         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.
+      # The comment text contains an invalid byte sequence, say.
       nil
     end
 
+    # The bare form targets every category, and answers the frozen constant
+    # itself: a directive's categories are only ever iterated.
     def self.parse_categories(text)
-      return CATEGORIES.dup if text.nil?
+      return CATEGORIES 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`).
+    # adjusted for any prefix that may precede it within the comment token.
     def self.inline?(lines, line_number, column)
-      line = lines[line_number - 1].to_s
-      !line.byteslice(0, column).to_s.strip.empty?
+      line = lines.at(line_number - 1).to_s
+      # Indentation is all a non-inline directive may have before it, so
+      # stripping the prefix from the left decides the question. Doing it from
+      # the right instead would raise on a line whose trailing bytes are
+      # invalid, which is a property of the code after the directive.
+      !line.byteslice(0, column).to_s.lstrip.empty?
     rescue ArgumentError, EncodingError
-      false # simplecov:disable — defensive guard for invalid byte sequences
+      false
     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
+        [line_number, column, text] if type.equal?(: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
+      :parse_comment, :parse_categories, :inline?, :comments_in
 
     def initialize(line_number:, mode:, categories:, inline:)
       @line_number = line_number
-      @mode        = mode
-      @categories  = categories
-      @inline      = inline
+      @mode = mode
+      @categories = categories
+      @inline = inline
     end
 
     def disabled?
-      mode == :disable
+      mode.equal?(: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?
+          ranges.fetch(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)
+          ranges.fetch(category) << (start..line_number)
         end
       end
     end

data/lib/simplecov/exit_codes/baseline_check.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    # Fails when a file listed in the checked-in baseline drops below its own
+    # floor on both axes: a lower percent than the floor records and more misses
+    # than it allows. The second condition is the dampener that keeps an edit
+    # with no coverage change from failing the run; a percent-only floor is
+    # decided by the percent alone.
+    class BaselineCheck < Check
+      def initialize(result, baseline)
+        super(result, nil)
+        @baseline = baseline
+      end
+
+      def exit_code
+        MINIMUM_COVERAGE
+      end
+
+      private
+
+      def compute_violations
+        CoverageViolations.baseline(result, @baseline)
+      end
+
+      def violation_lines(violation)
+        message = format(
+          "%<criterion>s coverage (%<actual>s) dropped below its baseline floor (%<expected>s%%) in %<filename>s",
+          criterion: violation.fetch(:criterion).capitalize,
+          actual: Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected),
+          filename: violation.fetch(:project_filename)
+        )
+        ["#{message}#{missed_clause(violation)}."]
+      end
+
+      def missed_clause(violation)
+        allowed = violation.fetch(:allowed_missed)
+        return unless allowed
+
+        units = UNITS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion)))
+        " (#{violation.fetch(:actual_missed)} uncovered #{units}, #{allowed} allowed)"
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/check.rb

@@ -2,11 +2,9 @@
 
 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`.
+    # Shared skeleton for the threshold checks. Subclasses supply `exit_code`,
+    # `compute_violations` (memoized here, since `failing?` and `report_lines`
+    # both consult it), and `violation_lines`.
     class Check
       def initialize(result, thresholds)
         @result = result
@@ -17,17 +15,25 @@ module SimpleCov
         violations.any?
       end
 
+      def violations
+        @violations ||= compute_violations
+      end
+
+      # Concatenated rather than flat-mapped: a check answering a bare string
+      # instead of its list of lines is an error this raises, not a spelling the
+      # flattening would forgive.
+      def report_lines
+        lines = [] #: Array[String]
+        violations.each_with_object(lines) { |violation, into| into.concat(violation_lines(violation)) }
+      end
+
       def report
-        violations.each { |violation| report_violation(violation) }
+        report_lines.each { |line| ExitCodes.print_error(line) }
       end
 
-    private
+      private
 
       attr_reader :result, :thresholds
-
-      def violations
-        @violations ||= compute_violations
-      end
     end
   end
 end