simplecov 1.0.2 → 1.1.0

data/lib/simplecov/configuration.rb

@@ -77,27 +77,18 @@ module SimpleCov
 
     #
     # Allows you to configure simplecov in a block instead of
-    # prepending SimpleCov to each config method.
+    # prepending SimpleCov to each config method. Parameterized blocks retain
+    # their caller context and receive this configuration target explicitly.
     #
     def configure(&block)
-      # 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. 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))
-    ensure
-      # @type var block_context: untyped
-      # @type var saved: Hash[Symbol, untyped]?
-      restore_ivars(block_context, saved) if saved
+      raise ArgumentError, "configuration block required" unless block
+
+      if block.parameters.empty?
+        instance_exec(&(_ = block))
+      else
+        yield self
+      end
+      self
     end
 
     #
@@ -113,7 +104,7 @@ module SimpleCov
 
       @at_exit = proc do
         result = SimpleCov.result
-        result.format! if result && SimpleCov.merge_finalization_owner? && SimpleCov.final_result_process?
+        result.format! if result && SimpleCov.merge_finalization_owner?
       end
     end
 
@@ -158,35 +149,14 @@ module SimpleCov
       @project_name = new_name if new_name.is_a?(String)
       @project_name ||= File.basename(root).capitalize.tr("_", " ")
     end
-
-  private
-
-    # Copy instance variables from block_context into self, saving any
-    # of ours that would be clobbered. Returns the saved values for
-    # later restoration.
-    def swap_ivars_from(block_context)
-      saved = {} # : 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)
-        instance_variable_set(ivar, block_context.instance_variable_get(ivar))
-      end
-      saved
-    end
-
-    # Copy instance variables back to block_context and restore our saved values.
-    def restore_ivars(block_context, saved)
-      block_context.instance_variables.each do |ivar|
-        block_context.instance_variable_set(ivar, instance_variable_get(ivar))
-      end
-      saved.each { |ivar, value| instance_variable_set(ivar, value) }
-    end
   end
 end
 
 require_relative "configuration/coverage"
 require_relative "configuration/coverage_criteria"
+require_relative "configuration/eval_coverage"
 require_relative "configuration/filters"
+require_relative "configuration/groups"
 require_relative "configuration/formatting"
 require_relative "configuration/ignored_entries"
 require_relative "configuration/merging"

data/lib/simplecov/coverage_json.rb

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

data/lib/simplecov/coverage_statistics.rb

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