scrap4rb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9534e00ea290711ab140dcca603641ba180313ace9259a32c7b031cffaca788a
-  data.tar.gz: cd326a737dd566c651b5c25ef133415afe38d667756fb9138ae20cfbbb951709
+  metadata.gz: 96286449e9afa50fcf63563ab4c24e5ea34422d4b78aef3c8ba5c5fecd0dad0a
+  data.tar.gz: 75e1b075bdc33a520a45c1cf95b5e20f484d6893969e5b138f1e6514e0fda703
 SHA512:
-  metadata.gz: a372446e785fa9b0d5b915577df54a1526e77821357c7971095ab3b859b72778c23e85c9a8b984934a208a4d2a31c1c3d4f5df5f2a1904544925f21b8e8e7ed7
-  data.tar.gz: 8af1af6f60679abb63c4e8ae1454176be74292096d6f45a78bcdbcfaa00ebe8e0013929488a408d00cb6f334888b0adc54d8f86102b474e131501f3467617a7f
+  metadata.gz: 76526de107521d564ae46d855eb70920b67f1029a9cf13d8f1831ba8ad2db2173a9a550926ec8e01ebb849f1559d153f8d095157e76dd632005a0e68619ca062
+  data.tar.gz: 0c6caaaf36b1d12058035482a7f8af88fabd089da3b8f3c54ccd08992bcadb1c80baa2fdf27204dfe866ddd378ac09a5368a623771a79057fdeeebc2a40a5daa

data/CHANGELOG.md

@@ -6,6 +6,24 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-15
+
+### Changed
+- The setup depth counts 1 for each `let`, `let!`, `subject` and instance variable in a setup block, plus 1 for a setup block with other statements. Before, it counted 1 for each statement in a setup block, and 0 for `let` and `subject`. See `docs/setup-depth.md`.
+- temp-resource-work also counts file reads and writes, directories and processes: `File`, `IO` and `Dir` calls such as `read`, `open` and `mkdir`, `IO.popen`, `Open3` and `exec`. `File.join` and `file_fixture(...).read` do not count.
+- A `begin` with several `rescue` clauses is one branch, as a `try` is in SCRAP. Before, each clause counted 1.
+- The `--compare` verdict is `worse` for hidden helper lines only when more tests have them than the number of new tests. Before, a new test that called a helper made the verdict `worse`. See `docs/compare-verdict.md`.
+
+### Added
+- A `why` line for each file, with the ratios and counts behind the score, as in the SCRAP report.
+- `where` lines for a file with more than one describe block or class: the three blocks with the most pressure and the worst test of each. The JSON report has them as `top_blocks`.
+- `--compare` shows `example_count_delta`.
+- `loop do` is a branch, and `for x in` is a table branch. A `for` loop over a literal table is table-driven.
+- The setup depth follows `setup :method_name` to the body of the method.
+
+### Fixed
+- A bare `super` in `def setup` no longer counts as a setup statement.
+
 ## [0.1.0] - 2026-10-02
 
 ### Added
@@ -19,5 +37,6 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   `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
+[Unreleased]: https://github.com/roberthopman/scrap4rb/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/roberthopman/scrap4rb/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/roberthopman/scrap4rb/releases/tag/v0.1.0

data/README.md

@@ -55,6 +55,7 @@ The comparison gives each changed file a verdict: `improved`, `worse`, `mixed` o
 ```
 test/models/smelly_test.rb
   score 48.46 HIGH  mode LOCAL  ai AUTO_REFACTOR  tests=6 avg=12.78 max=18.26
+  why    low-assert=0.83 branching=0.17 mocking=0.17 helper-hidden=1 harmful-dup=11 extraction=0.0 matrix=1 subject-rep=0
   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
@@ -70,7 +71,12 @@ 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
+why        The ratios and counts behind the score: tests with 1 assertion or fewer, with
+           branches, with stubs and with hidden helper lines; duplication; extraction
+           pressure; table-drive candidates; subject repetition
 HIGH/...   Recommendations, ranked by confidence, at most four
+where      The three describe blocks or classes with the most pressure, with the worst
+           test of each. Only for a file with more than one block
 tests      The SCRAP score of each test, worst first, with its smells
 EXTRACT    A group of tests where a shared helper pays for itself
 ```
@@ -95,7 +101,7 @@ 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
+temp-resource-work         files, directories, threads or processes         3
 literal-heavy-setup        a string over 5 lines, a hash or array over 10   3
 ```
 
@@ -114,13 +120,15 @@ 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
+before, with            setup blocks, setup :method and def setup, let and subject,
+                        inherited by every test in the class (see docs/setup-depth.md)
 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
+doseq, for, every?      for, each, each_with_index, map, times, all?, ...
+if, when, cond, and     if, unless, case, while, until, &&, ||, rescue modifier
+loop, try               loop, begin/rescue (one per begin)
 ```
 
 The policy numbers (weights, thresholds, levels) are SCRAP's, unchanged.
@@ -130,6 +138,7 @@ The policy numbers (weights, thresholds, levels) are SCRAP's, unchanged.
   - 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.
+  - `--compare` does not call new tests that use a helper a helper regression. See `docs/compare-verdict.md`.
 
 ## Notes for Rails suites
 

data/docs/compare-verdict.md

@@ -0,0 +1,55 @@
+# The compare verdict
+
+This document explains one deviation from SCRAP in `--compare`: when hidden helper lines make the verdict `worse`.
+
+## The rule in SCRAP
+
+SCRAP compares the summary of each file with the baseline, and gives a verdict in this order:
+
+```
+Verdict     When
+-------     ----
+improved    file score -5 or more, no rise in extraction pressure or in max SCRAP
+worse       helper regression: more tests with hidden helper lines, no fall in
+            extraction pressure, and no more table-drive candidates
+worse       any rise in extraction pressure or max SCRAP, or file score +5 or more
+unchanged   file score delta 0
+mixed       all other cases
+```
+
+The helper regression rule looks for a refactor that moves setup into a local helper. The setup is then hidden, but the duplication does not go down. The rule uses `helper_hidden_delta`: the change in the number of tests that call a local helper.
+
+The source is `comparison.clj` in [unclebob/scrap](https://github.com/unclebob/scrap).
+
+## The problem
+
+`helper_hidden_delta` is a count, not a ratio. A new test that calls an existing helper adds 1. Thus a change that adds tests which call a helper gets the verdict `worse`, also when all scores improve. scrap4rb's own test suite shows this:
+
+```
+Change                          file score   max SCRAP   helper_hidden   tests   SCRAP verdict
+------                          ----------   ---------   -------------   -----   -------------
+4 tests for setup depth         -0.75        0.0         +2              +4      worse
+6 tests for branches and files  -0.76        0.0         +6              +6      worse
+```
+
+The advice that follows, "revert it, or simplify the helpers", is wrong for these changes. SCRAP has the same behavior.
+
+## The rule in scrap4rb
+
+scrap4rb compares `helper_hidden_delta` with the number of new tests:
+
+```
+helper regression = helper_hidden_delta > max(example_count_delta, 0)
+                    and extraction pressure did not fall
+                    and table-drive candidates did not rise
+```
+
+  - A new test that calls a helper is not a regression.
+  - An existing test that starts to call a helper is a regression, as in SCRAP.
+  - When tests are removed, the limit is 0, so removed tests cannot hide a regression.
+
+`--compare` shows `example_count_delta`, so the reason for a verdict is visible.
+
+## The limit of the rule
+
+The rule counts tests, not names. Suppose a change adds 2 tests without helpers and moves 2 existing tests to a helper. Then `helper_hidden_delta` is 2, `example_count_delta` is 2, and the rule does not see the regression. To see it, scrap4rb would have to match the tests in the baseline by name. The baseline does not store the tests, so scrap4rb does not do this.

data/docs/setup-depth.md

@@ -0,0 +1,72 @@
+# Setup depth
+
+This document explains how scrap4rb counts the setup depth of a test, and why the count differs from a literal port of SCRAP.
+
+## Setup depth in SCRAP
+
+SCRAP gives each test (`it`) a setup depth in two steps:
+
+  1. The start value is the number of setup forms in the enclosing `describe` and `context` blocks: `before`, `before-all`, `with`, `around`, `with-stubs`, `let`, `binding` and `with-redefs`. Each form counts 1, however many lines it has.
+  2. Inside the test, each nested `let`, `binding` or `with-redefs` adds 1. SCRAP keeps the deepest level, not the sum.
+
+The setup depth has three effects:
+
+  - It goes into the complexity score: `saturating(1 + branches + setup_depth + helper_calls)`. The curve rises quickly at the start: 1 gives 1.0, 3 gives 8.26 and 5 gives 13.32.
+  - An API-contract test gets 2 levels free.
+  - A test with a setup depth above 2 cannot be a coverage-matrix candidate. Thus a file of such tests does not get the "make it table-driven" advice.
+
+The source is `example_collect.clj`, `example_node.clj` and `example_metrics.clj` in [unclebob/scrap](https://github.com/unclebob/scrap).
+
+## Why a literal port does not work
+
+speclj has two kinds of setup:
+
+  - `with` is a named, lazy binding. The Minitest equivalent is `let`, or an instance variable in `setup`.
+  - `before` is a block of actions. It counts 1, however many lines it has.
+
+A Rails `setup` block mixes the two kinds:
+
+```ruby
+setup do
+  @user = users(:alice)
+  @order = orders(:open)
+  sign_in @user
+  visit order_path(@order)
+end
+```
+
+In speclj, this is two `with` forms and one `before`, so the setup depth is 3.
+
+## The rule
+
+scrap4rb counts the setup depth of a test class or a `describe` block as follows:
+
+  - Each `let`, `let!` and `subject` counts 1.
+  - In each `setup` block, `before` block and `def setup`, each instance variable assignment counts 1. For `setup :build_order`, scrap4rb reads the body of the method `build_order`.
+  - A setup block that also has other statements counts 1 more. A `super` call is not a statement for this rule.
+
+A nested `describe` block adds its own setup depth to the setup depth of its parent. Inside a test, a context block (`travel_to`, `with_*`, `stub` with a block) adds 1, as a nested `with-redefs` does in SCRAP.
+
+The three possible rules give different results for the setup block above:
+
+```
+Rule                                   Depth   API test   Large test   Matrix candidate
+----                                   -----   --------   ----------   ----------------
+A: 1 per setup block (+1 per let)      1       1.0        4.95         yes
+B: 1 per statement (in 0.1.0)          4       8.26       13.32        no
+C: 1 per @ivar or let, +1 if actions   3       4.95       11.0         no
+```
+
+  - Rule A is the literal mapping of `before`. A 20-line setup block costs 1, but SCRAP has the same weakness with a large `before`.
+  - Rule B counts too many. Each action line costs as much as a binding. With a 10-line setup block, the complexity score of a large test is 21.03 instead of 4.95. `let` costs nothing, so a move of the same setup from `setup` into `let` improves the score without a real change.
+  - Rule C gives the same number as the equivalent speclj code. scrap4rb uses rule C.
+
+## Locals in a test
+
+In Clojure, a test keeps its locals in a `let`. That `let` adds 1 to the setup depth. SCRAP also gives the `let` form the setup phase, so the assertions inside it do not count as phases. Thus SCRAP never reports multiple-phases for this test:
+
+```clojure
+(it "x" (let [x (atom 1)] (should= 1 @x) (reset! x 2) (should= 2 @x)))
+```
+
+The same test in Ruby has flat locals. It gets a setup depth of 0 and multiple-phases (5 points). scrap4rb does not copy the Clojure behavior, because Ruby has no `let` scope for the locals of a test. The result is that a Ruby score and a speclj score of the same test can differ.

data/lib/scrap4rb/cli.rb

@@ -41,16 +41,26 @@ module Scrap4rb
       opts
     end
 
-    def analyze_file(path, shared_asserts)
-      src = File.read(path)
+    def analyze_file(path, shared_asserts) = analyze_source(path, File.read(path), shared_asserts)
+
+    def analyze_source(path, src, shared_asserts)
       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) } }
+      blocks = exs.group_by { _1[:describe_path] }.reject { |p, _| p.empty? }.map { |p, b| { path: p, summary: Summary.summarize(b), examples: 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) }
+        ai: Judgment.actionability(summary, mode), actions: Judgment.actions(summary, mode), top_blocks: top_blocks(blocks) }
+    end
+
+    def top_blocks(blocks)
+      blocks.map do |b|
+        worst = b[:examples].max_by { _1[:scrap] }
+        { path: b[:path], score: Judgment.pressure_score(b[:summary]), level: Judgment.level(b[:summary]),
+          avg_scrap: b[:summary][:avg_scrap], harmful_duplication_score: b[:summary][:harmful_duplication_score],
+          worst: worst.slice(:name, :line, :scrap) }
+      end.sort_by { -_1[:score] }.first(Policy::REPORT[:top_block_count])
     end
 
     def print_report(r, verbose:)
@@ -58,9 +68,11 @@ module Scrap4rb
       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]}"
+      puts why_line(s)
       r[:actions].each { |c, t| puts "  #{LABEL[c].ljust(6)} #{t}" }
+      r[:top_blocks].each { puts where_line(_1) } if r[:top_blocks].size > 1
       worst = r[:examples].sort_by { -_1[:scrap] }
-      worst = worst.first(5) unless verbose
+      worst = worst.first(Policy::REPORT[:top_example_count]) 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]}): " +
@@ -68,6 +80,18 @@ module Scrap4rb
       end
     end
 
+    def why_line(s)
+      r = Judgment.ratios(s)
+      format("  why    low-assert=%.2f branching=%.2f mocking=%.2f helper-hidden=%d harmful-dup=%d extraction=%.1f matrix=%d subject-rep=%d",
+             r[:low], r[:branching], r[:mocking], s[:helper_hidden_example_count], s[:harmful_duplication_score],
+             s[:extraction_pressure_score], s[:coverage_matrix_candidates], s[:subject_repetition_score])
+    end
+
+    def where_line(b)
+      format("  where  %s  %s %.1f  avg=%.1f dup=%d  worst: %s (%.1f)", b[:path].join(" / "), b[:level], b[:score],
+             b[:avg_scrap], b[:harmful_duplication_score], b[:worst][:name], b[:worst][:scrap])
+    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]} " \
@@ -92,7 +116,8 @@ module Scrap4rb
                 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] }
+                helper_hidden_delta: a[:helper_hidden_example_count] - b[:helper_hidden_example_count],
+                example_count_delta: a[:example_count] - b[:example_count] }
         [r[:path], cmp.merge(verdict: Judgment.verdict(cmp))]
       end
     end

data/lib/scrap4rb/example.rb

@@ -61,8 +61,8 @@ module Scrap4rb
       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,
+        branches: branch?(node) ? 1 : 0,
+        table_branches: table_branch?(node) ? 1 : 0,
         with_redefs: stub_call?(node) ? 1 : 0,
         helper_calls: helper ? 1 : 0,
         temp_resources: temp_resource?(node) ? 1 : 0,
@@ -121,8 +121,8 @@ module Scrap4rb
       ].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: })
+    def score(name:, node:, body:, ctx:, inherited_setup:, inherited_depth:, describe_path:, table_driven: false)
+      m = combine(*body.map { analyze(_1, ctx, inherited_depth, Set.new) }, { table_driven: })
       raw_lines = lines_of(node)
       line_count = raw_lines + m[:helper_hidden_lines]
       forms = top_forms(body)
@@ -159,29 +159,42 @@ module Scrap4rb
       }
     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
+    def setup_body(node, helpers)
+      if bare_call?(node) && SETUP_CALLS.include?(node.name) && node.block.is_a?(Prism::BlockNode) then block_body(node)
+      elsif bare_call?(node) && SETUP_CALLS.include?(node.name) && node.block.nil? && node.arguments
+        node.arguments.arguments.grep(Prism::SymbolNode).flat_map { helpers.fetch(_1.unescaped.to_sym, []) }
+      elsif node.is_a?(Prism::DefNode) && node.name == :setup
+        statements(node.body).reject { _1.is_a?(Prism::ForwardingSuperNode) || _1.is_a?(Prism::SuperNode) }
+      end
+    end
+
+    def setup_forms(scope_body, helpers) = scope_body.flat_map { setup_body(_1, helpers) || [] }
+
+    def setup_depth(scope_body, helpers)
+      scope_body.sum do |n|
+        next 1 if bare_call?(n) && LET_CALLS.include?(n.name) && n.block
+        bindings, actions = (setup_body(n, helpers) || []).partition { _1.is_a?(Prism::InstanceVariableWriteNode) }
+        bindings.size + (actions.empty? ? 0 : 1)
       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)
+    def collect(forms, ctx, path = [], inherited = [], inherited_depth = 0, out = [])
+      setup = inherited + setup_forms(forms, ctx.helpers)
+      depth = inherited_depth + setup_depth(forms, ctx.helpers)
       forms.each do |f|
         if (name, body = scope_children(f))
-          collect(body, ctx, path + [name], setup, out)
+          collect(body, ctx, path + [name], setup, depth, out)
         elsif test_node?(f)
-          out << score(name: test_name(f), node: f, body: test_body(f), ctx:, inherited_setup: setup, describe_path: path)
+          out << score(name: test_name(f), node: f, body: test_body(f), ctx:, inherited_setup: setup,
+                       inherited_depth: depth, 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)
+                       inherited_depth: depth, 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)
+          out << score(name: dynamic_test_name(f), node: f, body: block_body(f), ctx:, inherited_setup: setup,
+                       inherited_depth: depth, describe_path: path)
         end
       end
       out

data/lib/scrap4rb/judgment.rb

@@ -101,7 +101,8 @@ module Scrap4rb
 
     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[:helper_hidden_delta] > [c[:example_count_delta], 0].max && c[:extraction_pressure_delta] >= 0 && c[:case_matrix_delta] <= 0
+        "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"

data/lib/scrap4rb/policy.rb

@@ -1,5 +1,6 @@
 module Scrap4rb
   module Policy
+    REPORT = { top_example_count: 5, top_block_count: 3 }.freeze
     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

data/lib/scrap4rb/syntax.rb

@@ -8,10 +8,12 @@ module Scrap4rb
     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
+                    Prism::UntilNode, Prism::AndNode, Prism::OrNode, Prism::RescueModifierNode].freeze
+    FILE_CALLS = %i[read readlines binread write binwrite open foreach popen mkdir].to_set
     TEST_CALLS = %i[test it specify].to_set
     BLOCK_CALLS = %i[describe context].to_set
     SETUP_CALLS = %i[setup before].to_set
+    LET_CALLS = %i[let let! subject].to_set
 
     extend self
 
@@ -44,6 +46,13 @@ module Scrap4rb
 
     def assertion?(node) = call?(node) && ASSERTION.match?(node.name)
 
+    def branch?(node)
+      BRANCH_NODES.any? { node.is_a?(_1) } || (node.is_a?(Prism::BeginNode) && !node.rescue_clause.nil?) ||
+        (bare_call?(node) && node.name == :loop && !node.block.nil?)
+    end
+
+    def table_branch?(node) = node.is_a?(Prism::ForNode) || (call?(node) && TABLE_CALLS.include?(node.name) && !node.block.nil?)
+
     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) }
@@ -53,6 +62,7 @@ module Scrap4rb
     end
 
     def table_driven_form?(node)
+      return table_literal?(node.collection) if node.is_a?(Prism::ForNode)
       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) })
@@ -62,10 +72,9 @@ module Scrap4rb
       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")
+      %i[mktmpdir tmpdir system spawn fork exec].include?(node.name) ||
+        %w[Tempfile Thread FileUtils Open3].include?(recv) ||
+        (%w[File IO Dir].include?(recv) && FILE_CALLS.include?(node.name))
     end
 
     def large_literal?(node)
@@ -85,7 +94,7 @@ module Scrap4rb
     end
 
     def control_call?(node)
-      assertion?(node) || context_head?(node) || stub_call?(node) || TABLE_CALLS.include?(node.name) ||
+      assertion?(node) || context_head?(node) || stub_call?(node) || TABLE_CALLS.include?(node.name) || node.name == :loop ||
         TEST_CALLS.include?(node.name) || SETUP_CALLS.include?(node.name) || !node.name.match?(/\A[a-z_]/i)
     end
 

data/lib/scrap4rb/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scrap4rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Hopman
@@ -71,6 +71,8 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- docs/compare-verdict.md
+- docs/setup-depth.md
 - exe/scrap4rb
 - lib/scrap4rb.rb
 - lib/scrap4rb/cli.rb