simplecov 1.0.3 → 1.1.0

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,7 +10,7 @@ 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
 

data/lib/simplecov/coverage_violations.rb

@@ -122,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
@@ -134,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,8 +41,9 @@ 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.to_s
     rescue LoadError, StandardError => e

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

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| ExitCodes.print_error 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,28 +7,15 @@ 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)

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|
-          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
-
       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|
-          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
-
+    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,8 +14,8 @@ 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)
@@ -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

data/lib/simplecov/exit_codes.rb

@@ -22,6 +22,7 @@ module SimpleCov
   end
 end
 
+require_relative "exit_codes/check"
 require_relative "exit_codes/exit_code_handling"
 require_relative "exit_codes/maximum_coverage_drop_check"
 require_relative "exit_codes/maximum_overall_coverage_check"

data/lib/simplecov/exit_handling.rb

@@ -25,50 +25,20 @@ module SimpleCov
       # or a test consumed the result) then don't run exit tasks.
       return unless Coverage.running?
 
-      # Stand down when we'd only clobber a fresher report. See
-      # `defer_to_existing_report?` and issue #581.
-      return if defer_to_existing_report?
-
-      SimpleCov.run_exit_tasks!
-    end
-
-    # Returns true when our process has no coverage data to contribute
-    # (after the resultset merge) and a newer report already exists on
-    # disk. Typically fires when `SimpleCov.start` ran in a parent
-    # process — e.g. a Rakefile or Rails' `Bundler.require` — that
-    # shelled out to the test runner. See issue #581.
-    def defer_to_existing_report?
-      return false unless existing_report_newer_than_us?
-
-      res = result
-      empty = res.nil? || res.files.empty?
-      warn_about_deferred_report if empty
-      empty
-    end
-
-    def existing_report_newer_than_us?
-      return false unless process_start_time
-
-      last_run_path = File.join(coverage_path, ".last_run.json")
-      File.exist?(last_run_path) && File.mtime(last_run_path) > process_start_time
-    end
+      # Capture the suite's exit status BEFORE the deferral probe: its
+      # freshness check rescues filesystem errors, and completing any
+      # rescue inside an at_exit handler resets $ERROR_INFO to nil.
+      error_exit_status = exit_status_from_exception
 
-    def warn_about_deferred_report
-      return unless print_errors
+      # Stand down when we'd only clobber a fresher report (#581).
+      return if defer_to_existing_report?
 
-      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 " \
-        "runner. See https://github.com/simplecov-ruby/simplecov/issues/581.",
-        :yellow
-      )
+      SimpleCov.run_exit_tasks!(error_exit_status)
     end
 
-    # @api private — called from the at_exit block.
-    def run_exit_tasks!
-      error_exit_status = exit_status_from_exception
-
+    # @api private — called from the at_exit block (which pre-captures
+    # the status, see there) and by `collate` (the default argument).
+    def run_exit_tasks!(error_exit_status = exit_status_from_exception)
       at_exit.call
 
       exit_and_report_previous_error(error_exit_status) if previous_error?(error_exit_status)
@@ -113,7 +83,7 @@ module SimpleCov
     # would surface a spurious "below minimum" violation about the
     # missing slice rather than a real shortfall.
     def ready_to_process_results?
-      merge_finalization_owner? && final_result_process? && result? &&
+      merge_finalization_owner? && result? &&
         (collating_result? || parallel_results_complete?)
     end
 

data/lib/simplecov/file_list.rb

@@ -47,15 +47,11 @@ module SimpleCov
 
     # Returns the count of lines that are not relevant for coverage
     def never_lines
-      return 0.0 if empty?
-
       sum { |f| f.never_lines.size }
     end
 
     # Returns the count of skipped lines
     def skipped_lines
-      return 0.0 if empty?
-
       sum { |f| f.skipped_lines.size }
     end
 
@@ -65,13 +61,13 @@ module SimpleCov
       map(&:covered_percent)
     end
 
-    # Finds the least covered file and returns that file's name
+    # Finds the least covered file and returns that file's name, or nil
+    # for an empty list (e.g. a fully filtered result).
     def least_covered_file
       # `covered_percent` is nil only for an unmeasured criterion, and :line
       # is always measured, so the `|| 0.0` arm never fires at runtime; it
-      # (and the cast) exist to satisfy min_by's Comparable requirement.
-      least_covered = min_by { |file| file.covered_percent || 0.0 }
-      (_ = least_covered).filename
+      # exists to satisfy min_by's Comparable requirement.
+      min_by { |file| file.covered_percent || 0.0 }&.filename
     end
 
     # Returns the overall amount of relevant lines of code across all files in this list
@@ -161,8 +157,7 @@ module SimpleCov
     # reported when they pass their own engine-support check.
     def enabled_criteria_for_reporting
       criteria = [] #: Array[SimpleCov::criterion]
-      criteria << :line   if SimpleCov.coverage_criterion_enabled?(:line) ||
-                             SimpleCov.coverage_criterion_enabled?(:oneshot_line)
+      criteria << :line   if SimpleCov.line_coverage?
       criteria << :branch if SimpleCov.branch_coverage?
       criteria << :method if SimpleCov.method_coverage?
       criteria

data/lib/simplecov/filter.rb

@@ -23,10 +23,26 @@ module SimpleCov
       raise NotImplementedError, "The base filter class is not intended for direct use"
     end
 
-    def self.build_filter(filter_argument)
-      return filter_argument if filter_argument.is_a?(SimpleCov::Filter)
+    # Whether this filter's verdict depends only on the file's path, so it can
+    # be decided before that file has any coverage. Used when recording which
+    # tracked files a process did not load, where no coverage exists yet.
+    # Defaults to false so a custom filter is never guessed at. See #1250.
+    def path_only?
+      false
+    end
 
-      class_for_argument(filter_argument).new(filter_argument)
+    # `string_filter` selects the semantics of bare String arguments —
+    # StringFilter's segment-substring match for `add_filter`/`skip`,
+    # GlobFilter for `cover` — and threads through Array elements so a
+    # list gets the same treatment as its members.
+    def self.build_filter(filter_argument, string_filter: SimpleCov::StringFilter)
+      case filter_argument
+      when SimpleCov::Filter then filter_argument
+      when String            then string_filter.new(filter_argument)
+      when Array
+        SimpleCov::ArrayFilter.new(filter_argument.map { |arg| build_filter(arg, string_filter: string_filter) })
+      else class_for_argument(filter_argument).new(filter_argument)
+      end
     end
 
     def self.class_for_argument(filter_argument)
@@ -57,6 +73,10 @@ module SimpleCov
       source_file.project_filename.match?(segment_pattern)
     end
 
+    def path_only?
+      true
+    end
+
   private
 
     def segment_pattern
@@ -68,14 +88,15 @@ module SimpleCov
       escaped    = Regexp.escape(normalized)
       boundary   = '(?:\A|/)'
 
-      if normalized.include?(".")
-        # Filename pattern (e.g. "test.rb" matches "faked_test.rb"): allow
-        # substring match within the last path segment, anchored to a
-        # segment boundary.
-        %r{#{boundary}[^/]*#{escaped}}
-      elsif normalized.end_with?("/")
+      if normalized.end_with?("/")
         # Trailing slash signals directory-only matching.
         /#{boundary}#{escaped}/
+      elsif normalized.include?(".") && !normalized.include?("/")
+        # Bare filename pattern (e.g. "test.rb" matches "faked_test.rb"):
+        # allow a substring match within a single path segment. Multi-segment
+        # arguments must not get this relaxation, or "app/models/user.rb"
+        # would also match "webapp/models/user.rb".
+        %r{#{boundary}[^/]*#{escaped}(?=[/.]|\z)}
       else
         # Directory or path: require a segment-boundary match so "lib"
         # matches "lib/" but not "library/".
@@ -95,6 +116,10 @@ module SimpleCov
     def matches?(source_file)
       filter_argument.match?(source_file.project_filename)
     end
+
+    def path_only?
+      true
+    end
   end
 
   # Filter that matches when the configured block returns truthy for the
@@ -115,6 +140,10 @@ module SimpleCov
     def matches?(source_file)
       File.fnmatch?(filter_argument, source_file.project_filename, File::FNM_PATHNAME | File::FNM_EXTGLOB)
     end
+
+    def path_only?
+      true
+    end
   end
 
   # Filter that matches when any of its component filters (built from the
@@ -128,6 +157,11 @@ module SimpleCov
       super(filter_objects)
     end
 
+    # Path-decidable only when every component filter is.
+    def path_only?
+      filter_argument.all?(&:path_only?)
+    end
+
     # Returns true if any of the filters in the array match the given source file.
     # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
     def matches?(source_files_list)

data/lib/simplecov/formatter/base.rb

@@ -23,6 +23,17 @@ module SimpleCov
 
     private
 
+      # The one home of the "status lines go to stderr, not through warn"
+      # decision (see #1225). stderr rather than stdout because this is a
+      # status message, not the program's output, so it stays out of
+      # pipelines like `rspec -f json`. And `$stderr.puts` rather than
+      # `warn` so the line neither reaches `Warning.warn` hooks (warning
+      # trackers, raise-on-warning test setups) nor vanishes under `-W0`.
+      # Subclasses call this at the end of their `format`.
+      def emit_status(result)
+        $stderr.puts output_message(result) unless @silent # rubocop:disable Style/StderrPuts
+      end
+
       # Subclasses override to prepend a marker (e.g. "JSON ") to the
       # summary line. Default empty for the HTML formatter, which has
       # historically been the unmarked default.