simplecov 1.0.0 → 1.1.1

data/lib/simplecov/exit_codes.rb

@@ -1,15 +1,32 @@
 # 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
+    rescue IOError
+      # A parallel runner can close a worker's stderr before its at_exit
+      # hooks run (rspec-conductor does). The violation still has to set
+      # the exit status even when its explanation cannot be printed.
+    end
   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?
 
-      warn 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)
@@ -97,7 +67,7 @@ module SimpleCov
     # @api private
     def exit_and_report_previous_error(exit_status)
       if print_errors
-        warn SimpleCov::Color.colorize(
+        ExitCodes.print_error SimpleCov::Color.colorize(
           "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
           :yellow
         )
@@ -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
 
@@ -124,7 +94,7 @@ module SimpleCov
       return unless exit_status.positive?
 
       if print_errors
-        warn SimpleCov::Color.colorize(
+        ExitCodes.print_error SimpleCov::Color.colorize(
           "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
         )
       end

data/lib/simplecov/file_list.rb

@@ -27,8 +27,8 @@ module SimpleCov
     # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
     # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
     def coverage_statistics(criterion = nil)
-      @coverage_statistics ||= compute_coverage_statistics
-      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+      stats = (@coverage_statistics ||= compute_coverage_statistics)
+      criterion ? stats[criterion] : stats
     end
 
     def coverage_statistics_by_file
@@ -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,9 +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
-      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
+      # 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
@@ -137,7 +137,10 @@ module SimpleCov
     # enabled set so disabled criteria don't surface in totals, JSON,
     # or the HTML report.
     def compute_coverage_statistics_by_file
-      seed = enabled_criteria_for_reporting.to_h { |criterion| [criterion, []] }
+      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)
@@ -153,9 +156,8 @@ module SimpleCov
     # 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 = []
-      criteria << :line   if SimpleCov.coverage_criterion_enabled?(:line) ||
-                             SimpleCov.coverage_criterion_enabled?(:oneshot_line)
+      criteria = [] #: Array[SimpleCov::criterion]
+      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,22 @@ 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
+      rescue IOError
+        # A parallel runner can close a worker's stderr before its at_exit
+        # hooks run (rspec-conductor does). Losing the status line must not
+        # abort the exit tasks that follow report generation, i.e. the
+        # threshold checks and the .last_run.json write.
+      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.
@@ -45,7 +61,8 @@ module SimpleCov
       # confusing than the absolute form. See issue #197.
       def displayable_output_path
         directory = relative_or_absolute_output_path
-        entry_point_filename ? File.join(directory, entry_point_filename) : directory
+        entry_point = entry_point_filename
+        entry_point ? File.join(directory, entry_point) : directory
       end
 
       def relative_or_absolute_output_path

data/lib/simplecov/formatter/coverage_json_writer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "../atomic_file"
+
+module SimpleCov
+  module Formatter
+    # Shared writer for the coverage.json artifact, used by JSONFormatter
+    # (as its report) and HTMLFormatter (as the side file feeding
+    # `simplecov serve` and external tools). Centralizing the write keeps
+    # the two copies byte-identical (same pretty printing, same binary
+    # mode, so no CRLF translation on Windows depending on which
+    # formatter wrote last) and gives both formatters the
+    # concurrent-overwrite warning of issue #1171.
+    module CoverageJSONWriter
+      FILENAME = "coverage.json"
+
+      # The previous report can embed the project's entire source text,
+      # so the overwrite check bounds how much of it is read looking for
+      # the meta object before falling back to a full parse.
+      META_SCAN_BYTES = 64 * 1024
+      private_constant :META_SCAN_BYTES
+
+    module_function
+
+      def write(output_path, hash, result)
+        path = File.join(output_path, FILENAME)
+        warn_if_concurrent_overwrite(path, result)
+        AtomicFile.write(path, JSON.pretty_generate(hash), binary: true)
+        path
+      end
+
+      # Warns when the existing coverage.json has a timestamp newer than this
+      # process's start time — a strong signal that a sibling test process
+      # (e.g., parallel_tests) wrote it while we were running, and that our
+      # write is about to clobber their data.
+      def warn_if_concurrent_overwrite(path, result)
+        start_time = SimpleCov.process_start_time or return
+        existing = existing_meta(path) or return
+        return unless existing[:timestamp] > start_time
+
+        # Both formatters write coverage.json through this method, so when
+        # they are configured together the file found here was just written
+        # by our own run, not a concurrent one. A matching command_name
+        # means the same merged result, so there's nothing to lose by
+        # overwriting. See issue #1171.
+        return if existing[:command_name] == result.command_name
+
+        warn "simplecov: #{path} was written at #{existing[:timestamp].iso8601} — after " \
+             "this process started at #{start_time.iso8601}. Overwriting " \
+             "likely loses coverage data from a concurrent test run. For " \
+             "parallel test setups, use SimpleCov::ResultMerger or run a single " \
+             "collation step after all workers finish."
+      end
+
+      def existing_meta(path)
+        return nil unless File.exist?(path)
+
+        meta = parse_meta(path) or return nil
+        timestamp = meta[:timestamp] or return nil
+
+        {timestamp: Time.iso8601(timestamp), command_name: meta[:command_name]}
+      rescue ArgumentError
+        # An unparseable timestamp disables the check for this file.
+        nil
+      end
+
+      def parse_meta(path)
+        parse_meta_head(path) || parse_meta_full(path)
+      end
+
+      # The meta object is flat and sits at the head of every file this
+      # module writes, so the common case parses just that slice instead
+      # of a multi-megabyte report. A miss (foreign key order, a brace
+      # inside a meta string) falls back to the full parse.
+      def parse_meta_head(path)
+        head = File.read(path, META_SCAN_BYTES).to_s
+        slice = head[/"meta"\s*:\s*(\{.*?\})/m, 1]
+        return nil unless slice
+
+        # The captured slice is always a JSON object, so a successful parse
+        # is always a Hash.
+        JSON.parse(slice, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def parse_meta_full(path)
+        parsed = JSON.parse(File.read(path), symbolize_names: true)
+        parsed.is_a?(Hash) ? parsed[:meta] : nil
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end