undercover 0.8.5 → 0.9.0

data/lib/undercover/options.rb

@@ -32,7 +32,7 @@ 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
 
@@ -41,19 +41,19 @@ module Undercover
                   :path,
                   :git_dir,
                   :compare,
-                  :syntax_version,
+                  :commits_only,
                   :run_mode,
                   :file_scope,
                   :glob_allow_filters,
                   :glob_reject_filters,
                   :max_warnings_limit,
-                  :formatter
+                  :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
@@ -61,7 +61,7 @@ module Undercover
       self.formatter = 'text'
     end
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def parse(args)
       args = build_opts(args)
 
@@ -74,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)
@@ -85,17 +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
 
@@ -143,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
@@ -163,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
 
@@ -179,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
@@ -197,7 +210,8 @@ 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
@@ -209,5 +223,12 @@ module Undercover
         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

@@ -11,19 +11,12 @@ module Undercover
     def_delegators :node, :first_line, :last_line, :name
     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 +
@@ -144,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]
@@ -69,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.5'
+  VERSION = '0.9.0'
 end

data/lib/undercover.rb

@@ -2,26 +2,33 @@
 
 $LOAD_PATH << 'lib'
 require 'json'
-require 'imagen'
 require 'rainbow'
-require 'bigdecimal'
 require 'forwardable'
 require 'simplecov'
 
 require 'undercover/lcov_parser'
+require 'undercover/coverage_index'
 require 'undercover/result'
 require 'undercover/cli'
 require 'undercover/changeset'
 require 'undercover/formatter'
 require 'undercover/json_formatter'
 require 'undercover/options'
+require 'undercover/coverage_root'
 require 'undercover/filter_set'
 require 'undercover/simplecov_result_adapter'
 require 'undercover/version'
+require 'undercover/node'
+require 'undercover/node_visitor'
+require 'undercover/erb_node'
+require 'undercover/erb_visitor'
+require 'undercover/erb_extractor'
+require 'undercover/file_loader'
 
 module Undercover
   class Report
     extend Forwardable
+    include FileLoader
 
     def_delegators :changeset, :validate
 
@@ -30,6 +37,7 @@ module Undercover
                 :coverage_adapter,
                 :results,
                 :code_dir,
+                :coverage_root,
                 :filter_set,
                 :max_warnings_limit
 
@@ -40,41 +48,28 @@ module Undercover
     # @param coverage_adapter [Undercover::SimplecovResultAdapter|Undercover::LcovParser] pre-parsed coverage adapter
     def initialize(changeset, opts, coverage_adapter)
       @coverage_adapter = coverage_adapter
-
-      @code_dir = opts.path
       @changeset = changeset
-
-      ignored_files = coverage_adapter.ignored_files || []
-      @filter_set = FilterSet.new(opts.glob_allow_filters, opts.glob_reject_filters, ignored_files)
+      @code_dir = changeset.repo_workdir
+      @coverage_root = resolve_coverage_root
+      coverage_adapter.coverage_root = @coverage_root
+      @filter_set = build_filter_set(opts)
       changeset.filter_with(filter_set)
       @max_warnings_limit = opts.max_warnings_limit
       @loaded_files = {}
       @results = {}
     end
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def build
       flag_count = 0
       changeset.each_changed_line do |filepath, line_no|
         break if max_warnings_limit && flag_count >= max_warnings_limit
 
-        dist_from_line_no = lambda do |res|
-          return BigDecimal::INFINITY if line_no < res.first_line
-
-          res_lines = res.first_line..res.last_line
-          return BigDecimal::INFINITY unless res_lines.cover?(line_no)
-
-          line_no - res.first_line
-        end
-        dist_from_line_no_sorter = lambda do |res1, res2|
-          dist_from_line_no[res1] <=> dist_from_line_no[res2]
-        end
-
         load_and_parse_file(filepath)
 
         next unless loaded_files[filepath]
 
-        res = loaded_files[filepath].min(&dist_from_line_no_sorter)
+        res = result_for_line(filepath, line_no)
         if res.uncovered?(line_no) && !res.flagged?
           res.flag
           flag_count += 1
@@ -84,7 +79,6 @@ module Undercover
       end
       self
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def build_warnings
       warn('Undercover::Report#build_warnings is deprecated! ' \
@@ -100,6 +94,29 @@ module Undercover
       all_results.select(&:flagged?)
     end
 
+    # Changed files undercover would have reported on, had --include-files /
+    # --exclude-files not rejected them. Everything rejected and nothing reported usually
+    # means the globs are written against the wrong root.
+    def globbed_out_files
+      @globbed_out_files ||= changeset.file_paths.select { |path| filter_set.rejected_by_globs?(path) }
+    end
+
+    # Changed ERB templates left unchecked because the coverage report has no ERB coverage
+    # at all, meaning SimpleCov ran without enable_coverage(:eval). Checking them anyway
+    # would flag every block at 0%.
+    def erb_files_without_coverage
+      return [] if coverage_adapter.erb_coverage?
+
+      @erb_files_without_coverage ||= changeset.file_paths.select do |path|
+        path.end_with?(FileLoader::ERB_EXTENSION) && filter_set.include?(path)
+      end
+    end
+
+    # Changed ERB templates left unchecked because they could not be parsed
+    def erb_parse_failures
+      @erb_parse_failures ||= []
+    end
+
     def inspect
       "#<Undercover::Report:#{object_id} results: #{results.size}>"
     end
@@ -109,21 +126,41 @@ module Undercover
 
     attr_reader :loaded_files
 
-    # rubocop:disable Metrics/AbcSize
-    def load_and_parse_file(filepath)
-      key = filepath.gsub(/^\.\//, '')
-      return if loaded_files[key]
-
-      root_ast = Imagen::Node::Root.new.build_from_file(
-        File.join(code_dir, filepath)
-      )
-      return if root_ast.children.empty?
+    # The innermost result whose lines cover line_no: the one starting closest above it,
+    # the first one listed on a tie. Lines outside every result fall back to the first.
+    def result_for_line(filepath, line_no)
+      @line_results ||= {}
+      by_line = @line_results[filepath] ||= index_results_by_line(loaded_files[filepath])
+      by_line[line_no] || loaded_files[filepath].first
+    end
 
-      loaded_files[key] = []
-      root_ast.find_all(->(node) { !node.is_a?(Imagen::Node::Root) }).each do |imagen_node|
-        loaded_files[key] << Result.new(imagen_node, coverage_adapter, filepath)
+    def index_results_by_line(file_results)
+      by_line = {}
+      file_results.each do |res|
+        (res.first_line..res.last_line).each do |line_no|
+          current = by_line[line_no]
+          by_line[line_no] = res if current.nil? || res.first_line > current.first_line
+        end
       end
+      by_line
+    end
+
+    def build_filter_set(opts)
+      FilterSet.new(opts.glob_allow_filters, opts.glob_reject_filters, coverage_adapter.ignored_files || [],
+                    coverage_root: coverage_root)
+    end
+
+    # LCOV reports carry no SimpleCov.root, so fall back to where undercover runs, which
+    # is where SimpleCov ran for anyone invoking the CLI by hand. A wrong guess is caught
+    # by the covered-file check in CoverageRoot.
+    def resolve_coverage_root
+      simplecov_root = coverage_adapter.simplecov_root || Dir.pwd
+      CoverageRoot.derive(code_dir, simplecov_root, coverage_adapter.coverage_keys, exists: method(:repository_path?))
+    end
+
+    # On disk, or committed at HEAD for files a sparse checkout left out
+    def repository_path?(path)
+      File.exist?(File.join(code_dir, path)) || changeset.head_path?(path)
     end
-    # rubocop:enable Metrics/AbcSize
   end
 end

data/undercover.gemspec

@@ -25,14 +25,16 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 3.0.0'
+  spec.required_ruby_version = '>= 3.2.0'
 
   spec.add_dependency 'base64'
   spec.add_dependency 'benchmark'
-  spec.add_dependency 'bigdecimal'
-  spec.add_dependency 'imagen', '>= 0.2.0'
+  spec.add_dependency 'erubi', '>= 1.13'
+  spec.add_dependency 'prism', '>= 1.8', '< 3'
   spec.add_dependency 'rainbow', '>= 2.1', '< 4.0'
   spec.add_dependency 'rugged', '>= 0.27', '< 1.10'
-  spec.add_dependency 'simplecov'
-  spec.add_dependency 'simplecov_json_formatter'
+  spec.add_dependency 'simplecov', '>= 1.0'
+  # Pinned: undercover requires its internal files by path and subclasses
+  # ResultHashFormatter, so a file reorganisation would break loading.
+  spec.add_dependency 'simplecov_json_formatter', '~> 0.1'
 end