simplecov 0.22.0 → 1.0.2

data/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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
+
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_by_group(@result, @minimum_coverage_by_group)
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -2,6 +2,8 @@
 
 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
@@ -9,18 +11,11 @@ module SimpleCov
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
-          $stderr.printf(
-            "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
-            criterion: violation.fetch(:criterion).capitalize
-          )
-        end
+        violations.each { |violation| report_violation(violation) }
       end
 
       def exit_code
@@ -29,24 +24,46 @@ module SimpleCov
 
     private
 
-      attr_reader :result, :minimum_coverage
+      WORST_FILES_LIMIT = 5
+      private_constant :WORST_FILES_LIMIT
+
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_overall(@result, @minimum_coverage)
+      end
 
-      def minimum_violations
-        @minimum_violations ||= calculate_minimum_violations
+      def report_violation(violation)
+        criterion = violation.fetch(:criterion)
+        actual = violation.fetch(:actual)
+        ExitCodes.print_error format(
+          "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
+          criterion: criterion.capitalize,
+          actual: SimpleCov::Color.colorize_percent(actual),
+          expected: violation.fetch(:expected)
+        )
+        report_worst_files(criterion)
       end
 
-      def calculate_minimum_violations
-        coverage_achieved = minimum_coverage.map do |criterion, percent|
-          {
-            criterion: criterion,
-            minimum_expected: percent,
-            actual: result.coverage_statistics.fetch(criterion).percent
-          }
+      def report_worst_files(criterion)
+        worst = worst_files_for(criterion)
+        return if worst.empty?
+
+        ExitCodes.print_error "  Lowest-coverage files (#{criterion}):"
+        worst.each do |path, percent|
+          ExitCodes.print_error format(
+            "    %<percent>s  %<path>s",
+            percent: SimpleCov::Color.colorize_percent(percent, format("%6.2f%%", percent)),
+            path: path
+          )
         end
+      end
 
-        coverage_achieved.select do |achieved|
-          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+      def worst_files_for(criterion)
+        stats_key = SimpleCov.coverage_statistics_key(criterion)
+        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
+        with_stats.sort_by { |_path, percent| percent }.first(WORST_FILES_LIMIT)
       end
     end
   end

data/lib/simplecov/exit_codes.rb

@@ -1,15 +1,30 @@
 # frozen_string_literal: true
 
 module SimpleCov
+  # Exit statuses SimpleCov sets when coverage checks fail, and the output
+  # helper the enforcement machinery reports through.
   module ExitCodes
     SUCCESS = 0
     EXCEPTION = 1
     MINIMUM_COVERAGE = 2
     MAXIMUM_COVERAGE_DROP = 3
+    MAXIMUM_COVERAGE = 4
+
+    # Threshold-violation reports and exit-status notices are the output of
+    # the enforcement feature, not Ruby warnings: routing them through
+    # `Kernel#warn` made `-W0` swallow the explanation for a failing exit
+    # code, let `Warning.warn` hooks (warning trackers, raise-on-warning
+    # test setups) intercept them mid-`at_exit`, and fed colorized text to
+    # warning logs. `print_errors false` remains the intended opt-out.
+    def self.print_error(message)
+      $stderr.puts message # rubocop:disable Style/StderrPuts
+    end
   end
 end
 
 require_relative "exit_codes/exit_code_handling"
 require_relative "exit_codes/maximum_coverage_drop_check"
+require_relative "exit_codes/maximum_overall_coverage_check"
 require_relative "exit_codes/minimum_coverage_by_file_check"
+require_relative "exit_codes/minimum_coverage_by_group_check"
 require_relative "exit_codes/minimum_overall_coverage_check"

data/lib/simplecov/exit_handling.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "English"
+
+# `at_exit` orchestration: post-suite report generation, threshold
+# checks, deferral when a sibling subprocess already wrote a fresher
+# report, and exit-status propagation.
+module SimpleCov
+  class << self
+    # @api private
+    CoverageLimits = Data.define(
+      :minimum_coverage,
+      :minimum_coverage_by_file,
+      :minimum_coverage_by_file_overrides,
+      :minimum_coverage_by_group,
+      :maximum_coverage,
+      :maximum_coverage_drop
+    )
+
+    def at_exit_behavior
+      # If we are in a different process than called start, don't interfere.
+      return if SimpleCov.pid != Process.pid
+
+      # If Coverage is no longer running (e.g. someone manually stopped it
+      # 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
+
+    def warn_about_deferred_report
+      return unless print_errors
+
+      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
+      )
+    end
+
+    # @api private — called from the at_exit block.
+    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)
+      process_results_and_report_error if ready_to_process_results?
+    end
+
+    # @api private — returns the exit status from the exit exception.
+    def exit_status_from_exception
+      @exit_exception = $ERROR_INFO
+      return nil unless @exit_exception
+
+      if @exit_exception.is_a?(SystemExit)
+        @exit_exception.status
+      else
+        SimpleCov::ExitCodes::EXCEPTION
+      end
+    end
+
+    # @api private — strict boolean so rspec-mocks 4's predicate matcher
+    # accepts it. test_unit sets status 0 on success, so SUCCESS must
+    # also be treated as "not a previous error".
+    def previous_error?(error_exit_status)
+      !!(error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS)
+    end
+
+    # @api private
+    def exit_and_report_previous_error(exit_status)
+      if print_errors
+        ExitCodes.print_error SimpleCov::Color.colorize(
+          "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
+          :yellow
+        )
+      end
+      Kernel.exit(exit_status)
+    end
+
+    # @api private — the process that owns final merge processing is the
+    # only one that reports against thresholds, and only when its
+    # `wait_for_other_processes` confirmed every sibling reported.
+    # When the wait times out, the merged total is partial and
+    # comparing it against `minimum_coverage` / `maximum_coverage`
+    # 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? &&
+        (collating_result? || parallel_results_complete?)
+    end
+
+    def process_results_and_report_error
+      exit_status = process_result(result)
+
+      # Force exit with stored status (see github issue #5)
+      return unless exit_status.positive?
+
+      if print_errors
+        ExitCodes.print_error SimpleCov::Color.colorize(
+          "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
+        )
+      end
+      Kernel.exit exit_status
+    end
+
+    # @api private — `exit_status = SimpleCov.process_result(SimpleCov.result)`.
+    def process_result(result)
+      result_exit_status = result_exit_status(result)
+      write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
+      result_exit_status
+    end
+
+    def result_exit_status(result)
+      ExitCodes::ExitCodeHandling.call(result, coverage_limits: build_coverage_limits)
+    end
+
+  private
+
+    def build_coverage_limits
+      CoverageLimits.new(
+        minimum_coverage: minimum_coverage,
+        minimum_coverage_by_file: minimum_coverage_by_file,
+        minimum_coverage_by_file_overrides: minimum_coverage_by_file_overrides,
+        minimum_coverage_by_group: minimum_coverage_by_group,
+        maximum_coverage: maximum_coverage,
+        maximum_coverage_drop: maximum_coverage_drop
+      )
+    end
+  end
+end

data/lib/simplecov/file_list.rb

@@ -23,8 +23,12 @@ module SimpleCov
       @files = files
     end
 
-    def coverage_statistics
-      @coverage_statistics ||= compute_coverage_statistics
+    # The per-criterion coverage statistics across all files. With no argument
+    # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
+    # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
+    def coverage_statistics(criterion = nil)
+      stats = (@coverage_statistics ||= compute_coverage_statistics)
+      criterion ? stats[criterion] : stats
     end
 
     def coverage_statistics_by_file
@@ -45,14 +49,14 @@ module SimpleCov
     def never_lines
       return 0.0 if empty?
 
-      map { |f| f.never_lines.count }.inject(:+)
+      sum { |f| f.never_lines.size }
     end
 
     # Returns the count of skipped lines
     def skipped_lines
       return 0.0 if empty?
 
-      map { |f| f.skipped_lines.count }.inject(:+)
+      sum { |f| f.skipped_lines.size }
     end
 
     # Computes the coverage based upon lines covered and lines missed for each file
@@ -63,7 +67,11 @@ module SimpleCov
 
     # Finds the least covered file and returns that file's name
     def least_covered_file
-      min_by(&:covered_percent).filename
+      # `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
     end
 
     # Returns the overall amount of relevant lines of code across all files in this list
@@ -71,16 +79,18 @@ module SimpleCov
       coverage_statistics[:line]&.total
     end
 
-    # Computes the coverage based upon lines covered and lines missed
-    # @return [Float]
-    def covered_percent
-      coverage_statistics[:line]&.percent
+    # The coverage across all files in percent, for the given criterion (line
+    # by default). Returns nil if the criterion was not measured.
+    # @return [Float, nil]
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
     end
 
-    # Computes the strength (hits / line) based upon lines covered and lines missed
-    # @return [Float]
-    def covered_strength
-      coverage_statistics[:line]&.strength
+    # The strength (average hits per relevant unit) for the given criterion
+    # (line by default).
+    # @return [Float, nil]
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
     end
 
     # Return total count of branches in all files
@@ -102,19 +112,60 @@ module SimpleCov
       coverage_statistics[:branch]&.percent
     end
 
+    # Return total count of methods in all files
+    def total_methods
+      coverage_statistics[:method]&.total
+    end
+
+    # Return total count of covered methods
+    def covered_methods
+      coverage_statistics[:method]&.covered
+    end
+
+    # Return total count of missed methods
+    def missed_methods
+      coverage_statistics[:method]&.missed
+    end
+
+    def method_covered_percent
+      coverage_statistics[:method]&.percent
+    end
+
   private
 
+    # Seed the result hash with one entry per criterion the user
+    # enabled — so an empty FileList (e.g. a group with no files) still
+    # yields the right shape — then fold each file's stats into the
+    # matching bucket. `SourceFile#coverage_statistics` always reports
+    # all three criteria; FileList is the layer that filters to the
+    # enabled set so disabled criteria don't surface in totals, JSON,
+    # or the HTML report.
     def compute_coverage_statistics_by_file
-      @files.each_with_object(line: [], branch: []) do |file, together|
-        together[:line] << file.coverage_statistics.fetch(:line)
-        together[:branch] << file.coverage_statistics.fetch(:branch) if SimpleCov.branch_coverage?
+      seed = enabled_criteria_for_reporting.to_h do |criterion|
+        bucket = [] #: Array[CoverageStatistics]
+        [criterion, bucket]
+      end
+      @files.each_with_object(seed) do |file, together|
+        file.coverage_statistics.each do |criterion, stats|
+          together[criterion] << stats if together.key?(criterion)
+        end
       end
     end
 
     def compute_coverage_statistics
-      coverage_statistics = {line: CoverageStatistics.from(coverage_statistics_by_file[:line])}
-      coverage_statistics[:branch] = CoverageStatistics.from(coverage_statistics_by_file[:branch]) if SimpleCov.branch_coverage?
-      coverage_statistics
+      coverage_statistics_by_file.transform_values { |stats| CoverageStatistics.from(stats) }
+    end
+
+    # `:line` (or its `:oneshot_line` synonym) is reported when either
+    # criterion is enabled; the JRuby-gated branch/method criteria are
+    # 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 << :branch if SimpleCov.branch_coverage?
+      criteria << :method if SimpleCov.method_coverage?
+      criteria
     end
   end
 end

data/lib/simplecov/filter.rb

@@ -3,11 +3,11 @@
 module SimpleCov
   #
   # Base filter class. Inherit from this to create custom filters,
-  # and overwrite the passes?(source_file) instance method
+  # and overwrite the matches?(source_file) instance method
   #
   # # A sample class that rejects all source files.
   # class StupidFilter < SimpleCov::Filter
-  #   def passes?(source_file)
+  #   def matches?(source_file)
   #     false
   #   end
   # end
@@ -20,12 +20,7 @@ module SimpleCov
     end
 
     def matches?(_source_file)
-      raise "The base filter class is not intended for direct use"
-    end
-
-    def passes?(source_file)
-      warn "#{Kernel.caller.first}: [DEPRECATION] #passes? is deprecated. Use #matches? instead."
-      matches?(source_file)
+      raise NotImplementedError, "The base filter class is not intended for direct use"
     end
 
     def self.build_filter(filter_argument)
@@ -35,37 +30,75 @@ module SimpleCov
     end
 
     def self.class_for_argument(filter_argument)
-      case filter_argument
-      when String
-        SimpleCov::StringFilter
-      when Regexp
-        SimpleCov::RegexFilter
-      when Array
-        SimpleCov::ArrayFilter
-      when Proc
-        SimpleCov::BlockFilter
-      else
-        raise ArgumentError, "You have provided an unrecognized filter type"
-      end
+      filter_classes_by_argument_type.find { |type, _| filter_argument.is_a?(type) }&.last ||
+        raise(SimpleCov::ConfigurationError, "You have provided an unrecognized filter type")
     end
+
+    def self.filter_classes_by_argument_type
+      @filter_classes_by_argument_type ||= {
+        String => SimpleCov::StringFilter,
+        Regexp => SimpleCov::RegexFilter,
+        Array => SimpleCov::ArrayFilter,
+        Proc => SimpleCov::BlockFilter
+      }.freeze
+    end
+    private_class_method :filter_classes_by_argument_type
   end
 
+  # Filter that matches when the source file's project path contains the
+  # configured string at a path-segment boundary.
   class StringFilter < SimpleCov::Filter
     # Returns true when the given source file's filename matches the
-    # string configured when initializing this Filter with StringFilter.new('somestring')
+    # string configured when initializing this Filter with StringFilter.new('somestring').
+    # Matching is path-segment-aware: the argument must appear immediately after a "/"
+    # and be followed by "/" or end-of-string, so "lib" matches "/lib/foo.rb" but not
+    # "/app/models/library.rb".
     def matches?(source_file)
-      source_file.project_filename.include?(filter_argument)
+      source_file.project_filename.match?(segment_pattern)
+    end
+
+  private
+
+    def segment_pattern
+      @segment_pattern ||= compute_segment_pattern
+    end
+
+    def compute_segment_pattern
+      normalized = filter_argument.delete_prefix("/")
+      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?("/")
+        # Trailing slash signals directory-only matching.
+        /#{boundary}#{escaped}/
+      else
+        # Directory or path: require a segment-boundary match so "lib"
+        # matches "lib/" but not "library/".
+        %r{#{boundary}#{escaped}(?=[/.]|\z)}
+      end
     end
   end
 
+  # Filter that matches when the source file's project path matches the
+  # configured Regexp.
   class RegexFilter < SimpleCov::Filter
     # Returns true when the given source file's filename matches the
-    # regex configured when initializing this Filter with RegexFilter.new(/someregex/)
+    # regex configured when initializing this Filter with RegexFilter.new(/someregex/).
+    # Uses `Regexp#match?` so the predicate returns a real boolean — `=~`
+    # would return the match position (an Integer or nil), which trips
+    # rspec-mocks 4's stricter predicate-matcher type check.
     def matches?(source_file)
-      (source_file.project_filename =~ filter_argument)
+      filter_argument.match?(source_file.project_filename)
     end
   end
 
+  # Filter that matches when the configured block returns truthy for the
+  # source file.
   class BlockFilter < SimpleCov::Filter
     # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
     # returns true for the given source file.
@@ -74,6 +107,18 @@ module SimpleCov
     end
   end
 
+  # Filter that matches when the source file's project path matches the
+  # configured shell glob (e.g. "lib/**/*.rb"). Used by `cover` and
+  # `skip` when callers want glob semantics instead of the substring
+  # match of `StringFilter`.
+  class GlobFilter < SimpleCov::Filter
+    def matches?(source_file)
+      File.fnmatch?(filter_argument, source_file.project_filename, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+    end
+  end
+
+  # Filter that matches when any of its component filters (built from the
+  # array's elements) match the source file.
   class ArrayFilter < SimpleCov::Filter
     def initialize(filter_argument)
       filter_objects = filter_argument.map do |arg|