testprune 0.1.0

data/lib/testprune/runner.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require_relative '../testprune'
+
+module Testprune
+  # Boots the target project's suite in a subprocess, instrumented so the adapters
+  # capture per-test coverage. Reuses the gem's lib via RUBYOPT (-I) so the target
+  # project does not need testprune in its Gemfile.
+  class Runner
+    def initialize(config)
+      @config = config
+    end
+
+    # explicit_command: array form of a user-supplied test command (after `--`),
+    # or nil to autodetect.
+    def call(explicit_command = nil)
+      framework, command = resolve(explicit_command)
+
+      FileUtils.mkdir_p(@config.output_dir)
+      File.delete(@config.run_file) if File.exist?(@config.run_file)
+
+      warn("testprune: framework=#{framework}  running: #{command.join(' ')}")
+      ok = system(env, *command, chdir: @config.root)
+
+      unless File.exist?(@config.run_file)
+        raise Error, 'suite finished but no run.json was captured — the adapter may ' \
+                     'not have loaded. Check the framework/command and source paths.'
+      end
+
+      count = begin
+        JSON.parse(File.read(@config.run_file)).fetch('tests', []).size
+      rescue JSON::ParserError
+        '(unreadable — suite may have been interrupted mid-write)'
+      end
+      warn("testprune: captured #{count} test(s) -> #{@config.run_file}")
+      warn('testprune: suite exited non-zero; coverage was still captured.') unless ok
+      ok
+    end
+
+    private
+
+    def env
+      gem_lib = File.expand_path('..', __dir__)
+      rubyopt = ["-I#{gem_lib}", '-rtestprune/autostart', ENV['RUBYOPT']].compact.reject(&:empty?).join(' ')
+      @config.to_env.merge('RUBYOPT' => rubyopt)
+    end
+
+    def resolve(explicit_command)
+      if explicit_command && !explicit_command.empty?
+        [framework_of(explicit_command.join(' ')), explicit_command]
+      else
+        autodetect
+      end
+    end
+
+    def framework_of(command_string)
+      command_string.include?('rspec') ? :rspec : :minitest
+    end
+
+    def autodetect
+      bundler = File.exist?(File.join(@config.root, 'Gemfile'))
+      prefix  = bundler ? %w[bundle exec] : []
+
+      if File.directory?(File.join(@config.root, 'spec'))
+        [:rspec, prefix + ['rspec']]
+      elsif File.directory?(File.join(@config.root, 'test'))
+        [:minitest, prefix + ['rake', 'test']]
+      else
+        raise Error, 'could not autodetect a test suite (no spec/ or test/ dir). ' \
+                     'Pass an explicit command after `--`.'
+      end
+    end
+  end
+end

data/lib/testprune/safety_check.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Testprune
+  # The hard guarantee: never confirm a removal that drops any semantic unit's
+  # coverage to zero. Cascading-aware — evaluates candidates against the units
+  # still covered by the *retained* set, decrementing as removals are confirmed,
+  # so two individually-safe removals that are jointly unsafe can't both pass.
+  #
+  # Only non-review candidates (the auto-applicable ones) are checked; review-only
+  # candidates are left with `safe = nil` since they're never patched.
+  class SafetyCheck
+    # original_footprints: pre-ambient-stripping footprints. When baseline subtraction
+    # is active, the candidates' footprint.units are stripped — but removing a test
+    # also removes its ambient units from coverage. We track and decrement original
+    # units so ambient units are guaranteed not to drop to zero.
+    def initialize(footprints, original_footprints: nil)
+      originals = original_footprints || footprints
+      @cover_count = Hash.new(0)
+      originals.each { |fp| fp.units.each { |unit| @cover_count[unit] += 1 } }
+      # Map id -> original units so evaluate always decrements the right set.
+      @original_units = originals.each_with_object({}) { |fp, h| h[fp.id] = fp.units }
+    end
+
+    def apply(candidates)
+      removable = candidates.reject(&:review_only).sort_by { |c| c.footprint.id }
+      removable.each { |candidate| evaluate(candidate) }
+      candidates
+    end
+
+    private
+
+    def evaluate(candidate)
+      units = @original_units.fetch(candidate.footprint.id, candidate.footprint.units)
+      at_risk = units.reject { |unit| @cover_count[unit] >= 2 }
+
+      if at_risk.empty?
+        candidate.safe = true
+        units.each { |unit| @cover_count[unit] -= 1 }
+      else
+        candidate.safe = false
+        candidate.safety_note = "would leave #{at_risk.size} unit(s) with no other test"
+      end
+    end
+  end
+end

data/lib/testprune/savings_estimator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Testprune
+  # Estimates CI time recovered by removing the approved candidates. Reports
+  # aggregate test time removed — honest about the fact that parallel runners mean
+  # wall-clock savings are smaller.
+  class SavingsEstimator
+    def initialize(run, detector_result)
+      @run = run
+      @detector = detector_result
+    end
+
+    def approved_count
+      @detector.approved_removals.size
+    end
+
+    def approved_time
+      @detector.approved_removals.sum { |c| c.footprint.wall_time || 0.0 }
+    end
+
+    def total_test_time
+      (@run['tests'] || []).sum { |t| t['wall_time'] || 0.0 }
+    end
+
+    def percent_of_test_time
+      base = total_test_time
+      base.zero? ? 0.0 : (approved_time / base * 100)
+    end
+  end
+end

data/lib/testprune/semantic_map.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Testprune
+  # Parses one source file with Prism and resolves Coverage locations to
+  # AST-aware semantic units:
+  #   - methods   (DefNode)            -> "Class#method"
+  #   - branch arms (IfNode/CaseNode/…) -> "if then-branch", labelled by the
+  #     innermost enclosing control node
+  #   - lines collapse to their innermost enclosing method, or a per-file
+  #     top-level unit when outside any def — so straight-line code still
+  #     contributes a stable unit.
+  class SemanticMap
+    Unit = Struct.new(:id, :kind, :label, :file, :line, keyword_init: true)
+
+    def self.for_file(path, relpath:)
+      # Read with replacement for invalid/undefined bytes so non-UTF-8 content
+      # (Latin-1 comments, etc.) never raises an encoding error.
+      source = File.read(path, encoding: 'UTF-8:UTF-8', invalid: :replace, undef: :replace)
+      new(path, source, relpath)
+    end
+
+    attr_reader :units
+
+    def initialize(path, source, relpath)
+      @path    = path
+      @relpath = relpath
+      @units            = {}  # id => Unit
+      @methods_by_pos   = {}  # [start_line, start_col] => Unit
+      @method_intervals = []  # [start_line, end_line, Unit]
+      @controls         = []  # [sl, sc, el, ec, type]
+      Visitor.new(self).visit(Prism.parse(source).value)
+    end
+
+    # Registration callbacks used by the Visitor.
+
+    def add_method(node, scope, sep)
+      loc = node.location
+      sl  = loc.start_line
+      sc  = loc.start_column
+      owner = scope.empty? ? '' : "#{scope.join('::')}#{sep}"
+      id  = "#{@relpath}#m@#{sl}:#{sc}"
+      unit = Unit.new(id: id, kind: :method, label: "#{owner}#{node.name} (#{@relpath}:#{sl})",
+                      file: @relpath, line: sl)
+      @units[id] = unit
+      @methods_by_pos[[sl, sc]] = unit
+      @method_intervals << [sl, loc.end_line, unit]
+    end
+
+    def add_control(node, type)
+      loc = node.location
+      @controls << [loc.start_line, loc.start_column, loc.end_line, loc.end_column, type]
+    end
+
+    # Resolution used when building footprints.
+
+    def method_unit(start_line, start_col)
+      @methods_by_pos[[start_line, start_col]]
+    end
+
+    def branch_unit(type, start_line, start_col, _end_line, _end_col)
+      id = "#{@relpath}#b:#{type}@#{start_line}:#{start_col}"
+      @units[id] ||= begin
+        control_type = innermost_control(start_line, start_col) || type
+        Unit.new(id: id, kind: :branch,
+                 label: "#{control_type} #{type}-branch (#{@relpath}:#{start_line})",
+                 file: @relpath, line: start_line)
+      end
+    end
+
+    def line_unit(lineno)
+      best = nil
+      @method_intervals.each do |sl, el, unit|
+        next unless lineno >= sl && lineno <= el
+
+        best = unit if best.nil? || sl > best.line
+      end
+      best || toplevel_unit
+    end
+
+    private
+
+    def toplevel_unit
+      id = "#{@relpath}#top"
+      @units[id] ||= Unit.new(id: id, kind: :toplevel, label: "#{@relpath} (top-level)",
+                              file: @relpath, line: 0)
+    end
+
+    # Innermost control node containing a position; returns its type or nil.
+    def innermost_control(line, col)
+      match = nil
+      @controls.each do |sl, sc, el, ec, type|
+        next unless contains?(sl, sc, el, ec, line, col)
+
+        match = [sl, sc, type] if match.nil? || sl > match[0] || (sl == match[0] && sc > match[1])
+      end
+      match && match[2]
+    end
+
+    def contains?(sl, sc, el, ec, line, col)
+      return false if line < sl || line > el
+      return false if line == sl && col < sc
+      return false if line == el && col > ec
+
+      true
+    end
+
+    # Walks the AST, tracking class/module nesting, registering methods and
+    # control-flow nodes.
+    class Visitor < Prism::Visitor
+      def initialize(map)
+        @map = map
+        @scope = []
+        super()
+      end
+
+      def visit_class_node(node)
+        with_scope(node.constant_path.slice) { super }
+      end
+
+      def visit_module_node(node)
+        with_scope(node.constant_path.slice) { super }
+      end
+
+      def visit_def_node(node)
+        @map.add_method(node, @scope, node.receiver ? '.' : '#')
+        super
+      end
+
+      def visit_if_node(node)
+        @map.add_control(node, 'if')
+        super
+      end
+
+      def visit_unless_node(node)
+        @map.add_control(node, 'unless')
+        super
+      end
+
+      def visit_case_node(node)
+        @map.add_control(node, 'case')
+        super
+      end
+
+      def visit_case_match_node(node)
+        @map.add_control(node, 'case')
+        super
+      end
+
+      def visit_while_node(node)
+        @map.add_control(node, 'while')
+        super
+      end
+
+      def visit_until_node(node)
+        @map.add_control(node, 'until')
+        super
+      end
+
+      def visit_rescue_node(node)
+        @map.add_control(node, 'rescue')
+        super
+      end
+
+      def visit_and_node(node)
+        @map.add_control(node, '&&')
+        super
+      end
+
+      def visit_or_node(node)
+        @map.add_control(node, '||')
+        super
+      end
+
+      private
+
+      def with_scope(name)
+        @scope.push(name)
+        yield
+        @scope.pop
+      end
+    end
+  end
+end

data/lib/testprune/test_body.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Testprune
+  # Produces a structural signature for the test defined at file:line by parsing
+  # its body with Prism and emitting a node-type sequence that ignores literal
+  # values and identifiers but keeps called method names. Two tests that differ
+  # only in their data (e.g. `assert_equal 3, add(1,2)` vs `assert_equal 5,
+  # add(2,3)`) get the same signature.
+  module TestBody
+    @file_cache = {}
+
+    module_function
+
+    def signature(file, line)
+      return nil unless file && line && File.exist?(file)
+
+      tree = (@file_cache[file] ||= Prism.parse(File.read(file)).value)
+      node = locate(tree, line)
+      body = body_of(node)
+      return nil unless body
+
+      normalize(body)
+    end
+
+    # Innermost def or block whose definition starts on `line`.
+    def locate(root, line)
+      stack = [root]
+      until stack.empty?
+        node = stack.pop
+        if node.location.start_line == line &&
+           (node.is_a?(Prism::DefNode) || (node.is_a?(Prism::CallNode) && node.block))
+          return node
+        end
+
+        stack.concat(node.compact_child_nodes)
+      end
+      nil
+    end
+
+    def body_of(node)
+      return nil unless node
+
+      node.is_a?(Prism::DefNode) ? node.body : node.block&.body
+    end
+
+    def normalize(node)
+      tokens = []
+      walk(node) do |n|
+        tokens << (n.is_a?(Prism::CallNode) ? "call:#{n.name}" : n.type.to_s)
+      end
+      tokens.join(',')
+    end
+
+    def walk(node, &block)
+      block.call(node)
+      node.compact_child_nodes.each { |child| walk(child, &block) }
+    end
+  end
+end

data/lib/testprune/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Testprune
+  VERSION = '0.1.0'
+end

data/lib/testprune.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'testprune/version'
+require_relative 'testprune/configuration'
+
+module Testprune
+  class Error < StandardError; end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: testprune
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Seth MacPherson
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Combines Ruby's native Coverage execution counts with Prism AST analysis
+  to map per-test coverage onto semantic units (methods, branches, conditions), find
+  redundant tests grouped by duplication type with confidence levels, and emit a removal
+  patch — never deleting a test that would open a coverage gap. Report + patch only;
+  asks for approval before any change.
+email: seth.macpherson@appfolio.com
+executables:
+- testprune
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- assets/quickstart.svg
+- exe/testprune
+- lib/testprune.rb
+- lib/testprune/adapters/minitest.rb
+- lib/testprune/adapters/rspec.rb
+- lib/testprune/analysis.rb
+- lib/testprune/autostart.rb
+- lib/testprune/baseline.rb
+- lib/testprune/cli.rb
+- lib/testprune/configuration.rb
+- lib/testprune/coverage_delta.rb
+- lib/testprune/duplication_detector.rb
+- lib/testprune/footprint.rb
+- lib/testprune/patch_writer.rb
+- lib/testprune/recorder.rb
+- lib/testprune/report.rb
+- lib/testprune/runner.rb
+- lib/testprune/safety_check.rb
+- lib/testprune/savings_estimator.rb
+- lib/testprune/semantic_map.rb
+- lib/testprune/test_body.rb
+- lib/testprune/version.rb
+homepage: https://github.com/seth-macpherson/testprune
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Audits a Ruby test suite for duplicate/redundant coverage using Prism AST
+  + Coverage data
+test_files: []