testprune 0.1.0

data/lib/testprune/duplication_detector.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'footprint'
+require_relative 'test_body'
+require_relative 'safety_check'
+require_relative 'baseline'
+
+module Testprune
+  # One test proposed for removal, with why and (after the safety pass) whether
+  # it's safe. `review_only` candidates (structural/overlap) are reported but
+  # never auto-patched.
+  Candidate = Struct.new(
+    :footprint, :confidence, :group, :reason, :kept_by,
+    :review_only, :safe, :safety_note,
+    keyword_init: true
+  )
+
+  # Holds the detection outcome and exposes the set that `apply` may patch.
+  # `ambient_units`/`setup_only` record what baseline subtraction removed, so the
+  # report can disclose it rather than silently dropping tests.
+  class DetectorResult
+    attr_reader :footprints, :candidates, :ambient_units, :setup_only
+
+    def initialize(footprints, candidates, ambient_units: 0, setup_only: 0)
+      @footprints = footprints
+      @candidates = candidates
+      @ambient_units = ambient_units
+      @setup_only = setup_only
+    end
+
+    # Only HIGH-confidence, non-review candidates that passed the safety check are
+    # auto-applicable. Structural (MEDIUM) and overlap (LOW) are review-only.
+    def approved_removals
+      @candidates.select { |c| c.confidence == :high && !c.review_only && c.safe }
+    end
+  end
+
+  # Detects duplicate/redundant tests from semantic footprints. Each removable
+  # candidate is justified by a *retained* keeper whose coverage is a superset
+  # (or equal), which the SafetyCheck then re-verifies against cascading gaps.
+  # Above this many post-identical/subset footprints, skip O(n²) overlap detection
+  # and log a warning. ~500 yields ~125k pairs which is acceptable; 2000+ becomes
+  # unusably slow on large suites.
+  OVERLAP_SIZE_LIMIT = 500
+
+  class DuplicationDetector
+    def initialize(footprints, overlap_threshold: 0.9, baseline_fraction: nil)
+      @original_footprints = footprints # preserved for SafetyCheck ambient-unit guarantee
+      ambient      = Baseline.ambient_units(footprints, baseline_fraction)
+      had_coverage = footprints.reject(&:empty?).size
+      @footprints  = strip_ambient(footprints, ambient).reject(&:empty?)
+      @ambient     = ambient.size
+      @setup_only  = had_coverage - @footprints.size # lost all signal to baseline
+      @threshold   = overlap_threshold
+      @candidates  = []
+      @seen        = Set.new # ids already proposed for removal
+      @protected   = Set.new # ids chosen as keepers — never propose these
+    end
+
+    def call
+      detect_identical
+      detect_subset
+      detect_structural
+      detect_overlap
+      SafetyCheck.new(@footprints, original_footprints: @original_footprints).apply(@candidates)
+      DetectorResult.new(@footprints, @candidates,
+                         ambient_units: @ambient, setup_only: @setup_only)
+    end
+
+    private
+
+    # Returns copies of the footprints with ambient (shared-setup) units removed,
+    # so detection compares only each test's *distinctive* coverage. A test whose
+    # footprint was entirely ambient becomes empty and is dropped — we can't tell
+    # what it uniquely exercises, so it must never be proposed for removal.
+    def strip_ambient(footprints, ambient)
+      return footprints if ambient.empty?
+
+      footprints.map do |fp|
+        fp.dup.tap { |copy| copy.units = fp.units - ambient }
+      end
+    end
+
+    def available
+      @footprints.reject { |fp| @seen.include?(fp.id) || @protected.include?(fp.id) }
+    end
+
+    def detect_identical
+      @footprints.group_by(&:units).each_value do |members|
+        next if members.size < 2
+
+        members = members.sort_by(&:id)
+        keeper = members.first
+        @protected << keeper.id
+        members.drop(1).each do |fp|
+          propose_local(fp, keeper, group: :identical,
+                        high_reason: "identical coverage to #{keeper.id}",
+                        low_reason: "identical coverage to #{keeper.id}, but in a different " \
+                                    'test file (likely a shared code path, not a redundant test)')
+        end
+      end
+    end
+
+    def detect_subset
+      available.sort_by(&:id).each do |candidate|
+        # Search for a keeper among all footprints not yet proposed for removal.
+        # Crucially, we include @protected footprints (already-designated keepers):
+        # excluding them caused false negatives in coverage chains where A ⊊ B ⊊ C —
+        # after B is protected as A's keeper, C must still be findable as B's keeper.
+        keeper = @footprints
+                   .reject { |fp| @seen.include?(fp.id) || fp.id == candidate.id }
+                   .find { |other| candidate.units.proper_subset?(other.units) }
+        next unless keeper
+
+        @protected << keeper.id
+        propose_local(candidate, keeper, group: :subset,
+                      high_reason: "coverage is a strict subset of #{keeper.id}",
+                      low_reason: "coverage is a strict subset of #{keeper.id}, but in a different " \
+                                  'test file (likely a shared code path, not a redundant test)')
+      end
+    end
+
+    # Coverage-equivalence only earns HIGH (auto-removable) confidence when both
+    # tests live in the same file — i.e. variations of one scenario. Equivalence
+    # across files usually means the tests merely share a guard/middleware path
+    # while asserting different things, so it's demoted to LOW review-only.
+    def propose_local(footprint, keeper, group:, high_reason:, low_reason:)
+      if same_file?(footprint, keeper)
+        propose(footprint, confidence: :high, group: group, reason: high_reason, keeper: keeper)
+      else
+        propose(footprint, confidence: :low, group: group, review_only: true,
+                reason: low_reason, keeper: keeper)
+      end
+    end
+
+    def same_file?(a, b)
+      !a.file.nil? && a.file == b.file
+    end
+
+    def detect_structural
+      by_signature = {}
+      available.each do |fp|
+        sig = TestBody.signature(fp.file, fp.line)
+        (by_signature[sig] ||= []) << fp if sig
+      end
+
+      by_signature.each_value do |members|
+        next if members.size < 2
+
+        members = members.sort_by(&:id)
+        keeper = members.first
+        @protected << keeper.id
+        members.drop(1).each do |fp|
+          next if (fp.units & keeper.units).empty? # require real coverage overlap
+
+          propose(fp, confidence: :medium, group: :structural, review_only: true,
+                  reason: "test body structurally identical to #{keeper.id}", keeper: keeper)
+        end
+      end
+    end
+
+    def detect_overlap
+      pool = available
+      if pool.size > OVERLAP_SIZE_LIMIT
+        warn "testprune: #{pool.size} candidates after identical/subset detection; " \
+             "overlap (LOW-confidence) detection skipped to avoid O(n²) cost at this " \
+             "suite size. HIGH/MEDIUM results are unaffected."
+        return
+      end
+
+      pool.combination(2).each do |a, b|
+        next if @seen.include?(a.id) || @seen.include?(b.id)
+
+        score = jaccard(a.units, b.units)
+        next if score < @threshold
+
+        smaller, larger = [a, b].sort_by { |fp| [fp.units.size, fp.id] }
+        next if @protected.include?(smaller.id)
+
+        @protected << larger.id
+        propose(smaller, confidence: :low, group: :overlap, review_only: true,
+                reason: "#{(score * 100).round}% coverage overlap with #{larger.id}",
+                keeper: larger)
+      end
+    end
+
+    def propose(footprint, confidence:, group:, reason:, keeper:, review_only: false)
+      @candidates << Candidate.new(
+        footprint: footprint, confidence: confidence, group: group, reason: reason,
+        kept_by: [keeper.id], review_only: review_only
+      )
+      @seen << footprint.id
+    end
+
+    # Avoids materializing the union Set: uses inclusion-exclusion arithmetic instead.
+    def jaccard(a, b)
+      inter = (a & b).size
+      union = a.size + b.size - inter
+      union.zero? ? 0.0 : inter.to_f / union
+    end
+  end
+end

data/lib/testprune/footprint.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'semantic_map'
+
+module Testprune
+  # A single test's semantic coverage: the set of AST-aware unit IDs it executed,
+  # plus the metadata needed to report and patch it.
+  Footprint = Struct.new(:id, :description, :file, :line, :wall_time, :units, keyword_init: true) do
+    def empty?
+      units.empty?
+    end
+  end
+
+  # Turns recorded per-test coverage (run.json) into Footprints by mapping
+  # Coverage locations onto Prism semantic units. Caches one SemanticMap per file.
+  class SemanticIndex
+    def initialize(root)
+      @root = root
+      @maps = {}
+    end
+
+    def build_footprints(tests)
+      tests.map { |test| footprint(test) }
+    end
+
+    def footprint(test)
+      units = Set.new
+      (test['coverage'] || {}).each do |file, data|
+        next unless File.exist?(file)
+
+        map = map_for(file)
+        collect_methods(units, map, data['methods'])
+        collect_branches(units, map, data['branches'])
+        collect_lines(units, map, data['lines'])
+      end
+
+      Footprint.new(
+        id: test['id'], description: test['description'], file: test['file'],
+        line: test['line'], wall_time: test['wall_time'] || 0.0, units: units
+      )
+    end
+
+    def label_for(id)
+      @maps.each_value do |map|
+        unit = map.units[id]
+        return unit.label if unit
+      end
+      id
+    end
+
+    private
+
+    def collect_methods(units, map, entries)
+      (entries || []).each do |entry|
+        _name, sl, sc, = entry
+        unit = map.method_unit(sl, sc)
+        units << unit.id if unit
+      end
+    end
+
+    def collect_branches(units, map, entries)
+      (entries || []).each do |entry|
+        type, sl, sc, el, ec = entry
+        units << map.branch_unit(type, sl, sc, el, ec).id
+      end
+    end
+
+    def collect_lines(units, map, lines)
+      (lines || []).each do |lineno|
+        unit = map.line_unit(lineno)
+        units << unit.id if unit
+      end
+    end
+
+    def map_for(file)
+      @maps[file] ||= SemanticMap.for_file(file, relpath: relativize(file))
+    rescue StandardError => e
+      warn "testprune: could not parse #{file} (#{e.class}: #{e.message}) — skipping"
+      @maps[file] = SemanticMap.new(file, '', relativize(file))
+    end
+
+    def relativize(file)
+      file.start_with?("#{@root}/") ? file[(@root.length + 1)..] : file
+    end
+  end
+end

data/lib/testprune/patch_writer.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'tempfile'
+require 'fileutils'
+require_relative '../testprune'
+require_relative 'test_body'
+
+module Testprune
+  # Emits a git-applyable patch that comments out the approved tests. Locates each
+  # test's exact AST block (def or `it`/`describe` block) with Prism, comments
+  # those lines, and diffs against the original via `git diff --no-index`. Writes
+  # only the .patch file — never mutates the target source.
+  class PatchWriter
+    def initialize(config)
+      @config = config
+    end
+
+    def write(candidates)
+      FileUtils.mkdir_p(@config.output_dir)
+      patch = candidates.group_by { |c| c.footprint.file }
+                        .map { |file, group| file_patch(file, group) }
+                        .compact.join
+      File.write(@config.patch_file, patch)
+      @config.patch_file
+    end
+
+    private
+
+    def file_patch(file, candidates)
+      unless file && File.exist?(file)
+        ids = candidates.map { |c| c.footprint.id }
+        warn "testprune: #{ids.size} candidate(s) skipped — #{file || '(no file)'} not found:\n" \
+             "  #{ids.join(', ')}"
+        return nil
+      end
+
+      original = File.read(file, encoding: 'UTF-8:UTF-8', invalid: :replace, undef: :replace)
+      tree = begin
+        Prism.parse(original).value
+      rescue StandardError => e
+        warn "testprune: Prism parse failed for #{file} (#{e.message}) — skipping"
+        return nil
+      end
+      ranges = candidates.filter_map { |c| block_range(tree, c) }
+      return nil if ranges.empty?
+
+      modified = comment_out(original, ranges)
+      diff(file, modified)
+    end
+
+    # [start_line, end_line, reason] for the test block at the candidate's line.
+    def block_range(tree, candidate)
+      node = TestBody.locate(tree, candidate.footprint.line)
+      return nil unless node
+
+      loc = node.location
+      [loc.start_line, loc.end_line, candidate.reason]
+    end
+
+    def comment_out(original, ranges)
+      lines = original.lines
+      commented = lines.dup
+      annotations = {} # 0-based insert index => annotation text
+
+      ranges.each do |start_line, end_line, reason|
+        annotations[start_line - 1] = "# testprune: removed redundant test — #{reason}\n"
+        (start_line..end_line).each do |lineno|
+          idx = lineno - 1
+          commented[idx] = "# #{commented[idx]}"
+        end
+      end
+
+      # Insert annotations from the bottom up so earlier indexes stay valid.
+      annotations.sort_by { |idx, _| -idx }.each do |idx, text|
+        indent = lines[idx][/\A\s*/]
+        commented.insert(idx, "#{indent}#{text}")
+      end
+      commented.join
+    end
+
+    # Unified diff via git, with headers rewritten to the repo-relative path so
+    # the patch applies cleanly from the project root.
+    def diff(file, modified)
+      relpath = relativize(file)
+      Tempfile.create(['testprune', '.rb']) do |tmp|
+        tmp.write(modified)
+        tmp.flush
+        out, _err, status = Open3.capture3(
+          'git', 'diff', '--no-index', '--no-color', file, tmp.path
+        )
+        raise Error, 'git diff failed while building patch' if status.exitstatus > 1
+
+        rewrite_headers(out, relpath)
+      end
+    end
+
+    def rewrite_headers(diff, relpath)
+      diff.lines.map do |line|
+        if line.start_with?('diff --git ')
+          "diff --git a/#{relpath} b/#{relpath}\n"
+        elsif line.start_with?('--- ')
+          "--- a/#{relpath}\n"
+        elsif line.start_with?('+++ ')
+          "+++ b/#{relpath}\n"
+        else
+          line
+        end
+      end.join
+    end
+
+    def relativize(file)
+      root = @config.root
+      file.start_with?("#{root}/") ? file[(root.length + 1)..] : file
+    end
+  end
+end

data/lib/testprune/recorder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'coverage'
+require 'json'
+require 'fileutils'
+require_relative '../testprune'
+require_relative 'coverage_delta'
+
+module Testprune
+  # Process-wide singleton that the framework adapters drive. It starts Coverage,
+  # snapshots peek_result around each test, and writes run.json when the suite ends.
+  class Recorder
+    def self.instance
+      @instance ||= new(Configuration.from_env)
+    end
+
+    # Used in testprune's own test suite to prevent Recorder state from leaking
+    # between test runs (the singleton is normally process-scoped by design).
+    def self.reset!
+      @instance = nil
+    end
+
+    def initialize(config)
+      @config = config
+      @tests  = []
+      @framework = nil
+    end
+
+    attr_accessor :framework
+
+    # Start Coverage with all required options and keep it running for the
+    # entire suite. Staying always-on means `Coverage.running?` is true before
+    # SimpleCov (or any other coverage tool) loads, so they see it already
+    # running and skip their own `Coverage.start` call — no guard needed in
+    # test_helper.rb. Per-test footprints are captured by diffing `peek_result`
+    # snapshots before and after each test; `peek_result` is non-destructive so
+    # SimpleCov's final `Coverage.result` call at suite end still gets the full
+    # aggregate unaffected.
+    def start_coverage
+      return if @started
+
+      Coverage.setup(lines: true, branches: true, methods: true)
+      Coverage.resume
+      @started = true
+    end
+
+    # Bracket a single test (RSpec around(:each)). Minitest uses start_test/
+    # finish_test directly from lifecycle hooks instead, to avoid wrapping #run.
+    def around(id:, file:, line:, description: nil)
+      start_test
+      begin
+        yield
+      ensure
+        finish_test(id: id, file: file, line: line, description: description)
+      end
+    end
+
+    # Snapshot coverage counts before the test begins.
+    def start_test
+      @before = Coverage.peek_result
+      @test_started = monotonic
+    end
+
+    # Record this test's coverage delta + wall time. Coverage keeps running
+    # between tests — the peek_result diff is accurate for serial suites because
+    # nothing else executes between start_test and finish_test.
+    def finish_test(id:, file:, line:, description: nil)
+      wall = monotonic - @test_started
+      delta = CoverageDelta.compute(@before, Coverage.peek_result, @config)
+      @tests << {
+        'id'          => id,
+        'description' => description || id,
+        'file'        => file && File.expand_path(file),
+        'line'        => line,
+        'wall_time'   => wall,
+        'coverage'    => delta
+      }
+    end
+
+    def dump
+      return if @dumped
+
+      @dumped = true
+      FileUtils.mkdir_p(@config.output_dir)
+      File.write(@config.run_file, JSON.generate(payload))
+    end
+
+    private
+
+    def payload
+      {
+        'root'      => @config.root,
+        'framework' => @framework,
+        'tests'     => @tests
+      }
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/testprune/report.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Testprune
+  # Renders the analysis as a grouped, human-readable report (or JSON). Candidates
+  # are grouped by confidence; HIGH shows safety status, MEDIUM/LOW are marked
+  # review-only.
+  class Report
+    GROUP_TITLES = {
+      identical:  'Identical coverage',
+      subset:     'Subset / subsumed coverage',
+      structural: 'Structurally duplicated test body',
+      overlap:    'High coverage overlap'
+    }.freeze
+
+    def initialize(result, json: false)
+      @result = result
+      @json   = json
+    end
+
+    def render
+      @json ? render_json : render_text
+    end
+
+    private
+
+    def render_text
+      lines = []
+      lines << 'testprune — test coverage redundancy report'
+      lines << "Suite: #{test_count} test(s), framework=#{@result.run['framework']}"
+      if @result.ambient_units.positive?
+        lines << "Baseline: subtracted #{@result.ambient_units} shared-setup unit(s); " \
+                 "#{@result.setup_only} test(s) had no distinctive coverage and were set aside."
+      end
+      lines << ''
+
+      lines.concat(section('HIGH confidence — safe to remove', high_candidates))
+      lines.concat(section('MEDIUM confidence — review (structural duplicates)', medium_candidates))
+      lines.concat(section('LOW confidence — review (overlapping coverage)', low_candidates))
+
+      lines.concat(savings_section)
+      lines << ''
+      lines << if @result.approved_removals.empty?
+                 'No auto-removable candidates. Nothing to apply.'
+               else
+                 'Run `testprune apply` to review and emit a removal patch.'
+               end
+      lines.join("\n")
+    end
+
+    def section(title, candidates)
+      return [] if candidates.empty?
+
+      out = ["#{title}: #{candidates.size}"]
+      candidates.each { |c| out.concat(candidate_lines(c)) }
+      out << ''
+      out
+    end
+
+    def candidate_lines(candidate)
+      fp = candidate.footprint
+      out = []
+      out << "  [#{candidate.group}] #{fp.id}"
+      out << "      at: #{fp.file}:#{fp.line}" if fp.file
+      out << "      reason: #{candidate.reason}"
+      out << "      kept by: #{candidate.kept_by.join(', ')}" unless candidate.kept_by.empty?
+      out << "      covers: #{covered_labels(fp)}"
+      out << "      #{safety_line(candidate)}"
+      out
+    end
+
+    def covered_labels(footprint)
+      labels = footprint.units.map { |id| @result.label_for(id) }.sort
+      labels.size <= 4 ? labels.join('; ') : "#{labels.first(4).join('; ')} (+#{labels.size - 4} more)"
+    end
+
+    def safety_line(candidate)
+      case candidate.safe
+      when true  then '✓ safe — every covered unit remains covered by a retained test'
+      when false then "✗ NOT safe — #{candidate.safety_note} (kept)"
+      else            '· review-only — not auto-applied'
+      end
+    end
+
+    def savings_section
+      s = @result.savings
+      [
+        'Estimated CI savings:',
+        "  #{s.approved_count} test(s), #{format('%.4f', s.approved_time)}s " \
+        "(~#{format('%.1f', s.percent_of_test_time)}% of #{format('%.4f', s.total_test_time)}s test time)",
+        '  Note: under parallel CI runners, wall-clock savings will be lower.'
+      ]
+    end
+
+    def high_candidates   = @result.candidates.select { |c| c.confidence == :high }
+    def medium_candidates = @result.candidates.select { |c| c.confidence == :medium }
+    def low_candidates    = @result.candidates.select { |c| c.confidence == :low }
+    def test_count        = (@result.run['tests'] || []).size
+
+    def render_json
+      JSON.pretty_generate(
+        framework: @result.run['framework'],
+        test_count: test_count,
+        savings: {
+          approved_count: @result.savings.approved_count,
+          approved_time: @result.savings.approved_time,
+          total_test_time: @result.savings.total_test_time,
+          percent_of_test_time: @result.savings.percent_of_test_time
+        },
+        candidates: @result.candidates.map { |c| candidate_json(c) }
+      )
+    end
+
+    def candidate_json(candidate)
+      fp = candidate.footprint
+      {
+        id: fp.id, file: fp.file, line: fp.line,
+        confidence: candidate.confidence, group: candidate.group,
+        reason: candidate.reason, kept_by: candidate.kept_by,
+        review_only: candidate.review_only, safe: candidate.safe,
+        safety_note: candidate.safety_note,
+        covers: fp.units.map { |id| @result.label_for(id) }.sort
+      }
+    end
+  end
+end