simplecov 0.22.0 → 1.0.0.rc1

data/lib/simplecov/result_merger.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
+require_relative "result_merger/legacy_format_adapter"
+require_relative "result_merger/resultset_file"
+require_relative "result_merger/resultset_store"
 
 module SimpleCov
   #
@@ -10,13 +12,8 @@ module SimpleCov
   #
   module ResultMerger
     class << self
-      # The path to the .resultset.json cache file
       def resultset_path
-        File.join(SimpleCov.coverage_path, ".resultset.json")
-      end
-
-      def resultset_writelock
-        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
+        ResultsetStore.resultset_path
       end
 
       def merge_and_store(*file_paths, ignore_timeout: false)
@@ -44,50 +41,37 @@ module SimpleCov
       end
 
       def valid_results(file_path, ignore_timeout: false)
-        results = parse_file(file_path)
-        merge_valid_results(results, ignore_timeout: ignore_timeout)
-      end
-
-      def parse_file(path)
-        data = read_file(path)
-        parse_json(data)
-      end
-
-      def read_file(path)
-        return unless File.exist?(path)
-
-        data = File.read(path)
-        return if data.nil? || data.length < 2
-
-        data
-      end
-
-      def parse_json(content)
-        return {} unless content
-
-        JSON.parse(content) || {}
-      rescue StandardError
-        warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
-        {}
+        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout)
       end
 
       def merge_valid_results(results, ignore_timeout: false)
-        results = results.select { |_command_name, data| within_merge_timeout?(data) } unless ignore_timeout
+        results = drop_expired_results(results) unless ignore_timeout
 
         command_plus_coverage = results.map do |command_name, data|
-          [[command_name], adapt_result(data.fetch("coverage"))]
+          [[command_name], LegacyFormatAdapter.call(data.fetch("coverage"))]
         end
 
         # one file itself _might_ include multiple test runs
         merge_coverage(*command_plus_coverage)
       end
 
+      def drop_expired_results(results)
+        fresh, expired = results.partition { |_command_name, data| within_merge_timeout?(data) }
+        return results if expired.empty?
+
+        warn_about_expired_results(expired.map(&:first))
+        fresh.to_h
+      end
+
       def within_merge_timeout?(data)
-        time_since_result_creation(data) < SimpleCov.merge_timeout
+        (Time.now - Time.at(data.fetch("timestamp"))) < SimpleCov.merge_timeout
       end
 
-      def time_since_result_creation(data)
-        Time.now - Time.at(data.fetch("timestamp"))
+      def warn_about_expired_results(expired_command_names)
+        warn "[SimpleCov]: Excluded #{expired_command_names.size} result(s) older than " \
+             "merge_timeout (#{SimpleCov.merge_timeout}s) from the merged report: " \
+             "#{expired_command_names.sort.join(', ')}. " \
+             "Increase SimpleCov.merge_timeout to include them."
       end
 
       def create_result(command_names, coverage)
@@ -104,9 +88,7 @@ module SimpleCov
         results.reduce do |(memo_command, memo_coverage), (command, coverage)|
           # timestamp is dropped here, which is intentional (we merge it, it gets a new time stamp as of now)
           merged_coverage = Combine.combine(Combine::ResultsCombiner, memo_coverage, coverage)
-          merged_command = memo_command + command
-
-          [merged_command, merged_coverage]
+          [memo_command + command, merged_coverage]
         end
       end
 
@@ -115,79 +97,53 @@ module SimpleCov
       # SimpleCov::Result with merged coverage data and the command_name
       # for the result consisting of a join on all source result's names
       def merged_result
-        # conceptually this is just doing `merge_results(resultset_path)`
-        # it's more involved to make syre `synchronize_resultset` is only used around reading
-        resultset_hash = read_resultset
-        command_names, coverage = merge_valid_results(resultset_hash)
-
+        command_names, coverage = merge_valid_results(read_resultset)
         create_result(command_names, coverage)
       end
 
       def read_resultset
-        resultset_content =
-          synchronize_resultset do
-            read_file(resultset_path)
-          end
-
-        parse_json(resultset_content)
+        content = synchronize_resultset { ResultsetFile.read(resultset_path) }
+        ResultsetFile.decode(content)
       end
 
       # Saves the given SimpleCov::Result in the resultset cache
-      def store_result(result)
+      def store_result(result) # rubocop:disable Naming/PredicateMethod
         synchronize_resultset do
           # Ensure we have the latest, in case it was already cached
           new_resultset = read_resultset
 
           # A single result only ever has one command_name, see `SimpleCov::Result#to_hash`
           command_name, data = result.to_hash.first
-          new_resultset[command_name] = data
-          File.open(resultset_path, "w+") do |f_|
-            f_.puts JSON.pretty_generate(new_resultset)
-          end
+          new_resultset[command_name] = merged_entry(new_resultset[command_name], data)
+
+          ResultsetStore.write(new_resultset)
         end
         true
       end
 
-      # Ensure only one process is reading or writing the resultset at any
-      # given time
-      def synchronize_resultset
-        # make it reentrant
-        return yield if defined?(@resultset_locked) && @resultset_locked
-
-        begin
-          @resultset_locked = true
-          File.open(resultset_writelock, "w+") do |f|
-            f.flock(File::LOCK_EX)
-            yield
-          end
-        ensure
-          @resultset_locked = false
-        end
-      end
+      # If an entry with the same command_name was written AFTER our process
+      # started, a sibling test runner (typically a subprocess our parent
+      # process shelled out to) wrote it. Combine coverage data rather than
+      # overwriting, so an empty parent-process result doesn't clobber the
+      # subprocess's real data. See https://github.com/simplecov-ruby/simplecov/issues/581.
+      def merged_entry(existing, incoming)
+        return incoming unless concurrent_runner_entry?(existing)
 
-      # We changed the format of the raw result data in simplecov, as people are likely
-      # to have "old" resultsets lying around (but not too old so that they're still
-      # considered we can adapt them).
-      # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
-      def adapt_result(result)
-        if pre_simplecov_0_18_result?(result)
-          adapt_pre_simplecov_0_18_result(result)
-        else
-          result
-        end
+        incoming.merge(
+          "coverage" => Combine.combine(Combine::ResultsCombiner, existing["coverage"], incoming["coverage"])
+        )
       end
 
-      # pre 0.18 coverage data pointed from file directly to an array of line coverage
-      def pre_simplecov_0_18_result?(result)
-        _key, data = result.first
+      def concurrent_runner_entry?(entry)
+        return false unless entry.is_a?(Hash)
 
-        data.is_a?(Array)
+        timestamp = entry["timestamp"]
+        process_start = SimpleCov.process_start_time
+        timestamp && process_start && timestamp.to_i >= process_start.to_i
       end
 
-      def adapt_pre_simplecov_0_18_result(result)
-        result.transform_values do |line_coverage_data|
-          {"lines" => line_coverage_data}
-        end
+      def synchronize_resultset(&)
+        ResultsetStore.synchronize(&)
       end
     end
   end

data/lib/simplecov/result_processing.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Result-building façade: turns the raw `Coverage.result` hash into a
+# `SimpleCov::Result`, applies filters and groups, drives merging
+# across test suites via `SimpleCov::ResultMerger`, and exposes the
+# `collate` entry point for stitching disparate resultsets together.
+module SimpleCov
+  class << self
+    #
+    # Collate a series of SimpleCov result files into a single SimpleCov output.
+    #
+    # See README for usage. By default `collate` ignores the merge_timeout
+    # so all results in all files specified will be merged. Pass
+    # `ignore_timeout: false` to honor it.
+    #
+    def collate(result_filenames, profile = nil, ignore_timeout: true, &block)
+      raise ArgumentError, "There are no reports to be merged" if result_filenames.empty?
+
+      initial_setup(profile, &block)
+
+      # Use the ResultMerger to produce a single, merged result, ready to use.
+      @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
+
+      run_exit_tasks!
+    end
+
+    #
+    # Returns the result for the current coverage run, merging it across test suites
+    # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
+    #
+    def result
+      return @result if result?
+
+      # Collect our coverage result
+      process_coverage_result if defined?(Coverage) && Coverage.running?
+
+      # If we're using merging of results, store the current result
+      # first (if there is one), then merge the results and return those
+      if merging
+        wait_for_other_processes
+        SimpleCov::ResultMerger.store_result(@result) if result?
+        @result = SimpleCov::ResultMerger.merged_result
+      end
+
+      @result
+    end
+
+    # Returns nil if the result has not been computed, otherwise the result.
+    def result?
+      defined?(@result) && @result
+    end
+
+    # Applies the configured filters to the given array of SimpleCov::SourceFile items
+    def filtered(files)
+      result = files.clone
+      filters.each do |filter|
+        result = result.reject { |source_file| filter.matches?(source_file) }
+      end
+      SimpleCov::FileList.new result
+    end
+
+    # Bin the given source files by group filter. `groups:` defaults to
+    # `SimpleCov.groups`; pass a Hash explicitly to bin against a
+    # different group config (e.g., the snapshot a Result captured at
+    # construction). Files matched by no group fall into the implicit
+    # "Ungrouped" bucket.
+    def grouped(files, groups: SimpleCov.groups)
+      return {} if groups.empty?
+
+      grouped = groups.transform_values do |filter|
+        SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
+      end
+
+      in_group  = grouped_file_set(grouped)
+      ungrouped = files.reject { |source_file| in_group.include?(source_file) }
+      grouped["Ungrouped"] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?
+
+      grouped
+    end
+
+    # Applies the profile of given name on SimpleCov configuration
+    def load_profile(name)
+      profiles.load(name)
+    end
+
+    # Clear out the previously cached .result. Primarily useful in testing.
+    def clear_result
+      @result = nil
+    end
+
+    # @api private — persist the per-criterion coverage percentages
+    # rounded down (see #679) so the next run can compute drift.
+    def write_last_run(result)
+      SimpleCov::LastRun.write(
+        result: result.coverage_statistics.transform_values { |stats| round_coverage(stats.percent) }
+      )
+    end
+
+    # @api private — round down to two decimals to be extra strict.
+    def round_coverage(coverage)
+      coverage.floor(2)
+    end
+
+  private
+
+    def initial_setup(profile, &block)
+      load_profile(profile) if profile
+      configure(&block) if block
+    end
+
+    def grouped_file_set(grouped)
+      grouped.values.each_with_object(Set.new) { |file_list, set| set.merge(file_list) }
+    end
+
+    # Finds files that were to be tracked but were not loaded, and
+    # initializes their line-by-line coverage to zero (or nil for
+    # comments / whitespace).
+    def add_not_loaded_files(result)
+      globs = unloaded_file_discovery_globs
+      return [result, Set.new] if globs.empty?
+
+      inject_unloaded_files(result.dup, discover_unloaded_paths(globs))
+    end
+
+    # Globs to expand on disk when injecting unloaded files into the
+    # result. Combines the legacy `track_files` glob (additive only)
+    # with every string glob declared via `cover` (also restrictive,
+    # but the restriction lives in `Result#apply_cover_filters!`).
+    def unloaded_file_discovery_globs
+      [tracked_files, *cover_globs].compact
+    end
+
+    # Expand the given globs relative to SimpleCov.root, not Dir.pwd —
+    # test runners that chdir (or CI scripts that invoke the suite
+    # from a subdir) would otherwise silently miss the unloaded-file
+    # injection and produce a different file set per environment. See
+    # issue #1106.
+    def discover_unloaded_paths(globs)
+      globs.flat_map { |glob| Dir.glob(glob, base: root) }.uniq
+    end
+
+    def inject_unloaded_files(result, candidate_paths)
+      not_loaded_files = candidate_paths.each_with_object(Set.new) do |file, set|
+        absolute_path = File.expand_path(file, root)
+        next if result.key?(absolute_path)
+
+        result[absolute_path] = SimulateCoverage.call(absolute_path)
+        set << absolute_path
+      end
+
+      [result, not_loaded_files]
+    end
+
+    # Run all the steps that handle processing the raw coverage result.
+    def process_coverage_result
+      @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
+      @result = SimpleCov::ResultAdapter.call(@result)
+      result, not_loaded_files = add_not_loaded_files(@result)
+      @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files)
+    end
+  end
+end

data/lib/simplecov/simulate_coverage.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "static_coverage_extractor"
+
 module SimpleCov
   #
   # Responsible for producing file coverage metrics.
@@ -8,22 +10,66 @@ module SimpleCov
   module_function
 
     #
-    # Simulate normal file coverage report on
-    # ruby 2.5 and return similar hash with lines and branches keys
+    # Simulate a file coverage report for a file that was tracked but never
+    # required. Returns the same hash shape as `Coverage.result` (lines,
+    # branches, methods).
+    #
+    # The line classification comes from `Coverage.line_stub` — the same
+    # classification the runtime would have produced if the file had been
+    # required — overlaid with SimpleCov's `# :nocov:` toggles and
+    # `# simplecov:disable line` directive ranges, which `Coverage` doesn't
+    # know about. This keeps "relevant lines" identical whether a file was
+    # loaded or just tracked, fixing the multi-line statement discrepancy
+    # in https://github.com/simplecov-ruby/simplecov/issues/654.
     #
-    # Happens when a file wasn't required but still tracked.
+    # Branches and methods are enumerated by static analysis (via
+    # `StaticCoverageExtractor`, which uses Prism). Earlier behavior left
+    # both as empty hashes, which made unloaded files invisible to the
+    # branch/method denominators while their lines DID count — so a
+    # `track_files`/`cover` glob that picked up files without specs
+    # silently inflated branch% relative to line%. See
+    # https://github.com/simplecov-ruby/simplecov/issues/1059. When Prism
+    # isn't loadable (Ruby < 3.3 without the prism gem) or the file
+    # can't be parsed, fall back to the old empty hashes — old behavior,
+    # old tradeoff.
     #
     # @return [Hash]
     #
     def call(absolute_path)
-      lines = File.foreach(absolute_path)
+      source_lines = read_lines(absolute_path)
+      lines = coverage_stub(absolute_path, source_lines) ||
+              LinesClassifier.new.classify(source_lines)
+      synthesized = StaticCoverageExtractor.call(source_lines.join) ||
+                    {"branches" => {}, "methods" => {}}
 
       {
-        "lines" => LinesClassifier.new.classify(lines),
-        # we don't want to parse branches ourselves...
-        # requiring files can have side effects and we don't want to trigger that
-        "branches" => {}
+        "lines" => lines,
+        "branches" => synthesized["branches"],
+        "methods" => synthesized["methods"]
       }
     end
+
+    def read_lines(path)
+      File.readlines(path)
+    rescue Errno::ENOENT
+      []
+    end
+
+    # Combine `Coverage.line_stub` (which gets multi-line statements right)
+    # with `LinesClassifier` (which knows about `# :nocov:` toggles and
+    # `# simplecov:disable line` ranges). Returns nil — and the caller
+    # falls back to `LinesClassifier` alone — when `Coverage` can't read
+    # or parse the file, or when the runtime doesn't expose `line_stub`
+    # (JRuby and TruffleRuby).
+    def coverage_stub(path, source_lines)
+      return nil unless Coverage.respond_to?(:line_stub)
+
+      stub = Coverage.line_stub(path)
+      classifier_output = LinesClassifier.new.classify(source_lines)
+      stub.each_index { |idx| stub[idx] = nil if classifier_output[idx].nil? }
+      stub
+    rescue Errno::ENOENT, SyntaxError
+      nil
+    end
   end
 end

data/lib/simplecov/source_file/branch.rb

@@ -8,7 +8,6 @@ module SimpleCov
     class Branch
       attr_reader :start_line, :end_line, :coverage, :type
 
-      # rubocop:disable Metrics/ParameterLists
       def initialize(start_line:, end_line:, coverage:, inline:, type:)
         @start_line = start_line
         @end_line   = end_line
@@ -17,7 +16,6 @@ module SimpleCov
         @type       = type
         @skipped    = false
       end
-      # rubocop:enable Metrics/ParameterLists
 
       def inline?
         @inline
@@ -33,7 +31,7 @@ module SimpleCov
       end
 
       #
-      # Check if branche missed or not
+      # Check if branch missed or not
       #
       # @return [Boolean]
       #

data/lib/simplecov/source_file/branch_builder.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Builds the `SourceFile::Branch` objects for a source file from
+    # the raw branch data Ruby's Coverage library reports. Applies the
+    # `ignore_branches :eval_generated` / `:implicit_else` filters and
+    # marks branches inside `# simplecov:disable` / `# :nocov:` chunks
+    # as skipped.
+    class BranchBuilder
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        coverage_branch_data = @source_file.coverage_data["branches"] || {}
+        branches = coverage_branch_data.flat_map do |condition, coverage_branches|
+          next [] if eval_generated_condition_to_ignore?(condition)
+
+          build_branches_from(condition, coverage_branches)
+        end
+
+        process_skipped(branches)
+      end
+
+    private
+
+      # Detect a Coverage-reported branch condition that originates from
+      # `eval`/`module_eval`/`class_eval`/`instance_eval` rather than from
+      # the file's literal source. Coverage attributes such branches to the
+      # caller's `__FILE__`/`__LINE__`, so a Rails `delegate :foo, to: :bar`
+      # call surfaces inside the source file as if there were branches at
+      # the `delegate` line. Prism never sees those branches in the static
+      # source, so a condition whose start_line isn't in the real-source
+      # branch set must be eval-generated. Only consulted when the user has
+      # opted in via `SimpleCov.ignore_branches :eval_generated`. See #1046.
+      def eval_generated_condition_to_ignore?(condition)
+        return false unless SimpleCov.ignored_branch?(:eval_generated)
+
+        positions = @source_file.real_source_positions
+        # simplecov:disable branch — nil branch fires only when Prism is unavailable
+        return false unless positions
+
+        # simplecov:enable branch
+
+        _type, _id, start_line, * = RubyDataParser.call(condition)
+        !positions[:branches].include?(start_line)
+      end
+
+      def build_branches_from(condition, branches)
+        # the format handed in from the coverage data is like this:
+        #
+        #     [:then, 4, 6, 6, 6, 10]
+        #
+        # which is [type, id, start_line, start_col, end_line, end_col]
+        _condition_type, _condition_id, *condition_range = RubyDataParser.call(condition)
+
+        branches.filter_map do |branch_data, hit_count|
+          build_branch(RubyDataParser.call(branch_data), hit_count, condition_range)
+        end
+      end
+
+      def build_branch(branch_data, hit_count, condition_range)
+        type, _id, start_line, start_col, end_line, end_col = branch_data
+        return nil if implicit_else_to_ignore?(type, [start_line, start_col, end_line, end_col], condition_range)
+
+        SourceFile::Branch.new(
+          start_line: start_line,
+          end_line: end_line,
+          coverage: hit_count,
+          inline: start_line == condition_range.first,
+          type: type
+        )
+      end
+
+      # Detect synthetic `:else` branches that Ruby's Coverage library reports
+      # for constructs with no literal `else` keyword in source (`case/in` /
+      # `case/when` without else, `||=`, `&&=`, `if`/`unless` without else,
+      # and the postfix `return if cond` shape). The signal is structural:
+      # a synthetic else reuses its parent condition's *full source range*
+      # (start_line, start_col, end_line, end_col all identical), while an
+      # explicit `else` arm carries a narrower range — its own keyword/body
+      # position rather than the whole conditional. Comparing the full range
+      # (not just `start_line`) is what distinguishes a ternary's explicit
+      # else on the same line as the condition — `arg == 42 ? :yes : :no`,
+      # where the else's columns differ from the parent's — from a postfix
+      # `return if cond` where the synthetic else inherits the full range.
+      # Only consulted when the user has opted in via
+      # `SimpleCov.ignore_branches :implicit_else`. See #1033.
+      def implicit_else_to_ignore?(type, branch_range, condition_range)
+        return false unless type == :else
+        return false unless SimpleCov.ignored_branch?(:implicit_else)
+
+        branch_range == condition_range
+      end
+
+      def process_skipped(branches)
+        chunks = @source_file.skip_chunks_for(:branch)
+        return branches if chunks.empty?
+
+        # A non-inline branch's source range starts on its arm body (e.g. the
+        # `:yes` line of `if cond / :yes / else / :no / end`), but `report_line`
+        # is the condition line above it — that's where the user sees the
+        # branch in the report and where they would naturally place an inline
+        # `# simplecov:disable branch` directive. Honour both.
+        branches.each do |branch|
+          branch.skipped! if chunks.any? { |chunk| branch.overlaps_with?(chunk) || chunk.include?(branch.report_line) }
+        end
+
+        branches
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/builder_context.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Helpers shared by the per-criterion builders (LineBuilder /
+    # BranchBuilder / MethodBuilder). Mixed into SourceFile so each
+    # builder can ask the file for its skip-chunk ranges and Prism-derived
+    # real source positions without duplicating the memoization.
+    module BuilderContext
+      # Skip-chunk lookup for the named criterion (`:line`, `:branch`,
+      # `:method`).
+      def skip_chunks_for(criterion)
+        (@skip_chunks ||= SkipChunks.new(filename, src)).for(criterion)
+      end
+
+      # Memoized set of real source positions (branch start lines, method
+      # name+line pairs) extracted via Prism. Returns nil when Prism is
+      # unavailable or parsing fails, signaling callers to keep every
+      # Coverage entry (no false drops). The `defined?` guard preserves a
+      # nil memoization across calls.
+      def real_source_positions
+        return @real_source_positions if defined?(@real_source_positions)
+
+        @real_source_positions = StaticCoverageExtractor.real_source_positions(src.join)
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/line.rb

@@ -25,7 +25,9 @@ module SimpleCov
       def initialize(src, line_number, coverage)
         raise ArgumentError, "Only String accepted for source" unless src.is_a?(String)
         raise ArgumentError, "Only Integer accepted for line_number" unless line_number.is_a?(Integer)
-        raise ArgumentError, "Only Integer and nil accepted for coverage" unless coverage.is_a?(Integer) || coverage.nil?
+        unless coverage.is_a?(Integer) || coverage.nil?
+          raise ArgumentError, "Only Integer and nil accepted for coverage"
+        end
 
         @src         = src
         @line_number = line_number
@@ -65,7 +67,10 @@ module SimpleCov
         return "skipped" if skipped?
         return "never" if never?
         return "missed" if missed?
-        return "covered" if covered?
+
+        # simplecov:disable — defensive: covered? is the only state left after the three above
+        "covered" if covered?
+        # simplecov:enable
       end
     end
   end