undercover 0.8.5 → 0.9.0

data/lib/undercover/coverage_root.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Undercover
+  # Coverage reports record paths relative to SimpleCov.root, while a changeset records
+  # them relative to the git repository root. In a monorepo the two differ by a directory
+  # prefix, e.g. coverage says "main.rb" where git says "apps/dash/main.rb".
+  #
+  # SimpleCov.root is stored in the report, but as an absolute path from whichever machine
+  # ran the tests, which need not exist where undercover runs. Its tail still names the
+  # directory though, so match the longest tail that exists in the repository.
+  module CoverageRoot
+    NONE = ''
+
+    # Coverage keys checked when confirming a candidate. A handful is enough to tell a
+    # real match from a directory that merely shares a name.
+    SAMPLE_SIZE = 20
+
+    # @param git_root [String] absolute path to the repository working directory
+    # @param simplecov_root [String, nil] SimpleCov.root as recorded in the report
+    # @param coverage_keys [Array<String>] paths relative to SimpleCov.root, used to
+    #   confirm a candidate actually holds the covered files
+    # @param exists [#call, nil] whether a path relative to git_root exists in the
+    #   repository; checks the disk by default
+    # @return [String] prefix that joins a coverage key onto a repository path,
+    #   NONE when coverage was recorded at the repository root or cannot be placed
+    def self.derive(git_root, simplecov_root, coverage_keys = nil, exists: nil)
+      return NONE if git_root.nil? || simplecov_root.nil? || simplecov_root.empty?
+
+      exists ||= ->(path) { File.exist?(File.join(git_root, path)) }
+      candidates(simplecov_root, exists).find do |prefix|
+        holds_covered_files?(prefix, coverage_keys, exists)
+      end || NONE
+    end
+
+    # @return [String] filepath relative to the coverage root
+    def self.strip(filepath, root)
+      return filepath if root.nil? || root.empty?
+
+      filepath.delete_prefix("#{root}/")
+    end
+
+    # @return [Boolean] whether a repository path lives under the coverage root
+    def self.under?(filepath, root)
+      return true if root.nil? || root.empty?
+
+      filepath.start_with?("#{root}/")
+    end
+
+    # Tails of SimpleCov.root that exist in the repository, longest first. "/build/x/app"
+    # offers "app", then "x/app", then "build/x/app"; the longest that exists wins, so a
+    # nested app beats a directory that happens to share its leaf name.
+    def self.candidates(simplecov_root, exists)
+      parts = Pathname.new(simplecov_root).each_filename.to_a
+      (1..parts.length)
+        .map { |depth| parts.last(depth).join('/') }
+        .select { |prefix| exists.call(prefix) }
+        .sort_by { |prefix| -prefix.length }
+    end
+    private_class_method :candidates
+
+    # Guards against a coincidence: the repository may contain a directory named like
+    # SimpleCov.root's leaf without being the place the coverage came from.
+    def self.holds_covered_files?(prefix, coverage_keys, exists)
+      keys = Array(coverage_keys).reject { |key| key.nil? || key.empty? }
+      return true if keys.empty?
+
+      keys.first(SAMPLE_SIZE).any? { |key| exists.call(File.join(prefix, key)) }
+    end
+    private_class_method :holds_covered_files?
+  end
+end

data/lib/undercover/erb_extractor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'erubi'
+
+module Undercover
+  # Extracts a Ruby string from an ERB template, preserving line positions so
+  # Prism produces a syntax tree whose line numbers map 1:1 back to the
+  # original .erb file.
+  #
+  # Uses erubi (pure Ruby, no native extension).
+  module ErbExtractor
+    # Mirrors ActionView's Erubi handler: `<%= helper do |x| %>` opens a block,
+    # so it must not be wrapped in `( ... ).to_s` like other expressions.
+    class Engine < ::Erubi::Engine
+      BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+      private
+
+      def add_expression(indicator, code)
+        return super unless BLOCK_EXPR.match?(code)
+
+        src << " #{bufvar}.append= " << code
+      end
+    end
+
+    module_function
+
+    def call(erb_source)
+      Engine.new(erb_source, trim: true).src
+    end
+  end
+end

data/lib/undercover/erb_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Undercover
+  # A Ruby construct parsed from an ERB template (if, unless, while, until, case, block)
+  class ErbNode < Node
+    KINDS = %i[block if unless while until case].freeze
+
+    # ErbExtractor keeps the template's line numbers, so nodes print the template's own lines.
+    # partial_script allows a top-level yield, as in a layout.
+    def self.parse(template, file_path)
+      Node.parse(ErbExtractor.call(template), file_path, visitor_class: ErbVisitor,
+                                                         source_lines: template.lines.map(&:chomp),
+                                                         partial_script: true)
+    end
+
+    def human_name
+      "#{kind} block"
+    end
+  end
+end

data/lib/undercover/erb_visitor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Undercover
+  # Also reports the control flow of ERB templates, where whole sections of markup sit in
+  # an if or a loop. An if is one node with its elsif branches.
+  class ErbVisitor < NodeVisitor
+    def visit_if_node(node)
+      add(:if, 'if', node, node.statements) { visit_if_branches(node) }
+    end
+
+    def visit_unless_node(node)
+      add(:unless, 'unless', node, node.statements) { super }
+    end
+
+    def visit_while_node(node)
+      add(:while, 'while', node, node.statements) { super }
+    end
+
+    def visit_until_node(node)
+      add(:until, 'until', node, node.statements) { super }
+    end
+
+    def visit_case_node(node)
+      add(:case, 'case', node, node.conditions) { super }
+    end
+
+    private
+
+    def visit_if_branches(node)
+      node.predicate.accept(self)
+      node.statements&.accept(self)
+      branch = node.subsequent
+      branch.is_a?(Prism::IfNode) ? visit_if_branches(branch) : branch&.accept(self)
+    end
+
+    def build(kind, name, prism_node, empty:)
+      return super unless ErbNode::KINDS.include?(kind)
+
+      ErbNode.new(kind, name, prism_node, @file_path, @source_lines, empty:)
+    end
+  end
+end

data/lib/undercover/file_loader.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Undercover
+  # Parses a changed file into Undercover::Result nodes. ERB templates go through
+  # ErbExtractor first, which turns a template into Ruby with line positions preserved
+  # so the parser can place nodes back onto the original template's line numbers.
+  #
+  # Expects the host to provide #code_dir, #coverage_adapter, #loaded_files and #erb_parse_failures.
+  module FileLoader
+    ERB_EXTENSION = '.erb'
+
+    def load_and_parse_file(filepath)
+      key = filepath.gsub(/^\.\//, '')
+      return if loaded_files.key?(key)
+
+      loaded_files[key] = nil
+      nodes = filepath.end_with?(ERB_EXTENSION) ? load_erb_file(key, filepath) : load_ruby_file(key, filepath)
+      loaded_files[key] = build_results(nodes, filepath) if nodes&.any?
+    end
+
+    private
+
+    def load_erb_file(key, filepath)
+      return unless coverage_adapter.erb_coverage?
+
+      full_path = File.join(code_dir, filepath)
+      return unless File.exist?(full_path)
+
+      all_nodes(ErbNode.parse(File.read(full_path), full_path))
+    rescue StandardError => e
+      erb_parse_failures << key
+      warn "#{key}: ERB parsing failed (#{e.message})"
+    end
+
+    def load_ruby_file(key, filepath)
+      all_nodes(Node.parse_file(File.join(code_dir, filepath)))
+    rescue Node::ParseError => e
+      warn "#{key}: Ruby parsing failed (#{e.message})"
+    end
+
+    def all_nodes(roots)
+      roots.flat_map { _1.find_all(->(_node) { true }) }
+    end
+
+    # Indexes the file's coverage once for all of its nodes
+    def build_results(nodes, filepath)
+      index = CoverageIndex.new(coverage_adapter.coverage(filepath))
+      nodes.map { |node| Result.new(node, coverage_adapter, filepath, coverage_index: index) }
+    end
+  end
+end

data/lib/undercover/filter_set.rb

@@ -2,40 +2,65 @@
 
 module Undercover
   class FilterSet
-    attr_reader :allow_filters, :reject_filters, :simplecov_filters
+    attr_reader :allow_filters, :reject_filters, :simplecov_filters, :coverage_root
 
-    def initialize(allow_filters, reject_filters, simplecov_filters)
+    def initialize(allow_filters, reject_filters, simplecov_filters, coverage_root: CoverageRoot::NONE)
       @allow_filters = allow_filters || []
       @reject_filters = reject_filters || []
       @simplecov_filters = simplecov_filters || []
+      @coverage_root = coverage_root || CoverageRoot::NONE
     end
 
+    # @param filepath[String] path relative to the git repository root
     def include?(filepath)
-      fnmatch = proc { |glob| File.fnmatch(glob, filepath, File::FNM_EXTGLOB) }
+      # Changes outside the coverage root belong to a different project in the same
+      # repository and have no coverage data to judge them by.
+      return false unless CoverageRoot.under?(filepath, coverage_root)
+
+      # Every filter below is written relative to SimpleCov.root, so compare there.
+      relative = CoverageRoot.strip(filepath, coverage_root)
 
       # Check if file was ignored by SimpleCov filters
-      return false if ignored_by_simplecov?(filepath)
+      return false if ignored_by_simplecov?(relative)
 
       # Apply Undercover's own filters
-      allow_filters.any?(fnmatch) && reject_filters.none?(fnmatch)
+      matches_globs?(relative)
+    end
+
+    # A file undercover would otherwise have reported on, dropped only by --include-files
+    # or --exclude-files. Used to tell a misconfigured glob apart from a clean run.
+    # @param filepath[String] path relative to the git repository root
+    def rejected_by_globs?(filepath)
+      return false unless CoverageRoot.under?(filepath, coverage_root)
+
+      relative = CoverageRoot.strip(filepath, coverage_root)
+      return false if ignored_by_simplecov?(relative)
+
+      !matches_globs?(relative)
     end
 
     private
 
+    def matches_globs?(relative)
+      fnmatch = proc { |glob| File.fnmatch(glob, relative, File::FNM_EXTGLOB) }
+      allow_filters.any?(fnmatch) && reject_filters.none?(fnmatch)
+    end
+
     def ignored_by_simplecov?(filepath)
       simplecov_filters.any? do |filter|
         filter = filter.transform_keys(&:to_sym)
         if filter[:string]
-          normalized(filepath).include?(filter[:string])
+          normalize_slash(filepath).include?(filter[:string])
         elsif filter[:regex]
-          normalized(filepath).match?(Regexp.new(filter[:regex]))
+          normalize_slash(filepath).match?(Regexp.new(filter[:regex]))
         elsif filter[:file]
-          filepath == filter[:file] # TODO: check if file also gets a slash?
+          filepath == filter[:file]
         end
       end
     end
 
-    def normalized(filepath)
+    # SimpleCov's 'rails' profile adds regex filters that start with a slash by default. Let's be compatible.
+    def normalize_slash(filepath)
       filepath.start_with?('/') ? filepath : "/#{filepath}"
     end
   end

data/lib/undercover/json_formatter.rb

@@ -63,7 +63,7 @@ module Undercover
     end
 
     def annotated_branches(result) # rubocop:disable Metrics/AbcSize
-      ast_info = AstBranchAnnotator.call(result.node.ast_node)
+      ast_info = AstBranchAnnotator.call(result.node.prism_node)
       counts_per_line = result.branches.each_with_object(Hash.new(0)) { |b, h| h[b[:line]] += 1 }
       result.branches.map do |entry|
         arm = result.branch_label(result.file_path, entry[:branch]) if counts_per_line[entry[:line]] > 1

data/lib/undercover/lcov_parser.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
-require 'undercover/root_to_relative_paths'
+require 'undercover/coverage_root'
 
 module Undercover
   class LcovParseError < StandardError
   end
 
   class LcovParser
-    include RootToRelativePaths
-
     attr_reader :io, :source_files
+    attr_accessor :coverage_root
 
-    def initialize(lcov_io, opts)
+    def initialize(lcov_io, _opts = nil, only_files: nil)
       @io = lcov_io
       @source_files = {}
-      @code_dir = opts&.path
+      @only_files = only_files&.to_set
+      @coverage_root = CoverageRoot::NONE
     end
 
-    def self.parse(lcov_report_path, opts = nil)
-      lcov_io = File.open(lcov_report_path)
-      new(lcov_io, opts).parse
+    def self.parse(lcov_report_path, opts = nil, only_files: nil)
+      File.open(lcov_report_path) do |lcov_io|
+        return new(lcov_io, opts, only_files: only_files).parse
+      end
     end
 
     def parse
@@ -28,11 +29,24 @@ module Undercover
       self
     end
 
+    # @return Array paths relative to SimpleCov.root
+    def coverage_keys
+      source_files.keys
+    end
+
+    # @return Boolean whether the report covers any ERB template, before only_files filtering
+    def erb_coverage?
+      @erb_coverage || false
+    end
+
+    # LCOV carries no SimpleCov.root, so coverage is always taken to sit at the repository
+    # root. Reports covering a subdirectory need the SimpleCov JSON format.
+    def simplecov_root
+      nil
+    end
+
     def coverage(filepath)
-      _filename, coverage = source_files.find do |relative_path, _|
-        relative_path == fix_relative_filepath(filepath)
-      end
-      coverage || []
+      source_files[CoverageRoot.strip(filepath, coverage_root)] || []
     end
 
     def total_coverage
@@ -69,19 +83,25 @@ module Undercover
 
     private
 
-    # rubocop:disable Metrics/MethodLength, Style/SpecialGlobalVars, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity, Style/SpecialGlobalVars, Metrics/AbcSize
     def parse_line(line)
       case line
       when /^SF:(.+)/
-        @current_filename = $~[1].gsub(/^\.\//, '')
-        source_files[@current_filename] = []
+        filename = $~[1].gsub(/^\.\//, '')
+        @erb_coverage ||= filename.end_with?('.erb')
+        @current_filename = @only_files.nil? || @only_files.include?(filename) ? filename : nil
+        source_files[@current_filename] = [] if @current_filename
       when /^DA:(\d+),(\d+)/
+        return unless @current_filename
+
         line_no = $~[1]
         covered = $~[2]
         source_files[@current_filename] << [line_no.to_i, covered.to_i]
       when /^(BRF|BRH):(\d+)/
         # branches found/hit; no-op
       when /^BRDA:(\d+),(\d+),(\d+),(-|\d+)/
+        return unless @current_filename
+
         line_no = $~[1]
         block_no = $~[2]
         branch_no = $~[3]
@@ -94,6 +114,5 @@ module Undercover
         raise LcovParseError, "could not recognise '#{line}' as valid LCOV"
       end
     end
-    # rubocop:enable Metrics/MethodLength, Style/SpecialGlobalVars, Metrics/AbcSize
   end
 end

data/lib/undercover/node.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Undercover
+  # A class, module, method or block parsed from a Ruby file, with the line range
+  # undercover checks coverage for. Blocks span their whole method call, receiver included.
+  class Node
+    class ParseError < StandardError; end
+
+    HUMAN_NAMES = {
+      class: 'class',
+      module: 'module',
+      instance_method: 'instance method',
+      class_method: 'class method',
+      block: 'block'
+    }.freeze
+
+    attr_reader :kind, :name, :prism_node, :file_path, :children
+
+    # @param source_lines [Array<String>] the lines nodes print, when not the parsed source's own
+    # @return [Array<Node>] top-level nodes, each with its nested nodes as children
+    def self.parse(source, file_path, visitor_class: NodeVisitor, source_lines: source.lines.map(&:chomp),
+                   partial_script: false)
+      result = Prism.parse(source, filepath: file_path, partial_script:)
+      if result.failure?
+        error = result.errors.first
+        raise ParseError, "#{error.message} on line #{error.location.start_line}"
+      end
+
+      visitor_class.new(file_path, source_lines).tap { result.value.accept(_1) }.roots
+    end
+
+    def self.parse_file(path)
+      parse(File.read(path), path)
+    end
+
+    def initialize(kind, name, prism_node, file_path, source_lines, empty:) # rubocop:disable Metrics/ParameterLists
+      @kind = kind
+      @name = name
+      @prism_node = prism_node
+      @file_path = file_path
+      @file_lines = source_lines
+      @empty = empty
+      @children = []
+    end
+
+    def human_name
+      HUMAN_NAMES.fetch(kind)
+    end
+
+    def first_line
+      prism_node.location.start_line
+    end
+
+    def last_line
+      prism_node.location.end_line
+    end
+
+    def empty_def?
+      @empty
+    end
+
+    def source_lines
+      @file_lines[(first_line - 1)..(last_line - 1)]
+    end
+
+    def source_lines_with_numbers
+      (first_line..last_line).zip(source_lines)
+    end
+
+    def find_all(matcher, ret = [])
+      ret << self if matcher.call(self)
+      children.each { |child| child.find_all(matcher, ret) }
+      ret
+    end
+  end
+end

data/lib/undercover/node_visitor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Undercover
+  # Builds the Node tree of a Prism syntax tree
+  class NodeVisitor < Prism::Visitor
+    attr_reader :roots
+
+    def initialize(file_path, source_lines)
+      super()
+      @file_path = file_path
+      @source_lines = source_lines
+      @roots = []
+      @parents = []
+    end
+
+    def visit_class_node(node)
+      add(:class, node.name.to_s, node, node.body) { super }
+    end
+
+    def visit_module_node(node)
+      add(:module, node.name.to_s, node, node.body) { super }
+    end
+
+    def visit_def_node(node)
+      add(node.receiver ? :class_method : :instance_method, node.name_loc.slice, node, node.body) { super }
+    end
+
+    def visit_call_node(node)
+      visit_block_call(node) { super }
+    end
+
+    def visit_super_node(node)
+      visit_block_call(node) { super }
+    end
+
+    def visit_forwarding_super_node(node)
+      visit_block_call(node) { super }
+    end
+
+    def visit_lambda_node(node)
+      add(:block, block_name(node.parameters), node, node.body) { super }
+    end
+
+    private
+
+    def visit_block_call(node, &)
+      block = node.block
+      return yield unless block.is_a?(Prism::BlockNode)
+
+      add(:block, block_name(block.parameters), node, block.body, &)
+    end
+
+    def add(kind, name, prism_node, body)
+      new_node = build(kind, name, prism_node, empty: body.nil?)
+      (@parents.last&.children || roots) << new_node
+      @parents.push(new_node)
+      yield
+      @parents.pop
+    end
+
+    def build(kind, name, prism_node, empty:)
+      Node.new(kind, name, prism_node, @file_path, @source_lines, empty:)
+    end
+
+    # Lists explicit parameters only: `it` and numbered parameter blocks are a plain "block"
+    def block_name(parameters)
+      names = parameters.is_a?(Prism::BlockParametersNode) ? parameter_names(parameters) : []
+      names.empty? ? 'block' : "block (#{names.join(', ')})"
+    end
+
+    def parameter_names(block_parameters)
+      [*ordered_parameters(block_parameters.parameters), *block_parameters.locals].map do |param|
+        param.is_a?(Prism::MultiTargetNode) ? param.slice : (param.name if param.respond_to?(:name))
+      end
+    end
+
+    def ordered_parameters(params)
+      return [] unless params
+
+      [*params.requireds, *params.optionals, params.rest, *params.posts, *params.keywords, params.keyword_rest,
+       params.block].compact.grep_v(Prism::ImplicitRestNode)
+    end
+  end
+end