undercover 0.8.4 → 0.9.0

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

data/lib/undercover/options.rb

@@ -32,32 +32,36 @@ module Undercover
     ].freeze
 
     DEFAULT_FILE_INCLUDE_GLOBS = %w[*.rb *.rake *.ru Rakefile].freeze
-    DEFAULT_FILE_EXCLUDE_GLOBS = %w[test/* spec/* db/* config/* *_test.rb *_spec.rb].freeze
+    DEFAULT_FILE_EXCLUDE_GLOBS = %w[test/* spec/* db/* config/* *_test.rb *_spec.rb vendor/*].freeze
+
+    FORMATS = %w[text json].freeze
 
     attr_accessor :lcov,
                   :simplecov_resultset,
                   :path,
                   :git_dir,
                   :compare,
-                  :syntax_version,
+                  :commits_only,
                   :run_mode,
                   :file_scope,
                   :glob_allow_filters,
                   :glob_reject_filters,
-                  :max_warnings_limit
+                  :max_warnings_limit,
+                  :formatter,
+                  :no_hint
 
     def initialize
       @run_mode = DIFF_TRIGGER_LINE
       @file_scope = FILE_SCOPE_EXTENDED
       # set defaults
-      self.path = '.'
       self.git_dir = '.git'
       self.glob_allow_filters = DEFAULT_FILE_INCLUDE_GLOBS
       self.glob_reject_filters = DEFAULT_FILE_EXCLUDE_GLOBS
       self.max_warnings_limit = nil
+      self.formatter = 'text'
     end
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def parse(args)
       args = build_opts(args)
 
@@ -70,10 +74,10 @@ module Undercover
         end
 
         opts.on_tail('--version', 'Show version') do
-          # :nocov:
+          # simplecov:disable
           puts VERSION
           exit
-          # :nocov:
+          # simplecov:enable
         end
 
         lcov_path_option(opts)
@@ -81,16 +85,18 @@ module Undercover
         project_path_option(opts)
         git_dir_option(opts)
         compare_option(opts)
+        commits_only_option(opts)
         ruby_syntax_option(opts)
         max_warnings_limit_option(opts)
         file_filters(opts)
+        format_option(opts)
+        hint_option(opts)
       end.parse(args)
 
       guess_resultset_path unless simplecov_resultset
       guess_lcov_path unless lcov
       self
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     private
 
@@ -138,8 +144,12 @@ module Undercover
       end
     end
 
+    # Deprecated. The project root is now read from the git repository, and paths in the
+    # coverage report are matched onto it without needing to be told where either lives.
+    # Still parsed so that an existing .undercover config file does not fail to load.
     def project_path_option(parser)
-      parser.on('-p', '--path path', 'Project directory') do |path|
+      parser.on('-p', '--path path', 'Deprecated, has no effect') do |path|
+        warn('undercover: --path is deprecated and ignored, it will be removed in a future release')
         self.path = path
       end
     end
@@ -158,11 +168,20 @@ module Undercover
       end
     end
 
+    def commits_only_option(parser)
+      desc = 'Only check committed changes after `--compare ref`, ignoring the index and working tree'
+      parser.on('--commits-only', desc) do
+        self.commits_only = true
+      end
+    end
+
+    # Deprecated. Kept so that a `-r ruby32` line in an existing .undercover file does not fail to load.
     def ruby_syntax_option(parser)
-      versions = Imagen::AVAILABLE_RUBY_VERSIONS.sort.join(', ')
-      desc = "Ruby syntax version, one of: #{versions}"
-      parser.on('-r', '--ruby-syntax ver', desc) do |version|
-        self.syntax_version = version.strip
+      parser.on('-r', '--ruby-syntax ver', 'Deprecated, has no effect') do
+        next if @ruby_syntax_warned
+
+        warn('--ruby-syntax is ignored, undercover parses with Prism; remove it from your config')
+        @ruby_syntax_warned = true
       end
     end
 
@@ -174,13 +193,12 @@ module Undercover
     end
 
     def guess_resultset_path
-      cwd = Pathname.new(File.expand_path(path))
-      try_path = File.join(cwd, 'coverage', 'coverage.json')
+      try_path = File.join(Dir.pwd, 'coverage', 'coverage.json')
       self.simplecov_resultset = try_path if File.exist?(try_path)
     end
 
     def guess_lcov_path
-      cwd = Pathname.new(File.expand_path(path))
+      cwd = Pathname.new(Dir.pwd)
       try_path = File.join(cwd, 'coverage', 'lcov', "#{cwd.split.last}.lcov")
       self.lcov = try_path if File.exist?(try_path)
     end
@@ -192,10 +210,25 @@ module Undercover
         self.glob_allow_filters = split_comma_separated_with_braces(comma_separated_globs)
       end
 
-      desc = 'Skip files matching specified glob patterns (comma separated). Empty by default.'
+      desc = 'Skip files matching specified glob patterns (comma separated). ' \
+             "Defaults to '#{DEFAULT_FILE_EXCLUDE_GLOBS.join(',')}'"
       parser.on('-x', '--exclude-files globs', desc) do |comma_separated_globs|
         self.glob_reject_filters = split_comma_separated_with_braces(comma_separated_globs)
       end
     end
+
+    def format_option(parser)
+      desc = "Output format: #{FORMATS.join(', ')} (default: text)"
+      parser.on('--format FORMAT', FORMATS, desc) do |format|
+        self.formatter = format
+      end
+    end
+
+    def hint_option(parser)
+      desc = 'Hide the one-line hint printed after the text report (or set UNDERCOVER_NO_HINT=1)'
+      parser.on('--no-hint', desc) do
+        self.no_hint = true
+      end
+    end
   end
 end

data/lib/undercover/result.rb

@@ -9,21 +9,14 @@ module Undercover
     attr_reader :node, :coverage, :coverage_adapter, :file_path
 
     def_delegators :node, :first_line, :last_line, :name
-    def_delegators :coverage_adapter, :skipped?
+    def_delegators :coverage_adapter, :skipped?, :branch_label
 
-    def initialize(node, coverage_adapter, file_path) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    # @param coverage_index [CoverageIndex] the file's coverage, shared by all of its nodes
+    def initialize(node, coverage_adapter, file_path, coverage_index: nil)
       @node = node
       @coverage_adapter = coverage_adapter
-      file_cov = coverage_adapter.coverage(file_path)
-      @coverage = file_cov.select do |ln, _|
-        if first_line == last_line
-          ln == first_line
-        elsif node.empty_def? || node.is_a?(Imagen::Node::Block)
-          ln >= first_line && ln <= last_line # rubocop:disable Style/ComparableBetween
-        else
-          ln > first_line && ln < last_line
-        end
-      end
+      coverage_index ||= CoverageIndex.new(coverage_adapter.coverage(file_path))
+      @coverage = coverage_index.within(coverage_lines)
 
       @file_path = file_path
       @flagged = false
@@ -37,24 +30,18 @@ module Undercover
       @flagged
     end
 
-    def uncovered?(line_no) # rubocop:disable Metrics/AbcSize
+    def uncovered?(line_no)
       return false if skipped?(file_path, line_no)
       return true if coverage.empty?
+      return true if uncovered_branch_lines.include?(line_no)
 
-      # check branch coverage for line_no
-      coverage.each do |ln, _block, _branch, cov|
-        return true if ln == line_no && cov && cov != 'ignored' && cov.zero?
-      end
-
-      # check line coverage for line_no
-      line_cov = coverage.select { |cov| cov.size == 2 }.find { |ln, _cov| ln == line_no }
-      line_cov && line_cov[1].zero?
+      line_hits[line_no]&.zero?
     end
 
     # Method `coverage_f` returns the total coverage of this Undercover::Result
     # as a % value, taking into account missing branches. Line coverage will be counted
     # as 0 if any branch is untested.
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
     def coverage_f
       return 0.0 if coverage.empty?
 
@@ -75,7 +62,6 @@ module Undercover
 
       (lines.values.sum.to_f / lines.keys.size).round(4)
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     # TODO: create a formatter interface instead and add some tests.
     # TODO: re-enable rubocops
@@ -105,7 +91,7 @@ module Undercover
           Rainbow(formatted_line).darkgray.dark
         elsif skipped?(file_path, num)
           Rainbow(formatted_line).darkgray.dark +
-            Rainbow(' skipped with :nocov:').italic.darkgray.dark
+            Rainbow(' skipped').italic.darkgray.dark
         elsif covered.nil?
           Rainbow(formatted_line).darkgray.dark +
             Rainbow(' hits: n/a').italic.darkgray.dark +
@@ -123,6 +109,15 @@ module Undercover
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
+    # Returns raw branch coverage entries for this result as structured hashes.
+    # Callers that need human-readable descriptions should use AstBranchAnnotator
+    # separately (e.g. JsonFormatter).
+    def branches
+      coverage.select { |cov| cov.size == 4 }.map do |ln, block_no, branch_no, count|
+        {line: ln, block: block_no, branch: branch_no, count: count}
+      end
+    end
+
     def file_path_with_lines
       "#{file_path}:#{first_line}:#{last_line}"
     end
@@ -135,6 +130,30 @@ module Undercover
 
     private
 
+    def coverage_lines
+      return first_line..first_line if first_line == last_line
+      return first_line..last_line if covers_own_boundaries?
+
+      (first_line + 1)..(last_line - 1)
+    end
+
+    def covers_own_boundaries?
+      node.empty_def? || node.kind == :block || node.is_a?(ErbNode)
+    end
+
+    def uncovered_branch_lines
+      @uncovered_branch_lines ||= coverage.filter_map do |ln, _block, _branch, cov|
+        ln if cov && cov != 'ignored' && cov.zero?
+      end.to_set
+    end
+
+    # first line tuple per line, as a linear search would find it
+    def line_hits
+      @line_hits ||= coverage.each_with_object({}) do |cov, hits|
+        hits[cov[0]] = cov[1] if cov.size == 2 && !hits.key?(cov[0])
+      end
+    end
+
     def count_covered_branches(line_number) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       branches = coverage.select { |cov| cov.size == 4 && cov[0] == line_number }
       count_covered = branches.count do |cov|

data/lib/undercover/simplecov_formatter.rb

@@ -1,34 +1,43 @@
 # frozen_string_literal: true
 
 require 'simplecov'
-require 'simplecov_json_formatter'
+require 'json'
+require 'undercover/version'
+
+# SimpleCov ships its own simplecov_json_formatter.rb shim that can shadow the
+# standalone gem on $LOAD_PATH. Require the gem's classes by subpath (which the
+# shim does not define) so the SimpleCovJSONFormatter::* constants are present.
+require 'simplecov_json_formatter/result_hash_formatter'
+require 'simplecov_json_formatter/result_exporter'
 
 # Patch ResultExporter to allow setting a custom export_path
 module SimpleCovJSONFormatter
   class ResultExporter
     def export_path
-      # :nocov:
+      # simplecov:disable
       File.join(SimpleCov.coverage_path, SimpleCov::Formatter::Undercover.output_filename || FILENAME)
-      # :nocov:
+      # simplecov:enable
     end
   end
 end
 
-module SimpleCov
+module SimpleCov # rubocop:disable Style/OneClassPerFile
   class << self
     attr_accessor :filter_definitions
 
-    alias filtered_uncached filtered
-
-    def filtered(files)
+    # Records the filters undercover needs to reproduce SimpleCov's ignore
+    # decisions. String/regex filters are serialized declaratively; files
+    # dropped by block/array/custom filters (which can't be serialized) are
+    # recorded by their project-relative path.
+    def track_filtered_out(original_files, filtered_files)
       @filter_definitions ||= extract_filter_definitions
-      original_files = files.dup
-      filtered_uncached(files).tap do |filtered_files|
-        filtered_file_paths = (original_files.map(&:filename) - filtered_files.map(&:filename))
-        filtered_file_paths.each do |file|
-          relative_path = file.delete_prefix("#{SimpleCov.root}/")
-          @filter_definitions << {file: relative_path} unless covered_by_serializable_filters?(relative_path)
-        end
+      filtered_file_paths = (original_files.map(&:filename) - filtered_files.map(&:filename))
+      filtered_file_paths.each do |file|
+        relative_path = file.delete_prefix("#{SimpleCov.root}/")
+        next if covered_by_serializable_filters?(relative_path)
+
+        entry = {file: relative_path}
+        @filter_definitions << entry unless @filter_definitions.include?(entry)
       end
     end
 
@@ -50,7 +59,7 @@ module SimpleCov
     end
 
     def covered_by_serializable_filters?(relative_path)
-      @filter_definitions.any? do |filter_def|
+      (@filter_definitions || []).any? do |filter_def|
         if filter_def[:string]
           relative_path.include?(filter_def[:string])
         elsif filter_def[:regex]
@@ -61,7 +70,20 @@ module SimpleCov
   end
 end
 
-module Undercover
+# SimpleCov applies filters inside the private SimpleCov::Result#apply_filters!,
+# so hook that method to populate filter_definitions as files are dropped.
+module Undercover # rubocop:disable Style/OneClassPerFile
+  module SimplecovResultFilterTracking
+    def apply_filters!(_filters)
+      files_before = @files.to_a
+      super
+      SimpleCov.track_filtered_out(files_before, @files)
+    end
+  end
+end
+SimpleCov::Result.prepend(Undercover::SimplecovResultFilterTracking)
+
+module Undercover # rubocop:disable Style/OneClassPerFile
   class ResultHashFormatterWithRoot < SimpleCovJSONFormatter::ResultHashFormatter
     def format
       formatted_result[:meta] = {timestamp: @result.created_at.to_i}
@@ -75,7 +97,7 @@ module Undercover
 
     def add_undercover_meta_fields
       formatted_result.tap do |result|
-        result[:meta].merge!(simplecov_root: SimpleCov.root)
+        result[:meta].merge!(simplecov_root: SimpleCov.root, undercover_version: Undercover::VERSION)
       end
     end
 
@@ -93,11 +115,20 @@ module Undercover
     end
   end
 
-  class UndercoverSimplecovFormatter < SimpleCov::Formatter::JSONFormatter
+  class UndercoverSimplecovFormatter
     class << self
       attr_accessor :output_filename
     end
 
+    # Own #format instead of inheriting SimpleCov::Formatter::JSONFormatter's,
+    # which bypasses #format_result and always writes coverage.json, dropping
+    # undercover's meta and custom filename.
+    def format(result)
+      result_hash = format_result(result)
+      SimpleCovJSONFormatter::ResultExporter.new(result_hash).export
+      result_hash
+    end
+
     def format_result(result)
       result_hash_formater = ResultHashFormatterWithRoot.new(result)
       result_hash_formater.format
@@ -105,7 +136,7 @@ module Undercover
   end
 end
 
-module SimpleCov
+module SimpleCov # rubocop:disable Style/OneClassPerFile
   module Formatter
     Undercover = ::Undercover::UndercoverSimplecovFormatter
   end

data/lib/undercover/simplecov_result_adapter.rb

@@ -1,28 +1,52 @@
 # frozen_string_literal: true
 
-require 'undercover/root_to_relative_paths'
+require 'undercover/coverage_root'
 
 module Undercover
   class SimplecovResultAdapter
-    include RootToRelativePaths
-
-    attr_reader :simplecov_result
+    attr_reader :simplecov_result, :only_files, :coverage_root
 
     # @param file[File] JSON file supplied by SimpleCov::Formatter::Undercover
     # @return SimplecovResultAdapter
-    def self.parse(file, opts = nil)
-      # :nocov:
+    def self.parse(file, opts = nil, only_files: nil)
+      # simplecov:disable
       result_h = JSON.parse(file.read)
       raise ArgumentError, 'empty SimpleCov' if result_h.empty?
 
-      new(result_h, opts)
-      # :nocov:
+      new(result_h, opts, only_files: only_files)
+      # simplecov:enable
     end
 
     # @param simplecov_result[SimpleCov::Result]
-    def initialize(simplecov_result, opts)
+    def initialize(simplecov_result, _opts = nil, only_files: nil)
       @simplecov_result = simplecov_result
-      @code_dir = opts&.path
+      @only_files = only_files
+      @coverage_root = CoverageRoot::NONE
+      @erb_coverage = (simplecov_result['coverage'] || {}).keys.any? { _1.end_with?('.erb') }
+    end
+
+    # @return Boolean whether the report covers any ERB template, which takes
+    #   SimpleCov's eval coverage. Recorded before only_files drops unchanged files.
+    def erb_coverage?
+      @erb_coverage
+    end
+
+    # Filtering waits for the coverage root, since only_files is relative to the repository
+    # while coverage keys are relative to SimpleCov.root.
+    def coverage_root=(root)
+      @coverage_root = root || CoverageRoot::NONE
+      keep_only_files!
+    end
+
+    # @return String SimpleCov.root as recorded when the report was written, an absolute
+    #   path on the machine that ran the tests
+    def simplecov_root
+      simplecov_result.dig('meta', 'simplecov_root')
+    end
+
+    # @return Array paths relative to SimpleCov.root
+    def coverage_keys
+      simplecov_result['coverage'].keys
     end
 
     # @param filepath[String]
@@ -52,6 +76,13 @@ module Undercover
       source_file['lines'][line_no - 1] == 'ignored'
     end
 
+    def branch_label(filepath, branch_no)
+      source_file = find_file(filepath)
+      return nil unless source_file
+
+      source_file['branches']&.dig(branch_no - 1, 'type')
+    end
+
     # unused for now
     def total_coverage; end
     def total_branch_coverage; end
@@ -62,8 +93,15 @@ module Undercover
 
     private
 
+    def keep_only_files!
+      return unless only_files
+
+      wanted = only_files.to_set { |path| CoverageRoot.strip(path, coverage_root) }
+      simplecov_result['coverage'].select! { |path, _| wanted.include?(path) }
+    end
+
     def find_file(filepath)
-      simplecov_result['coverage'][fix_relative_filepath(filepath)]
+      simplecov_result['coverage'][CoverageRoot.strip(filepath, coverage_root)]
     end
   end
 end

data/lib/undercover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Undercover
-  VERSION = '0.8.4'
+  VERSION = '0.9.0'
 end