minitest-impact 0.1.0

data/lib/minitest/impact/repo.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Minitest
+  module Impact
+    # Reads a git repository either as its working tree (rev nil) or as it was at a commit, so the
+    # same selection runs on an agent's uncommitted change and on a commit from history.
+    class Repo
+      attr_reader :root
+
+      def initialize(root = Dir.pwd)
+        @root = File.expand_path(root)
+        @cache = {}
+      end
+
+      def git(*args, allow_failure: false)
+        out, err, status = Open3.capture3("git", "-C", root, *args)
+        raise Error, "git #{args.join(" ")} failed: #{err.strip}" unless status.success? || allow_failure
+
+        status.success? ? out : nil
+      end
+
+      def head = git("rev-parse", "HEAD").strip
+
+      def commit?(rev) = !git("cat-file", "-e", "#{rev}^{commit}", allow_failure: true).nil?
+
+      def resolve(rev) = git("rev-parse", rev).strip
+
+      def merge_base(a, b) = git("merge-base", a, b, allow_failure: true)&.strip
+
+      # Contents of +path+ at +rev+, or in the working tree when rev is nil. nil when absent.
+      def read(path, rev = nil)
+        @cache.fetch([path, rev]) do
+          @cache[[path, rev]] =
+            if rev
+              git("show", "#{rev}:#{path}", allow_failure: true)
+            else
+              full = File.join(root, path)
+              File.file?(full) ? File.read(full) : nil
+            end
+        end
+      end
+
+      def files(rev = nil)
+        @cache.fetch([:files, rev]) do
+          @cache[[:files, rev]] =
+            if rev
+              git("ls-tree", "-r", "--name-only", rev).split("\n")
+            else
+              git("ls-files", "--cached", "--others", "--exclude-standard").split("\n").select { |f| File.file?(File.join(root, f)) }
+            end
+        end
+      end
+
+      # Files under +paths+ whose text contains the fixed string +needle+.
+      def grep(needle, paths:, rev: nil)
+        return [] if needle.to_s.strip.empty?
+
+        args = ["grep", "-l", "-F", "-e", needle]
+        args << "--untracked" unless rev
+        args << rev if rev
+        args += ["--", *paths]
+        out = git(*args, allow_failure: true).to_s
+        out.split("\n").map { |line| rev ? line.delete_prefix("#{rev}:") : line }
+      end
+
+      # Unified diff with no context between +base+ and +head+ (working tree when head is nil).
+      # Untracked files are listed as additions too, since an agent's new file is part of its change.
+      def diff(base, head = nil)
+        range = head ? [base, head] : [base]
+        text = git("diff", "--no-color", "--no-ext-diff", "-M", "--unified=0", *range)
+        return text if head
+
+        untracked = git("ls-files", "--others", "--exclude-standard").split("\n")
+        text + untracked.map { |path| "diff --git a/#{path} b/#{path}\nnew file mode 100644\n--- /dev/null\n+++ b/#{path}\n" }.join
+      end
+    end
+  end
+end

data/lib/minitest/impact/rules.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Impact
+    # Every rule that is a fact about Rails and Minitest layouts, in one place, so a reader can
+    # check them without reading the selector. Nothing here asks a model.
+    module Rules
+      TEST_ROOT = "test/"
+      TEST_FILE = %r{\Atest/.*_test\.rb\z}
+      FIXTURE = %r{\Atest/fixtures/(.+)\.yml\z}
+
+      # A change here can break any test, so the full suite is the only honest selection.
+      WHOLE_SUITE = %w[
+        Gemfile Gemfile.lock gems.rb gems.locked .ruby-version .tool-versions mise.toml
+        test/test_helper.rb config/application.rb config/boot.rb config/environment.rb
+        config/environments/test.rb config/database.yml
+      ].freeze
+
+      # A change to a base test class reaches every test under a directory.
+      BASE_CLASSES = {
+        "test/application_system_test_case.rb" => "test/system/"
+      }.freeze
+
+      # Files no test runs. Selected only when a test reads the file by path.
+      QUIET = [%r{\A(?:docs|tmp|log)/}, /\.md\z/, %r{\A\.github/}, /\ALICENSE/, /\.txt\z/, %r{\A\.claude/}, /\A\.gitignore\z/].freeze
+
+      ROUTES = "config/routes.rb"
+      LOCALE = %r{\Aconfig/locales/.+\.ya?ml\z}
+      MIGRATION = %r{\Adb/(migrate/.+\.rb|schema\.rb|.+_schema\.rb)\z}
+      VIEW = %r{\Aapp/views/(.+?)/(_?)([^/]+?)\.[^/]+\z}
+      STIMULUS = %r{\Aapp/javascript/controllers/(.+)_controller\.[jt]s\z}
+      AUTOLOADED = %r{\A(?:app/[^/]+|lib)/(.+)\.rb\z}
+
+      # Weights: how sure a reason is that a test file exercises the change (0..1).
+      WEIGHT = {
+        changed_test: 1.0,
+        method: 1.0,
+        deleted_file: 0.95,
+        conventional_test: 0.9,
+        reads_path: 0.85,
+        asserts_key: 0.85,
+        view: 0.85,
+        mentions_constant: 0.7,
+        file: 0.7,
+        via_file: 0.6,
+        untested_method: 0.3
+      }.freeze
+
+      module_function
+
+      def test_file?(path) = TEST_FILE.match?(path)
+      def whole_suite?(path) = WHOLE_SUITE.include?(path)
+      def quiet?(path) = QUIET.any? { |pattern| pattern.match?(path) }
+      def ruby?(path) = path.end_with?(".rb")
+
+      # app/models/billing/invoice.rb => test/models/billing/invoice_test.rb
+      # lib/tasks/x.rb => test/lib/tasks/x_test.rb, test/tasks/x_test.rb
+      def conventional_tests(path)
+        case path
+        when %r{\Aapp/(.+)\.rb\z} then ["test/#{Regexp.last_match(1)}_test.rb"]
+        when %r{\Alib/(.+)\.rb\z} then ["test/lib/#{Regexp.last_match(1)}_test.rb", "test/#{Regexp.last_match(1)}_test.rb"]
+        when VIEW
+          ["test/controllers/#{Regexp.last_match(1)}_controller_test.rb"]
+        else []
+        end
+      end
+
+      # Zeitwerk's naming: app/models/billing/invoice.rb => Billing::Invoice
+      def constant_for(path)
+        match = AUTOLOADED.match(path)
+        return unless match
+
+        rel = match[1].delete_prefix("concerns/")
+        rel.split("/").map { |part| camelize(part) }.join("::")
+      end
+
+      def camelize(word) = word.split("_").map(&:capitalize).join
+
+      def singularize(word)
+        case word
+        when /ies\z/ then word.sub(/ies\z/, "y")
+        when /(ss|us)\z/ then word
+        when /(s|x|z|ch|sh)es\z/ then word.sub(/es\z/, "")
+        when /s\z/ then word.chomp("s")
+        else word
+        end
+      end
+
+      # Tables a migration or schema diff touches.
+      def tables_in(text)
+        text.scan(/(?:create_table|drop_table|add_column|remove_column|change_column|rename_column|add_index|remove_index|add_reference|remove_reference|change_table|add_foreign_key|change_column_default|change_column_null)\s*\(?\s*[:"'](\w+)/).flatten.uniq
+      end
+
+      # The create_table block of schema.rb that holds +line+.
+      def schema_table_at(source, line)
+        source.lines.first(line).reverse_each do |text|
+          return Regexp.last_match(1) if text =~ /create_table\s+"(\w+)"/
+        end
+        nil
+      end
+
+      # Controllers a routes diff names.
+      def controllers_in_routes(text)
+        names = text.scan(/\bresources?\s+:(\w+)/).flatten.map { |name| name }
+        names += text.scan(/to:\s*["']([\w\/]+)#/).flatten
+        names += text.scan(/controller:\s*[:"']([\w\/]+)/).flatten
+        names.uniq.map { |name| "app/controllers/#{name}_controller.rb" }
+      end
+
+      # Candidate view files for a lazy key such as "sessions.new.title".
+      def views_for_key(key, files)
+        parts = key.split(".")
+        return [] if parts.size < 2
+
+        dir = parts[0..-3].join("/")
+        template = parts[-2]
+        files.select do |file|
+          file.start_with?("app/views/#{dir}/") &&
+            File.basename(file).split(".").first.delete_prefix("_") == template &&
+            File.dirname(file) == "app/views/#{dir}"
+        end
+      end
+
+      def stimulus_identifier(name) = name.tr("_", "-").gsub("/", "--")
+    end
+  end
+end

data/lib/minitest/impact/selector.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Minitest
+  module Impact
+    # One test file in a selection, with every reason it was picked.
+    Pick = Struct.new(:test, :score, :reasons, :seconds, keyword_init: true) do
+      def to_h = { "test" => test, "score" => score.round(3), "reasons" => reasons, "seconds" => seconds }
+    end
+
+    # What a selection decided about one changed file.
+    Resolution = Struct.new(:path, :how, :note, keyword_init: true)
+
+    Selection = Struct.new(:picks, :whole_suite, :resolutions, :jev, :warnings, keyword_init: true) do
+      def tests = picks.map(&:test)
+
+      def unresolved = resolutions.select { |resolution| resolution.how == :unresolved }
+
+      # high: every changed file was traced exactly (a changed test, a changed method the map saw
+      # run, or a file no test reads). medium: some file was traced by file or by convention. low:
+      # some file could not be traced, or the change needs the whole suite.
+      def confidence
+        return :low if whole_suite || resolutions.any? { |r| r.how == :unresolved }
+        return :medium if resolutions.any? { |r| %i[file convention].include?(r.how) }
+
+        :high
+      end
+
+      def to_h
+        {
+          "confidence" => confidence.to_s,
+          "whole_suite" => whole_suite,
+          "tests" => picks.map(&:to_h),
+          "files" => resolutions.map { |r| { "path" => r.path, "how" => r.how.to_s, "note" => r.note } },
+          "jev" => jev,
+          "warnings" => warnings
+        }
+      end
+    end
+
+    # Picks the test files a change is most likely to break or that verify it. Everything here is
+    # deterministic: the coverage map, method names, and the layout rules in Rules. A Jev ranker,
+    # when one is given, then re-ranks and extends the result (see Jev::Ranker).
+    class Selector
+      # granularity: :method (default) traces changed lines to methods; :file selects every test
+      # that loaded a changed file, as Crystalball and Ekstazi do. Kept to measure one against the other.
+      def initialize(repo:, map:, base:, head: nil, intent: nil, ranker: nil, exclude: nil, granularity: :method)
+        @repo = repo
+        @map = map
+        @base = base
+        @head = head
+        @intent = intent
+        @ranker = ranker
+        @exclude = exclude
+        @granularity = granularity
+        @hits = Hash.new { |hash, key| hash[key] = [] }
+        @resolutions = []
+        @warnings = []
+        @whole_suite = false
+      end
+
+      def changes
+        @changes ||= Diff.parse(@repo.diff(@base, @head)).reject { |change| @exclude&.call(change.path) }
+      end
+
+      def call
+        warn_if_stale
+        changes.each { |change| resolve(change) }
+        picks = rank
+        jev = nil
+        if @ranker && needs_ranker?(picks)
+          picks, jev = @ranker.call(picks: picks, changes: changes, intent: @intent, repo: @repo, map: @map, head: @head)
+          @whole_suite ||= jev&.dig("whole_suite") == true
+        end
+        Selection.new(picks: picks, whole_suite: @whole_suite, resolutions: @resolutions, jev: jev, warnings: @warnings)
+      end
+
+      private
+
+      def needs_ranker?(picks)
+        @resolutions.any? { |r| %i[unresolved file convention].include?(r.how) } || picks.size > Jev::Questions::MAX_CANDIDATES
+      end
+
+      def warn_if_stale
+        return if @map.commit.nil? || @repo.commit?(@map.commit)
+
+        @warnings << "the map was recorded at #{@map.commit}, which this repository does not have; matching by file only"
+      end
+
+      def hit(test, kind, reason)
+        return unless @map.tests.key?(test) || head_has?(test)
+
+        @hits[test] << [Rules::WEIGHT.fetch(kind), reason]
+      end
+
+      def head_has?(path) = head_files.include?(path)
+
+      def head_files = @head_files ||= @repo.files(@head).to_set
+
+      def resolved(change, how, note = nil)
+        @resolutions << Resolution.new(path: change.path, how: how, note: note)
+      end
+
+      # Several independent reasons make a test more likely, never less: 1 - Π(1 - w).
+      def rank
+        @hits.select { |test, _| head_has?(test) }.map do |test, reasons|
+          score = 1 - reasons.map(&:first).reduce(1.0) { |acc, weight| acc * (1 - weight) }
+          Pick.new(test: test, score: score, reasons: reasons.map(&:last).uniq, seconds: @map.seconds(test))
+        end.sort_by { |pick| [-pick.score, pick.seconds || Float::INFINITY, pick.test] }
+      end
+
+      def resolve(change)
+        path = change.path
+        return resolve_whole_suite(change) if Rules.whole_suite?(path)
+        return resolve_base_class(change) if Rules::BASE_CLASSES.key?(path)
+        return resolve_test(change) if Rules.test_file?(path)
+
+        case path
+        when Rules::FIXTURE then resolve_fixture(change, Regexp.last_match(1))
+        when Rules::LOCALE then resolve_locale(change)
+        when Rules::MIGRATION then resolve_migration(change)
+        when Rules::STIMULUS then resolve_stimulus(change, Regexp.last_match(1))
+        when Rules::ROUTES then resolve_routes(change)
+        else resolve_file(change)
+        end
+      end
+
+      def resolve_whole_suite(change)
+        @whole_suite = true
+        resolved(change, :whole_suite, "every test depends on it")
+      end
+
+      def resolve_base_class(change)
+        dir = Rules::BASE_CLASSES.fetch(change.path)
+        tests = (@map.test_files + head_files.to_a).uniq.select { |test| test.start_with?(dir) && Rules.test_file?(test) }
+        tests.each { |test| hit(test, :file, "inherits #{change.path}") }
+        resolved(change, :file, "every test under #{dir}")
+      end
+
+      def resolve_test(change)
+        return resolved(change, :quiet, "deleted test") if change.deleted?
+
+        hit(change.path, :changed_test, "the change edits this test")
+        resolved(change, :exact)
+      end
+
+      def resolve_fixture(change, name)
+        found = tests_mentioning("#{name}(:")
+        found.each { |test| hit(test, :reads_path, "uses the #{name} fixtures") }
+        model = "app/models/#{Rules.singularize(name.split("/").last)}.rb"
+        via = map_tests(model, :via_file, "tests #{model}, whose fixtures changed")
+        resolved(change, found.any? || via ? :convention : :unresolved, "fixtures #{name}")
+      end
+
+      def resolve_locale(change)
+        keys = LocaleKeys.at(@repo.read(change.path, @head), change.new_lines) |
+               LocaleKeys.at(@repo.read(change.old_path || change.path, @base), change.deleted? || change.status == :modified ? change.old_lines : [])
+        found = false
+        keys.each do |key|
+          tests_mentioning(key).each do |test|
+            hit(test, :asserts_key, "uses the key #{key}")
+            found = true
+          end
+          @repo.grep(key, paths: %w[app lib], rev: @head).each do |file|
+            found = true if map_tests(file, :via_file, "renders #{key} through #{file}")
+          end
+          Rules.views_for_key(key, head_files.to_a).each do |view|
+            found = true if resolve_view_like(view, "renders #{key} (lazy lookup) in #{view}")
+          end
+        end
+        resolved(change, found ? :convention : :unresolved, keys.empty? ? "no key found in the change" : "keys: #{keys.first(5).join(", ")}")
+      end
+
+      def resolve_migration(change)
+        source = @repo.read(change.path, @head) || ""
+        tables = Rules.tables_in(change.text)
+        if change.path.end_with?("schema.rb")
+          tables |= change.new_lines.filter_map { |line| Rules.schema_table_at(source, line) }
+        end
+        found = tables.any? do |table|
+          model = "app/models/#{Rules.singularize(table)}.rb"
+          by_map = map_tests(model, :via_file, "tests #{model}, whose table #{table} changed")
+          by_name = conventional(model)
+          by_map || by_name
+        end
+        resolved(change, found ? :convention : :unresolved, tables.empty? ? "no table found" : "tables: #{tables.join(", ")}")
+      end
+
+      def resolve_stimulus(change, name)
+        identifier = Rules.stimulus_identifier(name)
+        views = @repo.grep(identifier, paths: %w[app/views app/components app/helpers], rev: @head)
+        found = views.any? { |view| resolve_view_like(view, "uses the #{identifier} Stimulus controller through #{view}") }
+        resolved(change, found ? :convention : :unresolved, "Stimulus #{identifier}")
+      end
+
+      def resolve_routes(change)
+        found = Rules.controllers_in_routes(change.text).any? do |controller|
+          map_tests(controller, :via_file, "reaches #{controller}, whose routes changed") | conventional(controller)
+        end
+        resolved(change, found ? :convention : :unresolved, "routes")
+      end
+
+      def resolve_file(change)
+        reads = tests_mentioning(change.path)
+        reads.each { |test| hit(test, :reads_path, "reads #{change.path}") }
+        lookup = change.old_path || change.path
+
+        # A file the change adds cannot be in a map recorded before it; if the map knows it anyway
+        # (a map newer than the change, as when replaying history), using it would be hindsight.
+        if @map.known_file?(lookup) && !change.added?
+          resolve_mapped(change, lookup)
+        elsif change.path.start_with?("app/views/")
+          found = resolve_view_like(change.path, nil)
+          resolved(change, found || reads.any? ? :convention : :unresolved)
+        elsif Rules.ruby?(change.path) && Rules.constant_for(change.path)
+          resolve_by_name(change, reads.any?)
+        elsif reads.any?
+          resolved(change, :exact, "tests read it by path")
+        elsif Rules.quiet?(change.path)
+          resolved(change, :quiet, "no test reads it")
+        else
+          resolved(change, :unresolved, "not in the map and no rule matches")
+        end
+      end
+
+      # A file the map saw run. Changed lines inside methods select the tests that ran those
+      # methods; lines outside any method (class bodies, macros, constants) select every test that
+      # loaded the file.
+      def resolve_mapped(change, lookup)
+        if @granularity == :file && !change.deleted? && Rules.ruby?(lookup)
+          map_tests(lookup, :file, "loads #{lookup}")
+          conventional(lookup)
+          return resolved(change, :file)
+        end
+        if change.deleted? || !Rules.ruby?(lookup)
+          map_tests(lookup, change.deleted? ? :deleted_file : :view, change.deleted? ? "loaded #{lookup}, now deleted" : "rendered #{lookup}")
+          conventional(lookup)
+          return resolved(change, change.deleted? ? :exact : :file)
+        end
+
+        old_methods = Methods.of(@repo.read(lookup, @base))
+        map_version = map_source(lookup)
+        map_methods = map_version ? Methods.of(map_version) : nil
+        outside = false
+        untested = []
+        names = change.old_lines.map { |line| old_methods.enclosing(line)&.name }
+        outside = true if names.include?(nil) || change.old_lines.empty?
+        names.compact.uniq.each do |name|
+          definition = map_methods&.named(name)
+          next outside = true unless definition
+
+          body = definition.body.to_set
+          tests = @map.tests_for(lookup).select { |_test, lines| lines.any? { |line| body.include?(line) } }
+          untested << name if tests.empty?
+          tests.each_key { |test| hit(test, :method, "runs #{name}") }
+        end
+        conventional(lookup)
+        if outside
+          map_tests(lookup, :file, "loads #{lookup}")
+          resolved(change, :file, "changed outside a method the map knows")
+        elsif untested.any?
+          map_tests(lookup, :untested_method, "loads #{lookup}; no test runs #{untested.join(", ")}")
+          resolved(change, :file, "no test runs #{untested.join(", ")}")
+        else
+          resolved(change, :exact)
+        end
+      end
+
+      def resolve_by_name(change, found)
+        constant = Rules.constant_for(change.path)
+        found |= conventional(change.path)
+        tests_mentioning(constant).each do |test|
+          hit(test, :mentions_constant, "mentions #{constant}")
+          found = true
+        end
+        @repo.grep(constant, paths: %w[app lib], rev: @head).each do |file|
+          next if file == change.path
+
+          found = true if map_tests(file, :via_file, "reaches #{constant} through #{file}")
+        end
+        resolved(change, found ? :convention : :unresolved, constant)
+      end
+
+      def resolve_view_like(view, reason)
+        return map_tests(view, :view, reason || "renders #{view}") if @map.known_file?(view)
+
+        match = Rules::VIEW.match(view)
+        return false unless match
+
+        found = conventional(view)
+        dir = match[1]
+        controller = dir.end_with?("_mailer") ? "app/mailers/#{dir}.rb" : "app/controllers/#{dir}_controller.rb"
+        found |= map_tests(controller, :via_file, reason || "renders #{view} through #{controller}")
+        partial = "#{dir}/#{match[3]}"
+        if match[2] == "_"
+          @repo.grep(partial, paths: %w[app], rev: @head).each do |file|
+            found = true if map_tests(file, :via_file, reason || "renders the partial #{partial} through #{file}")
+          end
+        end
+        found
+      end
+
+      # Selects every test the map says loaded +file+; true when there was any. A file every test
+      # loads (a base class) tells little, so its weight shrinks with how widely it is loaded.
+      def map_tests(file, kind, reason)
+        tests = @map.tests_for(file)
+        return false if tests.empty?
+
+        weight = Rules::WEIGHT.fetch(kind) * (1 - (0.5 * @map.spread(file)))
+        tests.each_key { |test| @hits[test] << [weight, reason] }
+        true
+      end
+
+      def conventional(path)
+        found = false
+        Rules.conventional_tests(path).each do |test|
+          next unless @map.tests.key?(test) || head_has?(test)
+
+          hit(test, :conventional_test, "is the test for #{path}")
+          found = true
+        end
+        found
+      end
+
+      def tests_mentioning(needle)
+        @repo.grep(needle, paths: [Rules::TEST_ROOT], rev: @head).select { |file| Rules.test_file?(file) }
+      end
+
+      def map_source(path)
+        return nil if @map.commit.nil? || !@repo.commit?(@map.commit)
+
+        @repo.read(path, @map.commit)
+      end
+    end
+  end
+end

data/lib/minitest/impact/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Impact
+    VERSION = "0.1.0"
+  end
+end

data/lib/minitest/impact.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Impact
+    class Error < StandardError; end
+  end
+end
+
+require_relative "impact/version"
+require_relative "impact/recorder"
+require_relative "impact/map"
+require_relative "impact/repo"
+require_relative "impact/diff"
+require_relative "impact/methods"
+require_relative "impact/rules"
+require_relative "impact/locale_keys"
+require_relative "impact/jev/client"
+require_relative "impact/jev/questions"
+require_relative "impact/jev/ranker"
+require_relative "impact/selector"
+require_relative "impact/evaluation"
+require_relative "impact/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: minitest-impact
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bruno Costanzo
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Records which lines each Minitest test file executes, then, given a git diff, selects the test
+  files that ran the changed methods, plus the ones Rails conventions point to for views, copy,
+  routes and migrations. With a TypeSafe key, Jev re-ranks the selection and covers what the map
+  cannot see. Made for coding agents that should run a few tests in their loop and leave the full
+  suite to the final gate.
+executables:
+- minitest-impact
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- eval/ci_failures.rb
+- exe/minitest-impact
+- lib/minitest/impact.rb
+- lib/minitest/impact/cli.rb
+- lib/minitest/impact/diff.rb
+- lib/minitest/impact/evaluation.rb
+- lib/minitest/impact/jev/client.rb
+- lib/minitest/impact/jev/questions.rb
+- lib/minitest/impact/jev/ranker.rb
+- lib/minitest/impact/locale_keys.rb
+- lib/minitest/impact/map.rb
+- lib/minitest/impact/methods.rb
+- lib/minitest/impact/railtie.rb
+- lib/minitest/impact/rake_task.rb
+- lib/minitest/impact/record_bootstrap.rb
+- lib/minitest/impact/recorder.rb
+- lib/minitest/impact/recording_hooks.rb
+- lib/minitest/impact/repo.rb
+- lib/minitest/impact/rules.rb
+- lib/minitest/impact/selector.rb
+- lib/minitest/impact/version.rb
+homepage: https://github.com/bruno-costanzo/minitest-impact
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/bruno-costanzo/minitest-impact
+  changelog_uri: https://github.com/bruno-costanzo/minitest-impact/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Pick the Minitest tests a change is most likely to break, from a coverage
+  map and, optionally, Jev.
+test_files: []