scrap4rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9534e00ea290711ab140dcca603641ba180313ace9259a32c7b031cffaca788a
+  data.tar.gz: cd326a737dd566c651b5c25ef133415afe38d667756fb9138ae20cfbbb951709
+SHA512:
+  metadata.gz: a372446e785fa9b0d5b915577df54a1526e77821357c7971095ab3b859b72778c23e85c9a8b984934a208a4d2a31c1c3d4f5df5f2a1904544925f21b8e8e7ed7
+  data.tar.gz: 8af1af6f60679abb63c4e8ae1454176be74292096d6f45a78bcdbcfaa00ebe8e0013929488a408d00cb6f334888b0adc54d8f86102b474e131501f3467617a7f

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-02
+
+### Added
+- Initial release. A Ruby port of SCRAP by Robert C. Martin for Minitest
+  test files: structure errors, a SCRAP score and smells per test, fuzzy
+  duplication with extraction pressure, coverage-matrix detection, and per
+  file a refactor pressure, a remediation mode and an AI actionability class.
+- `scrap4rb` executable with `--all`, `--verbose`, `--json`,
+  `--write-baseline` and `--compare`.
+- Support for `test "..." do`, `def test_*`, `define_method(:"test_...")` and minitest/spec
+  `describe`/`it` blocks. A `define_method` test inside a loop over a table
+  (`CASES.each`) is one table-driven test that spans the loop.
+
+[Unreleased]: https://github.com/roberthopman/scrap4rb/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/roberthopman/scrap4rb/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Hopman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,161 @@
+# scrap4rb
+
+`scrap4rb` scores Minitest test code for structural quality. It is a Ruby port of [SCRAP](https://github.com/unclebob/scrap) by Robert C. Martin (Uncle Bob). SCRAP does for test code what CRAP does for production code: it finds the tests that are too large, too weak, too logic-heavy or too mock-heavy, and the duplicated scaffolding that is worth a helper.
+
+For each test file, scrap4rb answers three questions for a programmer or an AI assistant:
+
+  - Is this file poorly structured enough to refactor?
+  - Where is the worst structure: which tests, which lines?
+  - How to refactor: split the file, fix tests in place, make a table, or leave it alone?
+
+The output is advice, not a verdict. Read the file before you act on it.
+
+## Installation
+
+```bash
+gem install scrap4rb
+```
+
+Or add it to a Gemfile:
+
+```ruby
+gem "scrap4rb", group: :development
+```
+
+From a checkout you can run it without installing:
+
+```bash
+ruby -Ilib exe/scrap4rb path/to/project/test
+```
+
+## Usage
+
+Run it from the project root. The default path is `test`.
+
+```bash
+scrap4rb                                   # files that need attention, plus totals
+scrap4rb --all                             # every file, STABLE included
+scrap4rb --verbose test/models             # per-test metrics
+scrap4rb --json > scrap.json               # the full report as data
+scrap4rb test/models/order_test.rb         # one file
+```
+
+Before and after a refactor:
+
+```bash
+scrap4rb --write-baseline tmp/scrap.json
+# refactor the tests
+scrap4rb --compare tmp/scrap.json
+```
+
+The comparison gives each changed file a verdict: `improved`, `worse`, `mixed` or `unchanged`. When the verdict is `worse`, revert the refactor or simplify the helpers.
+
+## Output
+
+```
+test/models/smelly_test.rb
+  score 48.46 HIGH  mode LOCAL  ai AUTO_REFACTOR  tests=6 avg=12.78 max=18.26
+  HIGH   Strengthen assertions in weak tests before doing structural cleanup.
+  LOW    Be skeptical of helper extraction that only hides setup; ...
+   18.3  L59   it uses a long local helper          low-assertion-density,helper-hidden-complexity
+   17.3  L35   it handles a large payload           low-assertion-density,literal-heavy-setup
+   11.0  L8    it saves the record                  no-assertions
+  EXTRACT L4-17 net=31.74 (I=3 shared=22 variable=0): hours above 168 ... | negative hours ...
+```
+
+```
+Field      Meaning
+-----      -------
+score      Refactor pressure of the file
+level      STABLE, LOW, MEDIUM, HIGH or CRITICAL
+mode       STABLE: leave it. LOCAL: fix tests in place. SPLIT: split the file first
+ai         LEAVE_ALONE, AUTO_TABLE_DRIVE, AUTO_REFACTOR, MANUAL_SPLIT or REVIEW_FIRST
+HIGH/...   Recommendations, ranked by confidence, at most four
+tests      The SCRAP score of each test, worst first, with its smells
+EXTRACT    A group of tests where a shared helper pays for itself
+```
+
+## What it checks
+
+Structure errors:
+
+  - a `test` inside a `test`
+  - a `setup`, `teardown`, `describe`, `context` or `class` inside a test
+  - a second `def test_x` with the same name in one class (the first one never runs)
+  - parse errors
+
+Smells per test, with the SCRAP penalty:
+
+```
+Smell                      Fires when                                      Penalty
+-----                      ----------                                      -------
+no-assertions              the test has no assertion                       10
+low-assertion-density      one assertion in more than 10 lines              6
+multiple-phases            assert, act, assert again                        5
+high-mocking               more than 3 stubs or mocks                       4
+large-example              more than 20 lines                               4
+helper-hidden-complexity   more than 8 lines hidden in local helpers        4
+temp-resource-work         temporary files, threads or shell calls          3
+literal-heavy-setup        a string over 5 lines, a hash or array over 10   3
+```
+
+A short test with one or two assertions and few subjects is an "API contract" test. SCRAP excuses it from the low-assertion-density and large-example smells.
+
+Duplication is structural and fuzzy. Names and literal values become placeholders, so two tests that differ only in their numbers have the same shape. scrap4rb separates three kinds:
+
+  - **Harmful duplication**: repeated setup, arrange or assertion code. It becomes an EXTRACT recommendation only when a helper pays for itself after its own cost.
+  - **Coverage matrix**: many small, similar tests. The advice is "make it one table-driven test", not "this is bad".
+  - **Subject repetition**: many tests of the same API. This is normal and costs almost nothing.
+
+## How SCRAP maps to Minitest
+
+```
+SCRAP (speclj)          scrap4rb (Minitest)
+--------------          -------------------
+describe, context       a test class, or a minitest/spec describe block
+it                      test "..." do, def test_*, it "..." do, define_method(:"test_...")
+before, with            setup blocks and def setup, inherited by every test in the class
+let, binding            travel_to, freeze_time, within, using_session,
+                        perform_enqueued_jobs, with_*, and stub with a block
+with-redefs             stub, stub_request, any_instance, expects, stubs, Minitest::Mock.new
+should*                 assert*, refute*, must_*, wont_*
+doseq, for, every?      each, each_with_index, map, times, all?, ...
+if, when, cond, and     if, unless, case, while, until, &&, ||, rescue
+```
+
+The policy numbers (weights, thresholds, levels) are SCRAP's, unchanged.
+
+## Deviations from SCRAP
+
+  - A test whose whole body is one context block, such as `travel_to(...) do ... end`, is unwrapped before the phase count. In Ruby that block is test context, not arrange code.
+  - A call to an assertion helper defined in `test/test_helper.rb`, `test/application_system_test_case.rb`, `test/test_helpers/` or `test/support/` counts as one assertion. SCRAP only reads the spec file itself. Without this rule, every test that uses a shared assertion helper would be "no-assertions".
+  - A loop over a literal hash (`{ 5 => 0, 6 => 10 }.each`) counts as table-driven, the same as a loop over an array of arrays.
+
+## Notes for Rails suites
+
+Two SCRAP rules can disagree with common Rails practice. Decide for your own suite.
+
+  - **multiple-phases**: a system test that asserts after each click (to prove that the page changed before the next step) has several phases, and SCRAP gives it 5 points.
+  - **Low-assertion files**: a file is not STABLE when more than 35% of its tests have one assertion or fewer. A suite with "one behavior, one assertion" tests will have many LOCAL files for this reason only.
+
+## Development
+
+```bash
+bundle install
+rake test                      # unit tests and golden snapshots
+UPDATE_GOLDEN=1 rake test      # rewrite the snapshots after an intended change
+```
+
+The golden tests run the executable against the fixture suite in `test/fixtures/sample`. A golden diff means that the output changed. Accept it only when the change was intended.
+
+## Credits
+
+SCRAP is by Robert C. Martin (Uncle Bob): [github.com/unclebob/scrap](https://github.com/unclebob/scrap). The algorithm, the metrics, the smells and the policy numbers in scrap4rb come from SCRAP. scrap4rb is an independent Ruby implementation. It contains no SCRAP source code.
+
+scrap4rb 0.1.0 follows SCRAP at commit [`f793b28`](https://github.com/unclebob/scrap/tree/f793b28906d3c60e30b128e1ec08df6269a72b13) (2026-03-17). When SCRAP changes its rules or numbers, scrap4rb can differ until it follows again.
+
+Related tools by the same author: [crap4clj](https://github.com/unclebob/crap4clj), [crap4java](https://github.com/unclebob/crap4java), [crap4go](https://github.com/unclebob/crap4go) and [clj-mutate](https://github.com/unclebob/clj-mutate).
+
+## License
+
+scrap4rb is released under the MIT License. See [LICENSE](LICENSE). The license covers the code in this repository. It does not cover SCRAP itself.

data/exe/scrap4rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "scrap4rb"
+
+Scrap4rb::CLI.run(ARGV)

data/lib/scrap4rb/cli.rb

@@ -0,0 +1,130 @@
+require "json"
+require "digest"
+require "fileutils"
+require "optparse"
+require_relative "example"
+require_relative "structure"
+require_relative "summary"
+require_relative "judgment"
+
+module Scrap4rb
+  module CLI
+    extend self
+
+    LABEL = { 3 => "HIGH", 2 => "MEDIUM", 1 => "LOW" }.freeze
+
+    def run(argv)
+      opts = parse(argv)
+      files = (argv.empty? ? ["test"] : argv).flat_map { File.directory?(_1) ? Dir["#{_1}/**/*_test.rb"] : [_1] }.sort
+      shared = Example.shared_assert_helpers(Dir.pwd)
+      reports = files.map { analyze_file(_1, shared) }
+      write_baseline(opts[:write], reports) if opts[:write]
+      return puts(JSON.pretty_generate(json_safe(reports))) if opts[:json]
+
+      reports.each { print_report(_1, verbose: opts[:verbose]) if opts[:all] || _1[:mode] != "STABLE" || _1[:errors].any? }
+      print_comparison(opts[:compare], reports) if opts[:compare]
+      print_totals(files, reports)
+    end
+
+    def parse(argv)
+      opts = {}
+      OptionParser.new do |o|
+        o.banner = "Usage: scrap4rb [options] [paths...]   (default path: test)"
+        o.on("--all", "Show STABLE files too") { opts[:all] = true }
+        o.on("--verbose", "Show per-test metrics") { opts[:verbose] = true }
+        o.on("--json", "Print the full report as JSON") { opts[:json] = true }
+        o.on("--write-baseline FILE", "Write a baseline document to FILE") { opts[:write] = _1 }
+        o.on("--compare FILE", "Compare with a baseline document") { opts[:compare] = _1 }
+        o.on("-v", "--version", "Show the version") { puts VERSION; exit }
+        o.on("-h", "--help", "Show this help") { puts o; exit }
+      end.parse!(argv)
+      opts
+    end
+
+    def analyze_file(path, shared_asserts)
+      src = File.read(path)
+      result = Prism.parse(src)
+      exs = Example.from_tree(result.value, shared_assert_helpers: shared_asserts)
+      summary = Summary.summarize(exs)
+      blocks = exs.group_by { _1[:describe_path] }.reject { |p, _| p.empty? }.map { |p, b| { path: p, summary: Summary.summarize(b) } }
+      mode = Judgment.remediation_mode(summary, blocks)
+      { path:, content_hash: Digest::SHA256.hexdigest(src)[0, 16], errors: Structure.errors(result), examples: exs, summary:,
+        file_score: Judgment.pressure_score(summary), level: Judgment.level(summary), mode:,
+        ai: Judgment.actionability(summary, mode), actions: Judgment.actions(summary, mode) }
+    end
+
+    def print_report(r, verbose:)
+      s = r[:summary]
+      puts "\n#{r[:path]}"
+      r[:errors].each { puts "  #{_1}" }
+      puts "  score #{r[:file_score]} #{r[:level]}  mode #{r[:mode]}  ai #{r[:ai]}  tests=#{s[:example_count]} avg=#{s[:avg_scrap]} max=#{s[:max_scrap]}"
+      r[:actions].each { |c, t| puts "  #{LABEL[c].ljust(6)} #{t}" }
+      worst = r[:examples].sort_by { -_1[:scrap] }
+      worst = worst.first(5) unless verbose
+      worst.each { puts example_line(_1, verbose) }
+      s[:recommended_extractions].each do |x|
+        puts "  EXTRACT L#{x[:line_start]}-#{x[:line_end]} net=#{x[:net_benefit]} (I=#{x[:instances]} shared=#{x[:shared_forms]} variable=#{x[:variable_points]}): " +
+             x[:examples].map { _1[:name].to_s[0, 40] }.join(" | ")
+      end
+    end
+
+    def example_line(e, verbose)
+      extra = if verbose
+                "  [a=#{e[:assertions]} b=#{e[:branches]} d=#{e[:setup_depth]} stub=#{e[:with_redefs]} h=#{e[:helper_calls]} " \
+                  "hh=#{e[:helper_hidden_lines]} ph=#{e[:phases]}#{" table" if e[:table_driven]}#{" api" if e[:api_contract]}]"
+              else
+                ""
+              end
+      format("  %5.1f  L%-4d %-58s %s%s", e[:scrap], e[:line], e[:name].to_s[0, 58], e[:smells].join(","), extra)
+    end
+
+    def write_baseline(file, reports)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.write(file, JSON.pretty_generate(version: 1, reports: reports.map { json_safe(_1.slice(:path, :content_hash, :summary)) }))
+    end
+
+    def compare(baseline, reports)
+      before = baseline["reports"].to_h { [_1["path"], _1["summary"].transform_keys(&:to_sym)] }
+      reports.filter_map do |r|
+        b = before[r[:path]] or next
+        a = r[:summary]
+        cmp = { file_score_delta: (Judgment.pressure_score(a) - Judgment.pressure_score(b)).round(2),
+                max_scrap_delta: (a[:max_scrap] - b[:max_scrap]).round(2),
+                extraction_pressure_delta: (a[:effective_duplication_score] - b[:effective_duplication_score]).round(2),
+                case_matrix_delta: a[:case_matrix_repetition] - b[:case_matrix_repetition],
+                helper_hidden_delta: a[:helper_hidden_example_count] - b[:helper_hidden_example_count] }
+        [r[:path], cmp.merge(verdict: Judgment.verdict(cmp))]
+      end
+    end
+
+    def print_comparison(file, reports)
+      puts "\nComparison with #{file}:"
+      compare(JSON.parse(File.read(file)), reports).each do |path, c|
+        next if c[:verdict] == "unchanged"
+        puts "  #{c[:verdict].ljust(9)} #{path}  #{c.except(:verdict).map { "#{_1}=#{_2}" }.join(" ")}"
+        puts "            the refactor made it worse: revert it, or simplify the helpers" if c[:verdict] == "worse"
+      end
+    end
+
+    def print_totals(files, reports)
+      exs = reports.flat_map { _1[:examples] }
+      tally = ->(values) { values.tally.sort.map { "#{_1}=#{_2}" }.join(" ") }
+      puts "\n#{files.size} files, #{exs.size} tests, #{reports.sum { _1[:errors].size }} structure errors"
+      puts "modes:   " + tally.(reports.map { _1[:mode] })
+      puts "ai:      " + tally.(reports.map { _1[:ai] })
+      puts "levels:  " + tally.(reports.map { _1[:level] })
+      puts "smells:  " + exs.flat_map { _1[:smells] }.tally.sort_by { -_2 }.map { "#{_1}=#{_2}" }.join(" ")
+      puts "extractions recommended: #{reports.sum { _1[:summary][:recommended_extraction_count] }}, " \
+           "table-drive candidates: #{reports.sum { _1[:summary][:coverage_matrix_candidates] }}"
+    end
+
+    def json_safe(value)
+      case value
+      when Set then value.to_a
+      when Hash then value.to_h { [_1, json_safe(_2)] }
+      when Array then value.map { json_safe(_1) }
+      else value
+      end
+    end
+  end
+end

data/lib/scrap4rb/example.rb

@@ -0,0 +1,195 @@
+require_relative "syntax"
+require_relative "policy"
+
+module Scrap4rb
+  module Example
+    include Syntax
+    extend self
+
+    SHARED_HELPER_GLOBS = %w[test/test_helper.rb test/application_system_test_case.rb test/test_helpers/**/*.rb test/support/**/*.rb].freeze
+
+    EMPTY = { assertions: 0, branches: 0, table_branches: 0, with_redefs: 0, helper_calls: 0, helper_hidden_lines: 0,
+              temp_resources: 0, large_literals: 0, max_setup_depth: 0, subject_symbols: Set.new.freeze, table_driven: false }.freeze
+
+    Context = Struct.new(:helpers, :shared_assert_helpers, :cache)
+
+    def from_source(src, shared_assert_helpers:)
+      from_tree(Prism.parse(src).value, shared_assert_helpers:)
+    end
+
+    def from_tree(tree, shared_assert_helpers:)
+      collect(statements(tree.statements), Context.new(helper_defs(tree), shared_assert_helpers, {}))
+    end
+
+    def shared_assert_helpers(root)
+      SHARED_HELPER_GLOBS.flat_map { Dir[File.join(root, _1)] }.flat_map do |file|
+        descendants(Prism.parse_file(file).value).select do |d|
+          d.is_a?(Prism::DefNode) && descendants(d).any? { assertion?(_1) }
+        end.map(&:name)
+      end.to_set
+    end
+
+    def saturating(complexity)
+      c = Policy::COMPLEXITY
+      return c[:floor] if complexity <= 1
+      c[:floor] + (c[:cap] - c[:floor]) * (1.0 - Math.exp(-c[:rise_rate] * (complexity - 1)))
+    end
+
+    def combine(*metrics)
+      metrics.reduce(EMPTY) do |acc, m|
+        {
+          assertions: acc[:assertions] + m.fetch(:assertions, 0),
+          branches: acc[:branches] + m.fetch(:branches, 0),
+          table_branches: acc[:table_branches] + m.fetch(:table_branches, 0),
+          with_redefs: acc[:with_redefs] + m.fetch(:with_redefs, 0),
+          helper_calls: acc[:helper_calls] + m.fetch(:helper_calls, 0),
+          helper_hidden_lines: acc[:helper_hidden_lines] + m.fetch(:helper_hidden_lines, 0),
+          temp_resources: acc[:temp_resources] + m.fetch(:temp_resources, 0),
+          large_literals: acc[:large_literals] + m.fetch(:large_literals, 0),
+          max_setup_depth: [acc[:max_setup_depth], m.fetch(:max_setup_depth, 0)].max,
+          subject_symbols: acc[:subject_symbols] | m.fetch(:subject_symbols, Set.new),
+          table_driven: acc[:table_driven] || m.fetch(:table_driven, false)
+        }
+      end
+    end
+
+    def analyze(node, ctx, depth, stack)
+      helper = bare_call?(node) && ctx.helpers.key?(node.name)
+      shared_assert = bare_call?(node) && !helper && ctx.shared_assert_helpers.include?(node.name)
+      next_depth = context_head?(node) ? depth + 1 : depth
+      children = kids(node).map { analyze(_1, ctx, next_depth, stack) }
+      expanded = helper && !stack.include?(node.name) ? expand(ctx, node.name, stack | [node.name], depth) : nil
+      local = {
+        assertions: assertion?(node) || shared_assert ? 1 : 0,
+        branches: BRANCH_NODES.any? { node.is_a?(_1) } ? 1 : 0,
+        table_branches: call?(node) && TABLE_CALLS.include?(node.name) && node.block ? 1 : 0,
+        with_redefs: stub_call?(node) ? 1 : 0,
+        helper_calls: helper ? 1 : 0,
+        temp_resources: temp_resource?(node) ? 1 : 0,
+        large_literals: large_literal?(node) ? 1 : 0,
+        max_setup_depth: depth,
+        subject_symbols: subject_symbols(node, helper),
+        table_driven: table_driven_form?(node)
+      }
+      combine(local, *children, *[expanded].compact)
+    end
+
+    def subject_symbols(node, helper)
+      return Set.new unless call?(node) && !helper && !control_call?(node)
+      recv = node.receiver
+      constant = recv.is_a?(Prism::ConstantReadNode) || recv.is_a?(Prism::ConstantPathNode)
+      Set[constant ? "#{recv.slice}.#{node.name}" : node.name.to_s]
+    end
+
+    def expand(ctx, name, stack, depth)
+      ctx.cache[[name, depth]] ||= begin
+        body = ctx.helpers[name]
+        hidden = body.sum { [1, lines_of(_1)].max }
+        combine({ helper_hidden_lines: hidden }, *body.map { analyze(_1, ctx, depth, stack) })
+      end
+    end
+
+    def top_forms(body)
+      forms = body
+      forms = block_body(forms.first) while forms.size == 1 && context_head?(forms.first)
+      forms
+    end
+
+    def phase(form, ctx)
+      return :setup if context_head?(form)
+      analyze(form, ctx, 0, Set.new)[:assertions].positive? ? :assert : :action
+    end
+
+    def assertion_clusters(forms, ctx) = forms.map { phase(_1, ctx) }.chunk_while { _1 == _2 }.count { _1.first == :assert }
+
+    def api_contract?(m, line_count, phases)
+      m[:assertions] <= 2 && m[:branches] + m[:table_branches] <= 4 && m[:table_branches] <= 1 &&
+        m[:with_redefs] <= 0 && m[:helper_calls] <= 1 && m[:helper_hidden_lines] <= 0 && m[:temp_resources] <= 0 &&
+        m[:large_literals] <= 0 && m[:subject_symbols].size <= 4 && phases <= 1 && line_count <= 18
+    end
+
+    def smells(m, line_count, phases, table_driven, api_contract)
+      [
+        [m[:assertions].zero?, "no-assertions", 10],
+        [m[:assertions] == 1 && line_count > 10 && !table_driven && !api_contract, "low-assertion-density", 6],
+        [phases > 1, "multiple-phases", 5],
+        [m[:with_redefs] > 3, "high-mocking", 4],
+        [line_count > 20 && !api_contract, "large-example", 4],
+        [m[:temp_resources].positive?, "temp-resource-work", 3],
+        [m[:large_literals].positive?, "literal-heavy-setup", 3],
+        [m[:helper_hidden_lines] > 8, "helper-hidden-complexity", 4]
+      ].select(&:first).map { { label: _2, penalty: _3 } }
+    end
+
+    def score(name:, node:, body:, ctx:, inherited_setup:, describe_path:, table_driven: false)
+      m = combine(*body.map { analyze(_1, ctx, inherited_setup.size, Set.new) }, { table_driven: })
+      raw_lines = lines_of(node)
+      line_count = raw_lines + m[:helper_hidden_lines]
+      forms = top_forms(body)
+      phases = assertion_clusters(forms, ctx)
+      api = api_contract?(m, line_count, phases)
+      setup_depth = api ? [0, m[:max_setup_depth] - 2].max : m[:max_setup_depth]
+      branch_penalty = m[:table_driven] ? m[:table_branches] : m[:branches] + m[:table_branches]
+      branch_penalty = [0, branch_penalty - 2].max if api
+      found = smells(m, line_count, phases, m[:table_driven], api)
+      complexity_score = saturating(1 + branch_penalty + setup_depth + m[:helper_calls])
+
+      setup = inherited_setup + forms.select { context_head?(_1) }
+      asserts = forms.select { phase(_1, ctx) == :assert }
+      arrange = forms.reject { phase(_1, ctx) == :assert }
+      setup_signatures = form_signatures(setup)
+      literal_signatures = body.flat_map { large_literal_signatures(_1) }
+      {
+        name:, describe_path:, line: node.location.start_line, end_line: node.location.end_line,
+        line_count:, raw_line_count: raw_lines, assertions: m[:assertions],
+        branches: m[:branches] + m[:table_branches], setup_depth: m[:max_setup_depth], with_redefs: m[:with_redefs],
+        helper_calls: m[:helper_calls], helper_hidden_lines: m[:helper_hidden_lines], temp_resources: m[:temp_resources],
+        table_driven: m[:table_driven], api_contract: api, phases:,
+        complexity: 1 + m[:branches] + m[:max_setup_depth] + m[:helper_calls] + m[:helper_hidden_lines] / 8,
+        complexity_score: complexity_score.round(2),
+        subject_symbols: m[:subject_symbols],
+        assert_signatures: form_signatures(asserts), assert_features: form_features(asserts),
+        setup_signatures:, setup_features: form_features(setup),
+        arrange_signatures: form_signatures(arrange), arrange_features: form_features(arrange),
+        literal_signatures:,
+        fixture_features: setup_signatures.empty? ? Set.new : shape_features(setup_signatures.map { :string }.unshift(:vec)),
+        scrap: (complexity_score + found.sum { _1[:penalty] }).round(2),
+        smells: found.map { _1[:label] },
+        literal_features: literal_signatures.to_set
+      }
+    end
+
+    def setup_forms(scope_body)
+      scope_body.flat_map do |n|
+        if bare_call?(n) && SETUP_CALLS.include?(n.name) && n.block.is_a?(Prism::BlockNode) then block_body(n)
+        elsif n.is_a?(Prism::DefNode) && n.name == :setup then statements(n.body).reject { bare_call?(_1) && _1.name == :super }
+        else []
+        end
+      end
+    end
+
+    def test_body(node) = node.is_a?(Prism::DefNode) ? statements(node.body) : block_body(node)
+
+    def collect(forms, ctx, path = [], inherited = [], out = [])
+      setup = inherited + setup_forms(forms)
+      forms.each do |f|
+        if (name, body = scope_children(f))
+          collect(body, ctx, path + [name], setup, out)
+        elsif test_node?(f)
+          out << score(name: test_name(f), node: f, body: test_body(f), ctx:, inherited_setup: setup, describe_path: path)
+        elsif (inner = dynamic_test_in_loop(f))
+          out << score(name: dynamic_test_name(inner), node: f, body: block_body(inner), ctx:, inherited_setup: setup,
+                       describe_path: path, table_driven: true)
+        elsif dynamic_test?(f)
+          out << score(name: dynamic_test_name(f), node: f, body: block_body(f), ctx:, inherited_setup: setup, describe_path: path)
+        end
+      end
+      out
+    end
+
+    def helper_defs(tree)
+      descendants(tree).select { _1.is_a?(Prism::DefNode) && !_1.name.start_with?("test_") && !%i[setup teardown].include?(_1.name) }
+                       .to_h { [_1.name, statements(_1.body)] }
+    end
+  end
+end

data/lib/scrap4rb/judgment.rb

@@ -0,0 +1,111 @@
+require_relative "policy"
+
+module Scrap4rb
+  module Judgment
+    extend self
+
+    def ratio(n, d) = d.positive? ? n.fdiv(d) : 0.0
+
+    def stable?(s)
+      n = s[:example_count]
+      zero = ratio(s[:zero_assertion_examples], n)
+      low = ratio(s[:low_assertion_examples], n)
+      small = n <= 2 && s[:max_scrap] <= 10 && s[:effective_duplication_score] <= 1 && s[:helper_hidden_example_count].zero? && zero <= 0
+      general = n.positive? && s[:max_scrap] <= 12 && s[:effective_duplication_score] <= 3 && zero <= 0 && low <= 0.35
+      small || general
+    end
+
+    def pressure_score(s)
+      n = s[:example_count]
+      w = Policy::PRESSURE[:weights]
+      base = w[:avg_scrap] * s[:avg_scrap] + w[:max_scrap] * s[:max_scrap] +
+             w[:effective_duplication_score] * s[:effective_duplication_score] +
+             w[:low_assertion_ratio] * ratio(s[:low_assertion_examples], n) +
+             w[:branching_ratio] * ratio(s[:branching_examples], n) +
+             w[:with_redefs_ratio] * ratio(s[:with_redefs_examples], n) +
+             w[:helper_hidden_ratio] * ratio(s[:helper_hidden_example_count], n)
+      factor = Policy::PRESSURE[:size_factors].find { |up_to, _| up_to.nil? || n <= up_to }.last
+      [0, factor * base - Policy::PRESSURE[:matrix_credit] * s[:case_matrix_repetition]].max.round(2)
+    end
+
+    def level(s)
+      score = pressure_score(s)
+      l = Policy::PRESSURE[:levels]
+      if stable?(s) then "STABLE"
+      elsif score >= l[:critical] then "CRITICAL"
+      elsif score >= l[:high] then "HIGH"
+      elsif score >= l[:medium] then "MEDIUM"
+      else "LOW"
+      end
+    end
+
+    def remediation_mode(s, blocks)
+      sp = Policy::PRESSURE[:split]
+      hot_blocks = blocks.count { %w[HIGH CRITICAL].include?(level(_1[:summary])) }
+      split_pressure = s[:avg_scrap] >= sp[:avg_scrap] || s[:effective_duplication_score] >= sp[:effective_duplication_score] ||
+                       s[:subject_repetition_score] >= sp[:subject_repetition_score] || s[:helper_hidden_example_count].positive?
+      if stable?(s) then "STABLE"
+      elsif s[:example_count] >= sp[:example_count] && (hot_blocks >= sp[:high_pressure_blocks] || s[:max_scrap] >= sp[:max_scrap]) && split_pressure
+        "SPLIT"
+      else "LOCAL"
+      end
+    end
+
+    def ratios(s)
+      n = s[:example_count]
+      { low: ratio(s[:low_assertion_examples], n), zero: ratio(s[:zero_assertion_examples], n),
+        branching: ratio(s[:branching_examples], n), mocking: ratio(s[:with_redefs_examples], n) }
+    end
+
+    def actionability(s, mode)
+      if mode == "STABLE" then "LEAVE_ALONE"
+      elsif matrix_heavy?(s) then "AUTO_TABLE_DRIVE"
+      elsif local_safe?(s, mode) then "AUTO_REFACTOR"
+      elsif mode == "SPLIT" then "MANUAL_SPLIT"
+      else "REVIEW_FIRST"
+      end
+    end
+
+    def matrix_heavy?(s)
+      r = ratios(s)
+      m = Policy::ACTIONABILITY[:matrix]
+      s[:coverage_matrix_candidates].positive? &&
+        s[:case_matrix_repetition] >= [m[:min_case_matrix_repetition], (s[:effective_duplication_score] / m[:effective_duplication_divisor]).floor].max &&
+        s[:max_scrap] <= m[:max_scrap] && r[:branching] <= m[:max_branching_ratio] && r[:mocking] < m[:max_mocking_ratio]
+    end
+
+    def local_safe?(s, mode)
+      r = ratios(s)
+      l = Policy::ACTIONABILITY[:local]
+      mode == "LOCAL" &&
+        (s[:effective_duplication_score].positive? || r[:zero].positive? || r[:low] > l[:low_assertion_ratio] || s[:max_scrap] > l[:max_scrap]) &&
+        r[:branching] <= l[:max_branching_ratio] && r[:mocking] < l[:max_mocking_ratio]
+    end
+
+    def actions(s, mode)
+      return [[3, "No refactor recommended; the file is structurally stable enough to leave alone."]] if mode == "STABLE"
+      r = ratios(s)
+      l = Policy::ACTIONABILITY[:local]
+      [
+        [mode == "SPLIT", 3, "Split this test file by responsibility before attempting local cleanup; the structural pressure is spread across multiple hotspots."],
+        [s[:coverage_matrix_candidates].positive?, 3, "Convert repeated low-complexity tests into table-driven checks; treat this as coverage-matrix repetition, not harmful duplication."],
+        [r[:zero].positive? || r[:low] > l[:low_assertion_ratio], 3, "Strengthen assertions in weak tests before doing structural cleanup."],
+        [mode == "LOCAL" && s[:max_scrap] > l[:max_scrap], 3, "Split oversized tests into narrower tests."],
+        [s[:effective_duplication_score].positive?, 2, "Extract shared setup or repeated assertion scaffolding only where harmful duplication is dominating."],
+        [r[:mocking] > l[:max_mocking_ratio], 2, "Reduce mocking and move coverage toward higher-level behaviors."],
+        [r[:branching] > l[:max_branching_ratio], 2, "Remove logic from tests or keep variation in explicit data tables rather than control flow."],
+        [s[:helper_hidden_example_count].positive?, 1, "Be skeptical of helper extraction that only hides setup; helper-hidden complexity should still count as complexity."],
+        [mode == "LOCAL" && s[:avg_scrap] > l[:avg_scrap], 1, "Consider splitting this file or block by responsibility."]
+      ].select(&:first).map { _1.drop(1) }.sort_by { [-_1[0], _1[1]] }.first(Policy::ACTIONABILITY[:max_actions])
+    end
+
+    def verdict(c)
+      if c[:file_score_delta] <= -5 && c[:extraction_pressure_delta] <= 0 && c[:max_scrap_delta] <= 0 then "improved"
+      elsif c[:helper_hidden_delta].positive? && c[:extraction_pressure_delta] >= 0 && c[:case_matrix_delta] <= 0 then "worse"
+      elsif c[:extraction_pressure_delta].positive? || c[:max_scrap_delta].positive? || c[:file_score_delta] >= 5 then "worse"
+      elsif c[:file_score_delta].zero? then "unchanged"
+      else "mixed"
+      end
+    end
+  end
+end

data/lib/scrap4rb/policy.rb

@@ -0,0 +1,23 @@
+module Scrap4rb
+  module Policy
+    DUPLICATION = { threshold: 0.5, matrix_max_scrap: 18, matrix_max_lines: 12, matrix_max_assertions: 1,
+                    matrix_max_branches: 0, matrix_max_setup_depth: 2, matrix_max_with_redefs: 0,
+                    matrix_max_temp_resources: 0, matrix_max_helper_hidden_lines: 0, matrix_max_subject_symbols: 2 }.freeze
+    COMPLEXITY = { cap: 25.0, rise_rate: 0.18, floor: 1.0 }.freeze
+    PRESSURE = {
+      size_factors: [[1, 0.25], [2, 0.40], [4, 0.65], [nil, 1.0]],
+      weights: { avg_scrap: 1.2, max_scrap: 0.6, effective_duplication_score: 0.8, low_assertion_ratio: 20,
+                 branching_ratio: 15, with_redefs_ratio: 15, helper_hidden_ratio: 12 },
+      matrix_credit: 1.5,
+      levels: { critical: 55, high: 35, medium: 18 },
+      split: { avg_scrap: 10, effective_duplication_score: 20, subject_repetition_score: 12, example_count: 12,
+               high_pressure_blocks: 2, max_scrap: 35 }
+    }.freeze
+    ACTIONABILITY = {
+      matrix: { min_case_matrix_repetition: 2, effective_duplication_divisor: 3, max_scrap: 12,
+                max_branching_ratio: 0.15, max_mocking_ratio: 0.2 },
+      local: { low_assertion_ratio: 0.4, max_branching_ratio: 0.3, max_mocking_ratio: 0.35, max_scrap: 20, avg_scrap: 12 },
+      max_actions: 4
+    }.freeze
+  end
+end

data/lib/scrap4rb/structure.rb

@@ -0,0 +1,42 @@
+require_relative "syntax"
+
+module Scrap4rb
+  module Structure
+    include Syntax
+    extend self
+
+    INSIDE_TEST_ERRORS = %i[test it specify setup teardown before after describe context].to_set
+
+    def errors(result)
+      parse_errors(result) + nesting_errors(result.value) + duplicate_name_errors(result.value)
+    end
+
+    def parse_errors(result) = result.errors.map { "ERROR line #{_1.location.start_line}: parse error: #{_1.message}" }
+
+    def nesting_errors(node, parent = nil, out = [])
+      if parent && misplaced?(node)
+        label = node.is_a?(Prism::ClassNode) ? "class" : node.name
+        out << "ERROR line #{node.location.start_line}: (#{label}) inside (#{parent[:form]}) at line #{parent[:line]}"
+      end
+      inner = test_node?(node) ? { form: node.is_a?(Prism::DefNode) ? "def #{node.name}" : node.name, line: node.location.start_line } : parent
+      kids(node).each { nesting_errors(_1, inner, out) }
+      out
+    end
+
+    def misplaced?(node)
+      test_node?(node) || (bare_call?(node) && INSIDE_TEST_ERRORS.include?(node.name) && node.block) ||
+        node.is_a?(Prism::ClassNode) || (node.is_a?(Prism::DefNode) && node.name == :setup)
+    end
+
+    def duplicate_name_errors(tree)
+      scopes = [tree] + descendants(tree).select { _1.is_a?(Prism::ClassNode) || (call?(_1) && BLOCK_CALLS.include?(_1.name)) }
+      scopes.flat_map do |scope|
+        body = scope.is_a?(Prism::ProgramNode) ? scope.statements.body : (scope_children(scope)&.last || [])
+        body.select { test_node?(_1) }.group_by { method_name_of(_1) }.filter_map do |name, nodes|
+          next if nodes.size < 2
+          "ERROR line #{nodes.last.location.start_line}: #{name} is defined again; line #{nodes.first.location.start_line} never runs"
+        end
+      end
+    end
+  end
+end

data/lib/scrap4rb/summary.rb

@@ -0,0 +1,131 @@
+require "set"
+require_relative "policy"
+
+module Scrap4rb
+  module Summary
+    extend self
+
+    def jaccard(a, b)
+      union = a | b
+      union.empty? ? 0.0 : (a & b).size.fdiv(union.size)
+    end
+
+    def duplication_cost(shared, instances, variable)
+      return 0.0 if shared <= 3 || variable > 4
+      (shared - 3) * (instances - 1)**1.5 / (variable + 1)
+    end
+
+    def summarize(exs)
+      total = exs.size
+      recs = extractions(exs)
+      matrix = coverage_matrix_count(exs)
+      dup = %i[setup assert fixture literal arrange].to_h { [_1, similar_count(exs, :"#{_1}_features")] }
+      pressure = recs.sum { _1[:net_benefit] }.round(2)
+      {
+        example_count: total,
+        avg_scrap: total.positive? ? (exs.sum { _1[:scrap] } / total).round(2) : 0.0,
+        max_scrap: exs.map { _1[:scrap] }.max || 0,
+        branching_examples: exs.count { _1[:branches].positive? && !_1[:table_driven] },
+        low_assertion_examples: exs.count { _1[:assertions] <= 1 },
+        with_redefs_examples: exs.count { _1[:with_redefs].positive? },
+        zero_assertion_examples: exs.count { _1[:assertions].zero? },
+        helper_hidden_example_count: exs.count { _1[:helper_hidden_lines].positive? },
+        table_driven_examples: exs.count { _1[:table_driven] },
+        setup_duplication_score: dup[:setup], assertion_duplication_score: dup[:assert],
+        fixture_duplication_score: dup[:fixture], literal_duplication_score: dup[:literal],
+        arrange_duplication_score: dup[:arrange],
+        subject_repetition_score: similar_count(exs, :subject_symbols),
+        duplication_score: dup.values.sum,
+        harmful_duplication_score: dup.values_at(:setup, :assert, :fixture, :arrange).sum,
+        avg_setup_similarity: average_similarity(exs, :setup_features).round(3),
+        avg_assert_similarity: average_similarity(exs, :assert_features).round(3),
+        avg_arrange_similarity: average_similarity(exs, :arrange_features).round(3),
+        avg_subject_similarity: average_similarity(exs, :subject_symbols).round(3),
+        coverage_matrix_candidates: matrix, case_matrix_repetition: matrix,
+        recommended_extraction_count: recs.size,
+        extraction_pressure_score: pressure,
+        effective_duplication_score: pressure,
+        recommended_extractions: recs
+      }
+    end
+
+    def extractions(exs)
+      components(exs).reject { |c| c.all? { extraction_matrix?(_1) } }.map { extraction(_1) }
+                     .select { _1[:net_benefit].positive? }.sort_by { [_1[:line_start], -_1[:net_benefit]] }
+    end
+
+    def similar_to_any?(ex, exs, key) = ex[key].any? && exs.any? { !_1.equal?(ex) && jaccard(ex[key], _1[key]) >= Policy::DUPLICATION[:threshold] }
+    def similar_count(exs, key) = exs.count { similar_to_any?(_1, exs, key) }
+
+    def average_similarity(exs, key)
+      pairs = exs.combination(2).map { jaccard(_1[key], _2[key]) }
+      pairs.empty? ? 0.0 : pairs.sum / pairs.size
+    end
+
+    def harmful_features(ex) = ex[:setup_features] | ex[:assert_features] | ex[:fixture_features] | ex[:arrange_features]
+
+    def matrix_base?(ex)
+      d = Policy::DUPLICATION
+      ex[:scrap] <= d[:matrix_max_scrap] && ex[:line_count] <= d[:matrix_max_lines] && ex[:assertions] <= d[:matrix_max_assertions] &&
+        ex[:branches] <= d[:matrix_max_branches] && ex[:setup_depth] <= d[:matrix_max_setup_depth] &&
+        ex[:with_redefs] <= d[:matrix_max_with_redefs] && ex[:temp_resources] <= d[:matrix_max_temp_resources] &&
+        ex[:helper_hidden_lines] <= d[:matrix_max_helper_hidden_lines]
+    end
+
+    def few_subjects?(ex) = ex[:subject_symbols].size <= Policy::DUPLICATION[:matrix_max_subject_symbols]
+
+    def extraction_matrix?(ex) = matrix_base?(ex) && (ex[:table_driven] || (few_subjects?(ex) && harmful_features(ex).any?))
+
+    def summary_matrix?(ex)
+      matrix_base?(ex) && (ex[:table_driven] || (few_subjects?(ex) && (ex[:assert_features].any? || ex[:arrange_features].any?)))
+    end
+
+    def coverage_matrix_count(exs)
+      exs.count do |ex|
+        summary_matrix?(ex) && (similar_to_any?(ex, exs, :setup_features) || similar_to_any?(ex, exs, :arrange_features) ||
+                                (similar_to_any?(ex, exs, :assert_features) && similar_to_any?(ex, exs, :subject_symbols)))
+      end
+    end
+
+    def components(exs)
+      features = exs.map { harmful_features(_1) }
+      adjacency = Hash.new { |h, k| h[k] = Set.new }
+      exs.each_index.to_a.combination(2).each do |i, j|
+        next unless jaccard(features[i], features[j]) >= Policy::DUPLICATION[:threshold]
+        adjacency[i] << j
+        adjacency[j] << i
+      end
+      seen = Set.new
+      exs.each_index.filter_map do |start|
+        next if seen.include?(start)
+        component = reachable(start, adjacency)
+        seen.merge(component)
+        component.sort.map { exs[_1] } if component.size > 1
+      end
+    end
+
+    def reachable(start, adjacency)
+      component = Set.new
+      stack = [start]
+      until stack.empty?
+        i = stack.pop
+        next if component.include?(i)
+        component << i
+        stack.concat(adjacency[i].to_a)
+      end
+      component
+    end
+
+    def extraction(cluster)
+      sets = cluster.map { harmful_features(_1) }
+      shared = sets.reduce(:&).size
+      variable = sets.reduce(:|).size - shared
+      before = duplication_cost(shared, cluster.size, variable)
+      helper_cost = shared + variable
+      { examples: cluster.map { _1.slice(:name, :line, :end_line) }, line_start: cluster.map { _1[:line] }.min,
+        line_end: cluster.map { _1[:end_line] }.max, instances: cluster.size, shared_forms: shared,
+        variable_points: variable, duplication_before: before.round(2), helper_cost:,
+        net_benefit: [0.0, before - helper_cost].max.round(2) }
+    end
+  end
+end

data/lib/scrap4rb/syntax.rb

@@ -0,0 +1,168 @@
+require "prism"
+require "set"
+
+module Scrap4rb
+  module Syntax
+    ASSERTION = /\A(assert|refute|must_|wont_)/
+    CONTEXT_CALLS = %i[travel_to travel freeze_time within within_frame using_session perform_enqueued_jobs].to_set
+    STUB_CALLS = %i[stub stub_request any_instance expects stubs stub_const].to_set
+    TABLE_CALLS = %i[each each_with_index each_pair each_with_object each_slice map flat_map times all? any? none?].to_set
+    BRANCH_NODES = [Prism::IfNode, Prism::UnlessNode, Prism::CaseNode, Prism::CaseMatchNode, Prism::WhileNode,
+                    Prism::UntilNode, Prism::AndNode, Prism::OrNode, Prism::RescueNode, Prism::RescueModifierNode].freeze
+    TEST_CALLS = %i[test it specify].to_set
+    BLOCK_CALLS = %i[describe context].to_set
+    SETUP_CALLS = %i[setup before].to_set
+
+    extend self
+
+    def kids(node) = node.compact_child_nodes
+    def descendants(node) = kids(node).flat_map { [_1, *descendants(_1)] }
+    def call?(node) = node.is_a?(Prism::CallNode)
+    def bare_call?(node) = call?(node) && node.receiver.nil?
+    def lines_of(node) = node.location.end_line - node.location.start_line + 1
+
+    def statements(body)
+      case body
+      when nil then []
+      when Prism::StatementsNode then body.body
+      when Prism::BeginNode then body.statements&.body || []
+      else [body]
+      end
+    end
+
+    def block_body(call) = call.block.is_a?(Prism::BlockNode) ? statements(call.block.body) : []
+
+    def context_head?(node)
+      return false unless call?(node) && node.block.is_a?(Prism::BlockNode)
+      CONTEXT_CALLS.include?(node.name) || node.name.start_with?("with_") || node.name == :stub
+    end
+
+    def stub_call?(node)
+      call?(node) && (STUB_CALLS.include?(node.name) ||
+                      (node.name == :new && node.receiver&.slice == "Minitest::Mock"))
+    end
+
+    def assertion?(node) = call?(node) && ASSERTION.match?(node.name)
+
+    def table_literal?(node)
+      case node
+      when Prism::ArrayNode then node.elements.size >= 2 && node.elements.all? { _1.is_a?(Prism::ArrayNode) || _1.is_a?(Prism::HashNode) }
+      when Prism::HashNode then node.elements.size >= 2
+      else false
+      end
+    end
+
+    def table_driven_form?(node)
+      return false unless call?(node)
+      (TABLE_CALLS.include?(node.name) && node.block && table_literal?(node.receiver)) ||
+        (assertion?(node) && (node.arguments&.arguments || []).any? { table_literal?(_1) })
+    end
+
+    def temp_resource?(node)
+      return true if node.is_a?(Prism::XStringNode) || node.is_a?(Prism::InterpolatedXStringNode)
+      return false unless call?(node)
+      recv = node.receiver&.slice
+      %i[mktmpdir tmpdir system spawn fork].include?(node.name) ||
+        recv == "Tempfile" || recv == "Thread" ||
+        (recv == "File" && %i[write binwrite].include?(node.name)) ||
+        (recv == "FileUtils")
+    end
+
+    def large_literal?(node)
+      case node
+      when Prism::StringNode, Prism::InterpolatedStringNode then string_line_count(node) > 5
+      when Prism::HashNode, Prism::KeywordHashNode, Prism::ArrayNode then node.elements.size > 10
+      else false
+      end
+    end
+
+    def string_line_count(node)
+      if node.opening_loc&.slice&.start_with?("<<") && node.closing_loc
+        node.closing_loc.start_line - node.opening_loc.start_line - 1
+      elsif node.is_a?(Prism::StringNode) then node.unescaped.lines.size
+      else lines_of(node)
+      end
+    end
+
+    def control_call?(node)
+      assertion?(node) || context_head?(node) || stub_call?(node) || TABLE_CALLS.include?(node.name) ||
+        TEST_CALLS.include?(node.name) || SETUP_CALLS.include?(node.name) || !node.name.match?(/\A[a-z_]/i)
+    end
+
+    def test_node?(node)
+      (node.is_a?(Prism::DefNode) && node.name.start_with?("test_")) ||
+        (bare_call?(node) && TEST_CALLS.include?(node.name) && node.block.is_a?(Prism::BlockNode))
+    end
+
+    def dynamic_test?(node)
+      bare_call?(node) && node.name == :define_method && node.block.is_a?(Prism::BlockNode) &&
+        dynamic_test_name(node).to_s.start_with?("test_")
+    end
+
+    def dynamic_test_name(node)
+      arg = node.arguments&.arguments&.first
+      case arg
+      when Prism::SymbolNode, Prism::StringNode then arg.unescaped
+      when Prism::InterpolatedSymbolNode, Prism::InterpolatedStringNode then arg.parts.map(&:slice).join
+      end
+    end
+
+    def dynamic_test_in_loop(node)
+      return unless call?(node) && TABLE_CALLS.include?(node.name) && node.block.is_a?(Prism::BlockNode)
+      block_body(node).find { dynamic_test?(_1) }
+    end
+
+    def test_name(node)
+      if node.is_a?(Prism::DefNode) then node.name.to_s
+      else node.arguments&.arguments&.first.then { _1.respond_to?(:unescaped) ? _1.unescaped : _1&.slice.to_s }
+      end
+    end
+
+    def method_name_of(node) = node.is_a?(Prism::DefNode) ? node.name.to_s : "test_#{test_name(node).to_s.gsub(/\s+/, "_")}"
+
+    def scope_children(node)
+      case node
+      when Prism::ClassNode, Prism::ModuleNode then [node.constant_path.slice, statements(node.body)]
+      when Prism::CallNode
+        [test_name(node) || node.name.to_s, block_body(node)] if bare_call?(node) && BLOCK_CALLS.include?(node.name) && node.block
+      end
+    end
+
+    def shape(node)
+      case node
+      when nil then nil
+      when Prism::StringNode, Prism::InterpolatedStringNode, Prism::XStringNode, Prism::InterpolatedXStringNode then :string
+      when Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode, Prism::ImaginaryNode then :number
+      when Prism::TrueNode, Prism::FalseNode then :boolean
+      when Prism::NilNode then :nil
+      when Prism::SymbolNode then :"#{node.unescaped}"
+      when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ConstantReadNode,
+           Prism::ConstantPathNode, Prism::SelfNode, Prism::ItLocalVariableReadNode then :sym
+      when Prism::HashNode, Prism::KeywordHashNode then [:hash, *node.elements.map { shape(_1) }.sort_by(&:inspect)]
+      when Prism::AssocNode then [shape(node.key), shape(node.value)]
+      when Prism::ArrayNode then [:vec, *node.elements.map { shape(_1) }]
+      when Prism::CallNode then [:sym, *[node.receiver, node.arguments, node.block].compact.map { shape(_1) }]
+      when Prism::ArgumentsNode then node.arguments.map { shape(_1) }
+      when Prism::StatementsNode then node.body.map { shape(_1) }
+      when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode then [:assign, :sym, shape(node.value)]
+      else [node.type, *kids(node).map { shape(_1) }]
+      end
+    end
+
+    def signature(value) = value.inspect
+
+    def shape_features(value, acc = Set.new)
+      acc << signature(value)
+      value.each { shape_features(_1, acc) } if value.is_a?(Array)
+      acc
+    end
+
+    def form_features(forms) = forms.each_with_object(Set.new) { |f, acc| shape_features(shape(f), acc) }
+    def form_signatures(forms) = forms.map { signature(shape(_1)) }
+
+    def large_literal_signatures(node)
+      own = large_literal?(node) ? [signature(shape(node))] : []
+      own + kids(node).flat_map { large_literal_signatures(_1) }
+    end
+  end
+end

data/lib/scrap4rb/version.rb

@@ -0,0 +1,3 @@
+module Scrap4rb
+  VERSION = "0.1.0"
+end

data/lib/scrap4rb.rb

@@ -0,0 +1,8 @@
+require_relative "scrap4rb/version"
+require_relative "scrap4rb/policy"
+require_relative "scrap4rb/syntax"
+require_relative "scrap4rb/example"
+require_relative "scrap4rb/structure"
+require_relative "scrap4rb/summary"
+require_relative "scrap4rb/judgment"
+require_relative "scrap4rb/cli"

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: scrap4rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Hopman
+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: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: scrap4rb reads Minitest test files and scores each test for size, branching,
+  mocking, weak assertions and duplicated scaffolding. Per file it reports a refactor
+  pressure, a remediation mode and an actionability class for an AI assistant. A Ruby
+  port of the SCRAP algorithm by Robert C. Martin.
+email:
+- hopman.r@gmail.com
+executables:
+- scrap4rb
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/scrap4rb
+- lib/scrap4rb.rb
+- lib/scrap4rb/cli.rb
+- lib/scrap4rb/example.rb
+- lib/scrap4rb/judgment.rb
+- lib/scrap4rb/policy.rb
+- lib/scrap4rb/structure.rb
+- lib/scrap4rb/summary.rb
+- lib/scrap4rb/syntax.rb
+- lib/scrap4rb/version.rb
+homepage: https://github.com/roberthopman/scrap4rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/roberthopman/scrap4rb
+  changelog_uri: https://github.com/roberthopman/scrap4rb/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'SCRAP for Minitest: structural quality scores for Ruby test code.'
+test_files: []