simplecov 0.22.0 → 1.0.0.rc2

data/lib/simplecov/source_file.rb

@@ -1,46 +1,64 @@
 # frozen_string_literal: true
 
+require_relative "directive"
+require_relative "static_coverage_extractor"
+require_relative "source_file/ruby_data_parser"
+require_relative "source_file/source_loader"
+require_relative "source_file/skip_chunks"
+require_relative "source_file/builder_context"
+require_relative "source_file/line_builder"
+require_relative "source_file/branch_builder"
+require_relative "source_file/method_builder"
+require_relative "source_file/statistics"
+
 module SimpleCov
   #
   # Representation of a source file including it's coverage data, source code,
   # source lines and featuring helpers to interpret that data.
   #
   class SourceFile
+    include BuilderContext
+
     # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
     attr_reader :filename
     # The array of coverage data received from the Coverage.result
     attr_reader :coverage_data
 
-    def initialize(filename, coverage_data)
+    def initialize(filename, coverage_data, loaded: true)
       @filename = filename
       @coverage_data = coverage_data
+      @loaded = loaded
     end
 
     # The path to this source file relative to the projects directory
     def project_filename
-      @filename.delete_prefix(SimpleCov.root)
+      @filename.delete_prefix(SimpleCov.root).sub(%r{\A[/\\]}, "")
     end
 
-    # The source code for this file. Aliased as :source
+    # The source code for this file. Aliased as :source.
+    # Intentionally read lazily to suppress reading unused source code.
     def src
-      # We intentionally read source code lazily to
-      # suppress reading unused source code.
-      @src ||= load_source
+      @src ||= SourceLoader.call(filename)
     end
     alias source src
 
-    def coverage_statistics
-      @coverage_statistics ||=
-        {
-          **line_coverage_statistics,
-          **branch_coverage_statistics
-        }
+    # Returns a hash keyed by every supported coverage criterion. Each
+    # value is a CoverageStatistics, even for criteria that weren't
+    # enabled during the run — those collapse to 0/0/0. Consumers
+    # (FileList, formatters) decide which keys to surface based on
+    # `SimpleCov.coverage_criterion_enabled?`.
+    # The per-criterion coverage statistics for this file. 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)
+      @coverage_statistics ||= Statistics.new(self).call
+      criterion ? @coverage_statistics[criterion] : @coverage_statistics
     end
 
     # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
     # and thus including coverage data. Aliased as :source_lines
     def lines
-      @lines ||= build_lines
+      @lines ||= LineBuilder.new(self).call
     end
     alias source_lines lines
 
@@ -68,7 +86,7 @@ module SimpleCov
 
     # Returns the number of relevant lines (covered + missed)
     def lines_of_code
-      coverage_statistics[:line]&.total
+      coverage_statistics[:line]&.total || 0
     end
 
     # Access SimpleCov::SourceFile::Line source lines by line number
@@ -76,65 +94,60 @@ module SimpleCov
       lines[number - 1]
     end
 
-    # The coverage for this file in percent. 0 if the file has no coverage lines
-    def covered_percent
-      coverage_statistics[:line]&.percent
+    # The coverage for this file in percent, for the given criterion (line by
+    # default). Returns nil if the criterion was not measured.
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
     end
 
-    def covered_strength
-      coverage_statistics[:line]&.strength
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
     end
 
     def no_lines?
-      lines.length.zero? || (lines.length == never_lines.size)
+      lines.empty? || (lines.length == never_lines.size)
     end
 
     def relevant_lines
       lines.size - never_lines.size - skipped_lines.size
     end
 
-    #
     # Return all the branches inside current source file
     def branches
-      @branches ||= build_branches
+      @branches ||= BranchBuilder.new(self).call
     end
 
     def no_branches?
       total_branches.empty?
     end
 
+    # DEPRECATED: use `covered_percent(:branch)`.
     def branches_coverage_percent
-      coverage_statistics[:branch]&.percent
+      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
+                                  "Use `covered_percent(:branch)`.")
+      covered_percent(:branch)
     end
 
-    #
     # Return the relevant branches to source file
     def total_branches
       @total_branches ||= covered_branches + missed_branches
     end
 
-    #
     # Return hash with key of line number and branch coverage count as value
     def branches_report
-      @branches_report ||= build_branches_report
+      @branches_report ||=
+        branches.reject(&:skipped?).group_by(&:report_line).transform_values { |bs| bs.map(&:report) }
     end
 
-    #
-    # Select the covered branches
-    # Here we user tree schema because some conditions like case may have additional
-    # else that is not in declared inside the code but given by default by coverage report
-    #
-    # @return [Array]
-    #
+    # Select the covered branches. We use a tree schema here because
+    # some conditions like `case` may have an additional `else` that
+    # isn't declared in code but is given by default by the coverage
+    # report.
     def covered_branches
       @covered_branches ||= branches.select(&:covered?)
     end
 
-    #
     # Select the missed branches with coverage equal to zero
-    #
-    # @return [Array]
-    #
     def missed_branches
       @missed_branches ||= branches.select(&:missed?)
     end
@@ -143,213 +156,34 @@ module SimpleCov
       branches_report.fetch(line_number, [])
     end
 
-    #
     # Check if any branches missing on given line number
-    #
-    # @param [Integer] line_number
-    #
-    # @return [Boolean]
-    #
     def line_with_missed_branch?(line_number)
-      branches_for_line(line_number).select { |_type, count| count.zero? }.any?
-    end
-
-  private
-
-    # no_cov_chunks is zero indexed to work directly with the array holding the lines
-    def no_cov_chunks
-      @no_cov_chunks ||= build_no_cov_chunks
-    end
-
-    def build_no_cov_chunks
-      no_cov_lines = src.map.with_index(1).select { |line_src, _index| LinesClassifier.no_cov_line?(line_src) }
-
-      # if we have an uneven number of nocovs we assume they go to the
-      # end of the file, the source doesn't really matter
-      # Can't deal with this within the each_slice due to differing
-      # behavior in JRuby: jruby/jruby#6048
-      no_cov_lines << ["", src.size] if no_cov_lines.size.odd?
-
-      no_cov_lines.each_slice(2).map do |(_line_src_start, index_start), (_line_src_end, index_end)|
-        index_start..index_end
-      end
-    end
-
-    def load_source
-      lines = []
-      # The default encoding is UTF-8
-      File.open(filename, "rb:UTF-8") do |file|
-        current_line = file.gets
-
-        if shebang?(current_line)
-          lines << current_line
-          current_line = file.gets
-        end
-
-        read_lines(file, lines, current_line)
-      end
-    end
-
-    SHEBANG_REGEX = /\A#!/.freeze
-    def shebang?(line)
-      SHEBANG_REGEX.match?(line)
-    end
-
-    def read_lines(file, lines, current_line)
-      return lines unless current_line
-
-      set_encoding_based_on_magic_comment(file, current_line)
-      lines.concat([current_line], ensure_remove_undefs(file.readlines))
-    end
-
-    RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = /\A#\s*(?:-\*-)?\s*(?:en)?coding:\s*(\S+)\s*(?:-\*-)?\s*\z/.freeze
-    def set_encoding_based_on_magic_comment(file, line)
-      # Check for encoding magic comment
-      # Encoding magic comment must be placed at first line except for shebang
-      if (match = RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX.match(line))
-        file.set_encoding(match[1], "UTF-8")
-      end
+      branches_for_line(line_number).any? { |_type, count| count.zero? }
     end
 
-    def ensure_remove_undefs(file_lines)
-      # invalid/undef replace are technically not really necessary but nice to
-      # have and work around a JRuby incompatibility. Also moved here from
-      # simplecov-html to have encoding shenaningans in one place. See #866
-      # also setting these option on `file.set_encoding` doesn't seem to work
-      # properly so it has to be done here.
-      file_lines.each do |line|
-        if line.encoding == Encoding::UTF_8
-          line
-        else
-          line.encode!("UTF-8", invalid: :replace, undef: :replace)
-        end
-      end
+    # Return all methods detected in this source file
+    def methods
+      @methods ||= MethodBuilder.new(self).call
     end
 
-    def build_lines
-      coverage_exceeding_source_warn if coverage_data["lines"].size > src.size
-      lines = src.map.with_index(1) do |src, i|
-        SimpleCov::SourceFile::Line.new(src, i, coverage_data["lines"][i - 1])
-      end
-      process_skipped_lines(lines)
+    def covered_methods
+      @covered_methods ||= methods.select(&:covered?)
     end
 
-    def process_skipped_lines(lines)
-      # the array the lines are kept in is 0-based whereas the line numbers in the nocov
-      # chunks are 1-based and are expected to be like this in other parts (and it's also
-      # arguably more understandable)
-      no_cov_chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
-
-      lines
-    end
-
-    def lines_strength
-      lines.sum { |line| line.coverage.to_i }
-    end
-
-    # Warning to identify condition from Issue #56
-    def coverage_exceeding_source_warn
-      warn "Warning: coverage data provided by Coverage [#{coverage_data['lines'].size}] exceeds number of lines in #{filename} [#{src.size}]"
-    end
-
-    #
-    # Build full branches report
-    # Root branches represent the wrapper of all condition state that
-    # have inside the branches
-    #
-    # @return [Hash]
-    #
-    def build_branches_report
-      branches.reject(&:skipped?).each_with_object({}) do |branch, coverage_statistics|
-        coverage_statistics[branch.report_line] ||= []
-        coverage_statistics[branch.report_line] << branch.report
-      end
-    end
-
-    #
-    # Call recursive method that transform our static hash to array of objects
-    # @return [Array]
-    #
-    def build_branches
-      coverage_branch_data = coverage_data.fetch("branches", {})
-      branches = coverage_branch_data.flat_map do |condition, coverage_branches|
-        build_branches_from(condition, coverage_branches)
-      end
-
-      process_skipped_branches(branches)
-    end
-
-    def process_skipped_branches(branches)
-      return branches if no_cov_chunks.empty?
-
-      branches.each do |branch|
-        branch.skipped! if no_cov_chunks.any? { |no_cov_chunk| branch.overlaps_with?(no_cov_chunk) }
-      end
-
-      branches
-    end
-
-    # Since we are dumping to and loading from JSON, and we have arrays as keys those
-    # don't make their way back to us intact e.g. just as a string
-    #
-    # We should probably do something different here, but as it stands these are
-    # our data structures that we write so eval isn't _too_ bad.
-    #
-    # See #801
-    #
-    def restore_ruby_data_structure(structure)
-      # Tests use the real data structures (except for integration tests) so no need to
-      # put them through here.
-      return structure if structure.is_a?(Array)
-
-      # rubocop:disable Security/Eval
-      eval structure
-      # rubocop:enable Security/Eval
-    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_start_line, * = restore_ruby_data_structure(condition)
-
-      branches.map do |branch_data, hit_count|
-        branch_data = restore_ruby_data_structure(branch_data)
-        build_branch(branch_data, hit_count, condition_start_line)
-      end
-    end
-
-    def build_branch(branch_data, hit_count, condition_start_line)
-      type, _id, start_line, _start_col, end_line, _end_col = branch_data
-
-      SourceFile::Branch.new(
-        start_line: start_line,
-        end_line:   end_line,
-        coverage:   hit_count,
-        inline:     start_line == condition_start_line,
-        type:       type
-      )
+    def missed_methods
+      @missed_methods ||= methods.select(&:missed?)
     end
 
-    def line_coverage_statistics
-      {
-        line: CoverageStatistics.new(
-          total_strength: lines_strength,
-          covered:  covered_lines.size,
-          missed:   missed_lines.size
-        )
-      }
+    # DEPRECATED: use `covered_percent(:method)`.
+    def methods_coverage_percent
+      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
+                                  "Use `covered_percent(:method)`.")
+      covered_percent(:method)
     end
 
-    def branch_coverage_statistics
-      {
-        branch: CoverageStatistics.new(
-          covered: covered_branches.size,
-          missed:  missed_branches.size
-        )
-      }
+    # Whether this file was added via track_files but never loaded/required.
+    def not_loaded?
+      !@loaded
     end
   end
 end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # `Prism::IfNode#subsequent` was renamed from `consequent` in Prism
+    # 1.3 (Dec 2024). Ruby 3.3's stdlib still ships an older Prism that
+    # only exposes `consequent`; 3.4+ and any project that's done
+    # `gem install prism` exposes `subsequent`. Resolve the method name
+    # ONCE here so the per-node hot path stays branch-free. The
+    # not-taken arm on whichever Prism version we're on can't be
+    # exercised by our own dogfood (we only run on one Prism at a time).
+    # simplecov:disable
+    IF_NODE_SUBSEQUENT_METHOD =
+      if ::Prism::IfNode.method_defined?(:subsequent)
+        :subsequent
+      else
+        :consequent
+      end
+    # simplecov:enable
+
+    # Prism visitor that accumulates branch and method tuples in the
+    # shape Ruby's `Coverage` reports. Tuple ids are sequential across
+    # the file — `Coverage` uses sequential ids too, so this matches the
+    # conventional shape. Only defined when Prism is loadable;
+    # `StaticCoverageExtractor.available?` is the runtime gate.
+    class Visitor < ::Prism::Visitor
+      attr_reader :branches, :methods
+
+      def initialize
+        super
+        @branches = {}
+        @methods = {}
+        @next_id = 0
+        @class_stack = []
+      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.
+      def visit_if_node(node)
+        emit_if_like(node)
+        super
+      end
+
+      def visit_unless_node(node)
+        emit_if_like(node)
+        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
+
+      # `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
+
+      # Track class/module nesting so method tuples carry the lexical
+      # class name. Module + Class are both treated as namespaces here
+      # since `Coverage` reports both as the constant.
+      def visit_class_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      def visit_module_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      # `def name(...)` and `def self.name(...)` both produce DefNode.
+      # The class context is the surrounding lexical class/module (or
+      # `Object` at the top level, matching `Coverage`'s convention).
+      def visit_def_node(node)
+        loc = node.location
+        class_name = @class_stack.last || "Object"
+        key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]
+        @methods[key] = 0
+        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)
+        then_loc = arm_location(node.statements, node.location)
+        else_loc = if_like_else_location(node)
+        @branches[build_tuple(:if, node.location)] = {
+          build_tuple(:then, then_loc) => 0,
+          build_tuple(:else, else_loc) => 0
+        }
+      end
+
+      # Resolve the source range Coverage attributes to a real-or-synthetic
+      # `:else` arm of an if-like construct. IfNode uses
+      # `subsequent` / `consequent` depending on Prism version (resolved
+      # to `IF_NODE_SUBSEQUENT_METHOD` at load time); UnlessNode uses
+      # `else_clause`. When neither is present, the synthesized else
+      # inherits the whole condition's range (matches Coverage's
+      # convention).
+      def if_like_else_location(node)
+        sub = node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.else_clause
+        return node.location unless sub
+
+        arm_location(else_body_of(sub), sub.location)
+      end
+
+      def emit_case_like(node, when_type)
+        arms = node.conditions.to_h do |when_node|
+          loc = arm_location(when_node.statements, when_node.location)
+          [build_tuple(when_type, loc), 0]
+        end
+        arms[build_tuple(:else, else_arm_location(node))] = 0
+        @branches[build_tuple(:case, node.location)] = arms
+      end
+
+      # Resolve the source range Coverage attributes to a synthetic-or-real
+      # `:else` arm of a case construct: the body of an explicit else,
+      # or the case's full range when no else is present.
+      def else_arm_location(node)
+        return node.location unless node.else_clause
+
+        arm_location(else_body_of(node.else_clause), node.else_clause.location)
+      end
+
+      def emit_loop(node, type)
+        cond_tuple = build_tuple(type, node.location)
+        body_loc = arm_location(node.statements, node.location)
+        @branches[cond_tuple] = {build_tuple(:body, body_loc) => 0}
+      end
+
+      # Body location for an arm. Prism's `statements` is a StatementsNode
+      # whose span covers the contained expressions; fall back to the
+      # parent when the arm body is empty (e.g., `if cond then end`).
+      def arm_location(statements, fallback_location)
+        statements&.location || fallback_location
+      end
+
+      # simplecov:disable branch
+      # The `else_node` fallback is defensive: every Prism node passed
+      # in here in practice responds to `:statements`.
+      def else_body_of(else_node)
+        else_node.respond_to?(:statements) ? else_node.statements : else_node
+      end
+      # simplecov:enable branch
+
+      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
+
+      # Render a constant path (e.g., `Foo::Bar`) as its source-form
+      # string. Defensive nil / to_s fallbacks: ClassNode and ModuleNode
+      # always carry a constant_path in practice.
+      # simplecov:disable
+      def constant_name(node)
+        return "<anonymous>" if node.nil?
+        return node.slice if node.respond_to?(:slice)
+
+        node.to_s
+      end
+      # simplecov:enable
+
+      def with_class(name)
+        @class_stack.push(name)
+        yield
+      ensure
+        @class_stack.pop
+      end
+    end
+  end
+end