simplecov 0.22.0 → 1.1.1

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative "prism_compat"
+require_relative "condition_folding"
+require_relative "location_conventions"
+require_relative "method_collector"
+require_relative "value_position"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Prism visitor that accumulates branch and method tuples in the
+    # shape Ruby's `Coverage` reports. Tuple ids are sequential across
+    # the file like `Coverage`'s, but the numbering order can differ
+    # (e.g. `case`/`when` and chained `&.` are visited in a different
+    # order than Coverage numbers them). That's fine: the combiners
+    # intern on source span and the report output drops ids, so nothing
+    # downstream compares them. Only defined when Prism is loadable;
+    # `StaticCoverageExtractor.available?` is the runtime gate.
+    class Visitor < ::Prism::Visitor
+      # Method tuples and the class/module nesting that names them are
+      # collected by this mixin; this class focuses on branch extraction.
+      include MethodCollector
+      # Source-range resolution, including the per-Ruby-version Coverage
+      # conventions. See issue #1226.
+      include LocationConventions
+      # Which literal `if`/`unless`/ternary conditions the compiler folds
+      # away (so we emit no branch for them).
+      include ConditionFolding
+
+      attr_reader :branches, :methods
+
+      def initialize
+        super
+        @branches = {}
+        @methods = {}
+        @next_id = 0
+        @class_stack = []
+        @value_positions = nil
+        @suppress_methods = false
+      end
+
+      # Entry point for a parsed file. On legacy Rubies the location of an
+      # empty branch arm depends on whether its construct is in value
+      # (tail) position, so precompute that once for the whole tree before
+      # emitting anything. Modern Rubies don't need it (see
+      # LocationConventions), so the pass is skipped there.
+      def visit_program_node(node)
+        # simplecov:disable branch — legacy-only arm; unreachable on the modern dogfood Ruby
+        @value_positions = ValuePositions.call(node) if LEGACY_COVERAGE_LOCATIONS
+        # simplecov:enable branch
+        super
+      end
+
+      # `if` / `unless` / postfix-if / postfix-unless / ternary all parse
+      # as IfNode (or UnlessNode). Both carry a `then` arm (the
+      # statements body) and an optional `subsequent` (an ElseNode for
+      # `else`, another IfNode for `elsif`). When the subsequent is
+      # missing, Coverage synthesizes a `:else` arm attributed to the
+      # whole condition's range — we do the same.
+      #
+      # A folded condition emits no tuple, and on modern Rubies only its
+      # live arm is descended into: the compiler eliminates the dead
+      # arm's entire subtree, so a branch or method nested there would be
+      # a phantom no loaded run can produce. A falsy `if`'s elsif chain
+      # survives as a plain `if`, which is what visiting the subsequent
+      # IfNode emits. On 3.2 the dead arm is visited too, branches only
+      # (see visit_folded_arms).
+      def visit_if_node(node)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, node.statements, PrismCompat.subsequent(node)) if verdict
+
+        emit_if_like(node, :if)
+        super
+      end
+
+      def visit_unless_node(node)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, PrismCompat.else_clause(node), node.statements) if verdict
+
+        emit_if_like(node, :unless)
+        super
+      end
+
+      def visit_call_node(node)
+        emit_safe_navigation(node) if node.respond_to?(:safe_navigation?) && node.safe_navigation?
+        super
+      end
+
+      # `case`/`when` and `case`/`in` (pattern matching) parse as CaseNode
+      # and CaseMatchNode respectively. When there's no explicit `else`,
+      # Coverage synthesizes one at the case's range.
+      def visit_case_node(node)
+        emit_case_like(node, :when)
+        super
+      end
+
+      def visit_case_match_node(node)
+        emit_case_like(node, :in)
+        super
+      end
+
+      # One-line pattern matching: `x => pattern` (MatchRequiredNode) and
+      # `x in pattern` (MatchPredicateNode). Ruby 3.3's Coverage reports
+      # these as a `:case` with an `:in` and an `:else` arm; 3.4 dropped
+      # them entirely (no branch), so this is legacy-only. The two forms
+      # differ only in where Coverage anchors the synthesized `:else`:
+      # `=>` uses the whole expression, `in` uses just the pattern.
+      # simplecov:disable branch — legacy-only arms; unreachable on the modern dogfood Ruby
+      def visit_match_required_node(node)
+        emit_oneline_pattern(node, node.location) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+
+      def visit_match_predicate_node(node)
+        emit_oneline_pattern(node, node.pattern.location) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+      # simplecov:enable branch
+
+      # `while` / `until` loops get a single `:body` arm. No synthetic
+      # else (the loop either runs the body or doesn't).
+      def visit_while_node(node)
+        emit_loop(node, :while)
+        super
+      end
+
+      def visit_until_node(node)
+        emit_loop(node, :until)
+        super
+      end
+
+    private
+
+      # IfNode and UnlessNode share a shape (predicate + then body +
+      # optional else/elsif) but expose the trailing arm under different
+      # accessors. `if_like_else_location` hides that split.
+      def emit_if_like(node, type)
+        then_loc = if_like_then_location(node, type)
+        else_loc = if_like_else_location(node, type)
+        @branches[build_tuple(type, if_like_location(node, type))] = {
+          build_tuple(:then, then_loc) => 0,
+          build_tuple(:else, else_loc) => 0
+        }
+      end
+
+      def emit_safe_navigation(node)
+        loc = safe_navigation_location(node)
+        @branches[build_tuple(:"&.", loc)] = {
+          build_tuple(:then, loc) => 0,
+          build_tuple(:else, loc) => 0
+        }
+      end
+
+      # simplecov:disable — legacy-only (3.4 emits no branch for one-line patterns)
+      def emit_oneline_pattern(node, else_location)
+        @branches[build_tuple(:case, node.location)] = {
+          build_tuple(:in, node.pattern.location) => 0,
+          build_tuple(:else, else_location) => 0
+        }
+      end
+      # simplecov:enable
+
+      def emit_case_like(node, when_type)
+        arms = node.conditions.to_h do |when_node|
+          [build_tuple(when_type, case_arm_location(node, when_node, when_type)), 0]
+        end
+        arms[build_tuple(:else, else_arm_location(node))] = 0
+        @branches[build_tuple(:case, node.location)] = arms
+      end
+
+      def emit_loop(node, type)
+        cond_tuple = build_tuple(type, node.location)
+        @branches[cond_tuple] = {build_tuple(:body, loop_body_location(node)) => 0}
+      end
+
+      def build_tuple(type, location)
+        id = @next_id
+        @next_id += 1
+        [type, id, location.start_line, location.start_column, location.end_line, location.end_column]
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  # Prism isn't available on this Ruby (older than 3.3 without the gem).
+  # `StaticCoverageExtractor.available?` will return false and callers
+  # fall back to the previous "empty hashes" behavior.
+end
+
+module SimpleCov
+  # Static enumeration of the branches and methods Ruby's `Coverage` library
+  # WOULD have reported if a file had been loaded with `branches: true` /
+  # `methods: true`. Used by `SimulateCoverage` to backfill data for files
+  # added via `cover` / `track_files` that were never `require`'d during the
+  # run — so unloaded files contribute to the branch/method denominators
+  # symmetrically with their line coverage, instead of vanishing from the
+  # totals (see #1059).
+  #
+  # Implementation uses Prism (stdlib in Ruby 3.3+, gem on older Rubies).
+  # When Prism isn't available, `available?` returns false and SimulateCoverage
+  # falls back to the previous behavior — older Rubies keep working, just
+  # without the synthesized data.
+  #
+  # The emitted shape mirrors `Coverage.result[path]` for the same file:
+  # branches are nested as `{condition_tuple => {arm_tuple => 0, ...}}` and
+  # methods as `{["ClassName", :name, lines/cols] => 0}`. Position info
+  # comes from Prism's reported source locations; it doesn't always match
+  # `Coverage`'s byte-for-byte (the two parsers report slightly different
+  # column conventions for some constructs), but lines are reliable and
+  # downstream consumers that key off line numbers (the HTML formatter,
+  # SonarQube, etc.) see the data they expect.
+  module StaticCoverageExtractor
+  module_function
+
+    # simplecov:disable branch
+    # The Prism-unavailable arm of this ternary is unreachable when Prism
+    # itself IS loadable — i.e., on every engine that exercises the dogfood
+    # report. Asserted-on by callers; tested indirectly via the
+    # `available?`-returns-false fallback path in SimulateCoverage's spec.
+    def available?
+      defined?(::Prism) ? true : false
+    end
+    # simplecov:enable branch
+
+    # Parse `source` (a string of Ruby) and return a hash of the form
+    # `{"branches" => {...}, "methods" => {...}}` matching the shape that
+    # `Coverage.result[path]` produces. Returns nil on parse failure or
+    # when Prism isn't available; callers should treat that as "couldn't
+    # extract — fall back to empty hashes."
+    def call(source)
+      # simplecov:disable branch — `then` arm unreachable when Prism IS loadable
+      return nil unless available?
+
+      # simplecov:enable branch
+
+      result = ::Prism.parse(source)
+      return nil if result.failure?
+
+      visitor = Visitor.new
+      visitor.visit(result.value)
+      {"branches" => visitor.branches, "methods" => visitor.methods}
+    rescue StandardError
+      # simplecov:disable line
+      # Parser errors beyond the .failure? check, unsupported AST shapes,
+      # or anything else: fall back to empty hashes rather than crashing
+      # the whole report. Defensive; hard to trigger from a real source
+      # input that Prism accepts at parse time.
+      nil
+      # simplecov:enable line
+    end
+
+    # Summarize a source file's REAL branch and method positions, for the
+    # `:eval_generated` filter (SimpleCov.ignore_branches /
+    # SimpleCov.ignore_methods, #1046). Returns a hash:
+    #
+    #   {
+    #     branches: Set[start_line, ...],         # e.g., [3, 12, 20]
+    #     methods:  Set[[name, start_line], ...]  # e.g., [[:foo, 7], [:bar, 13]]
+    #   }
+    #
+    # Branch matching is start_line-only rather than by the full tuple.
+    # Static extraction and Coverage can still disagree on a branch's exact
+    # column positions (and, for some constructs, its type), so matching on
+    # start_line alone is the conservative choice that tolerates those
+    # differences. Coincidental line-sharing between a real branch and an
+    # eval-generated one will keep both, which is an acceptable
+    # false-negative for an opt-in filter. Method matching uses
+    # (name, start_line) since a method name is unique at any line.
+    #
+    # Returns nil when Prism is unavailable or parsing fails, signaling
+    # callers to keep every Coverage entry (no false drops).
+    def real_source_positions(source)
+      extracted = call(source)
+      return nil unless extracted
+
+      {
+        branches: extracted["branches"].keys.to_set { |tuple| tuple[2] },
+        methods: extracted["methods"].keys.to_set { |tuple| [tuple[1], tuple[2]] }
+      }
+    end
+  end
+end
+
+# simplecov:disable branch
+# The `else` arm (Prism missing) is unreachable on engines where the
+# dogfood report runs; the Visitor class only matters when Prism is
+# loadable.
+require_relative "static_coverage_extractor/visitor" if SimpleCov::StaticCoverageExtractor.available?
+# simplecov:enable branch

data/lib/simplecov/unloaded_file_injector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "simulate_coverage"
+
+module SimpleCov
+  # Fills in coverage for files that were tracked (via `cover` / `track_files`)
+  # but never loaded, so they count toward the denominators instead of being
+  # absent from the report entirely.
+  #
+  # This is the mechanism; the merge-time policy of *when* to inject and
+  # which criteria the simulated files carry lives in
+  # `ResultMerger::UnloadedFiles` — easy names to confuse.
+  #
+  # Everything arrives as arguments rather than being read from the SimpleCov
+  # singleton. The merge step performs this injection on behalf of the processes
+  # that contributed to it, and it does not necessarily share their
+  # configuration: a standalone `collate` never ran `SimpleCov.start`, so it has
+  # no `cover` glob of its own and takes the tracked paths from the resultsets
+  # instead. See #1250.
+  module UnloadedFileInjector
+  module_function
+
+    # Expand `globs` into absolute paths, relative to `root` rather than
+    # `Dir.pwd` — test runners that chdir (or CI scripts that invoke the suite
+    # from a subdirectory) would otherwise silently miss files and produce a
+    # different set per environment. See #1106.
+    # `reject:` are the producing process's path-decidable filters. Paths its
+    # own report would exclude must not be recorded as tracked, or a merge that
+    # does not share the configuration would simulate them back in. Before
+    # injection moved to the merge the producer filtered them out of its own
+    # result and they never reached a resultset. A block filter is handed the
+    # source file and may consult coverage that does not exist yet, so those
+    # still fall to the merging process's filter chain. See #1250.
+    def discover(globs, root:, reject: [])
+      paths = globs.compact
+                   .flat_map { |glob| Dir.glob(glob, base: root) }
+                   .uniq
+                   .map { |path| File.expand_path(path, root) }
+      return paths if reject.empty?
+
+      paths.reject { |path| rejected?(path, reject) }
+    end
+
+    # `SourceFile` reads source and builds lines lazily, so a path-only filter
+    # answers without anything here touching disk.
+    def rejected?(path, filters)
+      candidate = SourceFile.new(path, NO_COVERAGE_YET, loaded: false)
+      filters.any? { |filter| filter.matches?(candidate) }
+    end
+
+    no_coverage_yet = {"lines" => []} #: Hash[String, Array[untyped]]
+    NO_COVERAGE_YET = no_coverage_yet.freeze
+    private_constant :NO_COVERAGE_YET
+
+    # Add simulated coverage for every path `coverage` does not already carry.
+    # Paths that are present are left alone, whoever put them there, which is
+    # what lets this run over resultsets a previous SimpleCov already injected
+    # into without double-counting or overwriting real data.
+    #
+    # Returns the augmented coverage and the set of paths that were added.
+    def call(coverage, paths, synthesize:, lines:)
+      injected = Set.new
+      augmented = coverage.dup
+
+      paths.each do |path|
+        next if augmented.key?(path)
+
+        augmented[path] = SimulateCoverage.call(path, synthesize: synthesize, lines: lines)
+        injected << path
+      end
+
+      [augmented, injected]
+    end
+  end
+end

data/lib/simplecov/useless_results_remover.rb

@@ -1,18 +1,27 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  #
-  # Select the files that related to working scope directory of SimpleCov
-  #
+  # Drop coverage entries whose paths live outside `SimpleCov.root` so the
+  # report only reflects the project's own source. Vendored gems, stdlib
+  # files, and anything else that happens to have been touched during the
+  # run never make it into the formatted result.
   module UselessResultsRemover
     def self.call(coverage_result)
-      coverage_result.select do |path, _coverage|
-        path =~ root_regx
-      end
+      coverage_result.select { |path, _coverage| path.match?(root_regex) }
+    end
+
+    # The `/i` flag covers case-insensitive matches on Windows / macOS-HFS+
+    # where the on-disk path's case can differ from `SimpleCov.root`'s.
+    def self.root_regex
+      root = SimpleCov.root
+      return @root_regex if root == @root_regex_root
+
+      @root_regex_root = root
+      @root_regex = /\A#{Regexp.escape(root.chomp(File::SEPARATOR) + File::SEPARATOR)}/i
     end
 
     def self.root_regx
-      @root_regx ||= /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/i.freeze
+      root_regex
     end
   end
 end

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "0.22.0"
+  VERSION = "1.1.1"
 end

data/lib/simplecov-html.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Backward-compatibility shim: simplecov-html is now part of simplecov.
+require_relative "simplecov/formatter/html_formatter"