crap4ruby 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2e848e88bdf6cd4f6b2f0a5477aa3a9f3565651006864d7101ad13beab82c7c
-  data.tar.gz: cc9a67ce5aaea92c6d7311f00526900017df5904c157d16764b77cbd27a0a9e7
+  metadata.gz: 28f7ade7b1a7064708117a46abf1e555d777493d5be570fc28cf6958b196e253
+  data.tar.gz: 3ae6bf461495ff0e5fa2edc3ecfa773f7c20f920fb3d6f7e92f9ce42bfec3ddd
 SHA512:
-  metadata.gz: 546293a428b456b48c4c22b34fe09980a2c88f1c7af0d69f8aa24f598fa5441993e8c50f1dc29dc346c233e0a8ffada8106fc13894a15a6185b1877c9823840a
-  data.tar.gz: ed047a7174bcce565ff2b248729f4faa61208f8a20794a6903d0fe9cfca7e1381243bd12287502dd5cfdef1087153c0720b363e098e39e32364262ade1501ddf
+  metadata.gz: da1e756e8824c99bd46cb34d5f994e95689866a760870bd13f5eb3530573c5eed5c4d6903f4e60a35c16f9f8f2bcb153af2db6712d9fa4d373d8a0c27f9b7a9d
+  data.tar.gz: 9fc11d38f195dea8de1a7b52079e8fd1b32979bc28d12149d7ded251d887577fa26ea0ffc28b6839aa4c41fc76b906f161b7b73bb9f7f53fed4fd1b7873f5e4f

data/CHANGELOG.md

@@ -5,6 +5,16 @@ Version numbers follow [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-10-29
+
+### Added
+
+- Automatically analyze large selections with bounded worker processes. Add `--jobs N` to set the worker count or use `--jobs 1` for serial analysis, with serial fallback on unsupported or multithreaded hosts.
+
+### Changed
+
+- Reduce analyzer, coverage-loading, discovery, scoring, and table-formatting overhead while preserving analysis results and report output. See [PERFORMANCE.md](PERFORMANCE.md) for real-project measurements.
+
 ## [0.2.1] - 2026-10-29
 
 ### Added
@@ -48,7 +58,8 @@ Version numbers follow [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.
 
 - Split CLI execution, AST discovery, and coverage loading into smaller methods without changing their behavior or scoring rules.
 
-[Unreleased]: https://github.com/svyatov/crap4ruby/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/svyatov/crap4ruby/compare/v0.2.2...HEAD
+[0.2.2]: https://github.com/svyatov/crap4ruby/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/svyatov/crap4ruby/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/svyatov/crap4ruby/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/svyatov/crap4ruby/compare/v0.1.0...v0.1.1

data/PERFORMANCE.md

@@ -0,0 +1,166 @@
+# Performance
+
+The benchmark compares complete CLI runs on local project checkouts. It checks report equality and rejects changed inputs.
+
+## Measured results (2026-10-29)
+
+Baseline: `19942c2` (0.2.1). CLI candidate: `2f23c80`. Final EDN allocation follow-up: `3dd909d`, measured separately below. Runtime: Ruby 4.0.9, Prism 1.9.0, arm64 macOS.
+
+Each variant has seven measured subprocess runs after one excluded warmup. Variant order alternates, and runs execute serially with warm filesystem caches.
+
+| Project | Mode | Ruby files | Baseline median | Candidate median | Time reduction |
+| --- | --- | ---: | ---: | ---: | ---: |
+| Les | Complexity only | 196 | 0.2530 s | 0.1485 s | 41.3% |
+| Les | SimpleCov coverage | 196 | 0.2840 s | 0.1788 s | 37.1% |
+| Forem | Complexity only | 1,307 | 0.9631 s | 0.3761 s | 60.9% |
+| Steep | Complexity only | 146 | 0.5330 s | 0.2185 s | 59.0% |
+| YARD | Complexity only | 207 | 0.3699 s | 0.1768 s | 52.2% |
+
+[Raw samples and input/output hashes](benchmark/results/2026-10-29-batch.jsonl) retain every measured duration. Each line is a JSON object. Campaign records distinguish the original baseline, the optimized serial baseline, current-code worker settings, and small inputs. Grouped samples factor identical metadata without dropping values. Phase, resource, and independent QA records are separate.
+
+The earlier campaigns measured [candidate `80484fd`](benchmark/results/2026-10-29.jsonl), [candidate `2f35bdd`](benchmark/results/2026-10-29-follow-up.jsonl), and [candidate `6a1701b`](benchmark/results/2026-10-29-report-score.jsonl) against the same baseline. Project input and report hashes match across campaigns. Timing differences between campaigns do not isolate individual changes.
+
+Timing includes Ruby startup, Prism activation, discovery, source reads, analysis, coverage loading, sorting, formatting, output capture, and process completion. Both variants start without inherited Bundler setup and activate the same Prism version. Runs use `--no-save`, so timing excludes snapshot serialization and writes. Test-suite execution is excluded.
+
+Every measured report matches its baseline byte for byte. Separate differential checks preserve all fields and traversal order across 10,568 method definitions in these four projects. Independent fixture checks cover nested definitions, heredocs, encoding, assignment syntax, errors, and coverage on Ruby 3.3.11 and 4.0.9. The batch implementation also passed 75 independent CLI runs and 21 controlled lifecycle probes on Ruby 3.3.11, 3.4.9, and 4.0.9. All used Prism 1.9.0. Prism 1.0 and 2.x were not executed.
+
+These results describe local checkouts and warm filesystem caches. They do not establish cold-disk latency, unique physical memory use, or performance on other machines. Separately sampled summed RSS is reported below.
+
+## Repeat the comparison
+
+1. Create a scratch directory with `mktemp -d`. Replace `BASELINE_DIR` below with its printed path.
+2. Export the baseline library:
+
+   ```sh
+   git archive --output=BASELINE_DIR/baseline.tar 19942c2 lib
+   ```
+
+3. Extract the archive:
+
+   ```sh
+   tar -xf BASELINE_DIR/baseline.tar -C BASELINE_DIR
+   ```
+
+4. Compare against a project checkout:
+
+   ```sh
+   bundle exec ruby script/benchmark.rb BASELINE_DIR/lib /path/to/project
+   ```
+
+The command prints JSON to stdout and median/range summaries to stderr. Pass multiple project paths to measure them serially. Set `SAMPLES` to an odd integer of at least three to change the sample count.
+
+For a comparison of current-code serial execution against its automatic default, use `BASELINE_JOBS=1` and pass `lib` as the baseline directory. `CANDIDATE_JOBS` can override the candidate worker count. Both optional settings are recorded in the output; use them only with library versions that support `--jobs`.
+
+The runner selects existing `app/` and `lib/` directories. It measures complexity-only mode and adds coverage-enabled mode when `coverage/.resultset.json` exists. It hashes selected paths and contents before and after each subprocess. Coverage-enabled runs also hash the coverage report. Library hashes must remain unchanged throughout the campaign.
+
+## Optimization evidence
+
+The analyzer shares one ordered result array across discovery, uses symbol dispatch for decision types, and resolves coverage endpoints by byte offset. Complexity-only CLI runs omit coverage line collection. Default library calls retain body lines.
+
+Analysis-only comparisons against the baseline preserved complete method records and reports. They reduced median analysis time by 18% to 25% before omitting coverage collection. The omitted walk then reduced complete complexity-only CLI latency by another 16% to 23% against that intermediate implementation.
+
+Preliminary CLI timings inherited Bundler's candidate version preload and were replaced by the clean-boot measurements above. The newer Prism child iterator was excluded because the minimum supported Prism version lacks it.
+
+### Follow-up experiments
+
+Seven trials per variant alternated execution order. Each trial started a separate Ruby process and ran one excluded warmup batch. Phase timing excludes library loading and result hashing. Allocation counts use `GC.stat(:total_allocated_objects)` deltas.
+
+| Experiment | Input and batch | Baseline median | Candidate median | Baseline allocated objects | Candidate allocated objects |
+| --- | --- | ---: | ---: | ---: | ---: |
+| Iteration membership hash | Forem, one complexity-only analysis | 0.4041 s | 0.3911 s | 944,945 | 945,015 |
+| Direct definition-boundary checks | Forem, one analysis with body lines | 0.5592 s | 0.5284 s | 1,374,461 | 1,186,622 |
+| Copy initial coverage counts | Les, 50 report loads | 0.3416 s | 0.2707 s | 1,434,813 | 87,463 |
+| Skip repeated file-type checks | Forem, 20 discovery calls | 1.8376 s | 1.6761 s | 1,061,220 | 993,820 |
+
+Each phase isolates one change against its preceding implementation. Analysis includes source reads and parsing. Coverage loading includes JSON parsing, validation, and normalization. Its input is the real Les report with 209 files and 13,399 line entries. The loader experiment screened an equivalent conditional form before the committed guard clause.
+
+Complete method records, merged coverage data, and selected file paths match within every phase. Independent checks also matched 382 Analyzer fixtures, 176 coverage cases, and 40 discovery scenarios on Ruby 3.3.11 and 4.0.9. Coverage checks include caller-array mutation, merged suites, unequal arrays, and symlink aliases.
+
+Moving the iteration block check before membership lookup showed no clear gain and was reverted.
+
+### Formatting and scoring
+
+The table formatter now uses one format template per report. Scoring combines integer terms before constructing the exact Rational result. Both changes preserve output and reduce allocated objects.
+
+| Experiment | Input and batch | Baseline median | Candidate median | Baseline allocated objects | Candidate allocated objects |
+| --- | --- | ---: | ---: | ---: | ---: |
+| Table format template | Forem, 20 tables of 5,765 entries | 0.1991 s | 0.1206 s | 1,384,240 | 461,740 |
+| Integer score terms | Les, 20 scoring passes over 1,045 methods | 0.3267 s | 0.3192 s | 397,060 | 250,020 |
+
+Each experiment has seven alternating trials per variant, with one excluded warmup batch per process. The table experiment compares `562581a` with the formatter in `c0f10f6`. The scoring experiment compares `c0f10f6` with `6a1701b`. Allocation counts cover the measured batch only.
+
+The formatter reduced phase time by 39% and allocated objects by 67%. Scoring reduced allocated objects by 37%. Its elapsed time changed by 2.3%, and CPU time changed from 0.3256 s to 0.3175 s. These small timing changes do not establish a reliable speed gain. Median process peak RSS was 47,398,912 versus 47,431,680 bytes. Median GC count was 17 for both variants; candidate batches triggered 16 to 17 collections. Median GC time was 12 versus 10 ms. Fewer allocations are a retained improvement even without a demonstrated reduction in peak memory or median collection count.
+
+Independent differential checks matched 146 formatter cases and 74 scoring cases on Ruby 3.3.11 and 4.0.9. These include encoding and control characters, exact Rational values, partial coverage, and large integers.
+
+#### EDN allocation follow-up
+
+Commit `3dd909d` trims trailing zeros in the newly formatted number string in place. This avoids copying that string. Each variant runs 100 EDN formatting passes after 100 excluded warmup passes, in seven fresh subprocesses with alternating order. Timing excludes library loading, analysis, sorting, and snapshot writes. The baseline is `af2f770`.
+
+| Input | Baseline median | Candidate median | Baseline allocated objects | Candidate allocated objects |
+| --- | ---: | ---: | ---: | ---: |
+| Les, 1,045 methods with coverage | 0.1696 s | 0.1699 s | 1,701,309 | 1,517,509 |
+| Forem, 5,765 methods without coverage | 0.3711 s | 0.3687 s | 2,894,109 | 2,894,109 |
+
+Les report allocations decreased by 10.8%. Forem has no numeric coverage or scores to trim, so its allocation count is unchanged. Timing ranges overlap for both inputs; these results establish no elapsed-time improvement. All EDN hashes match, and all selected source and coverage hashes remain unchanged. [Raw samples and QA evidence](benchmark/results/2026-10-29-edn.jsonl) retain every duration and allocation count. Differential checks preserve 4,012 numeric cases on each of Ruby 3.3.11, 3.4.9, and 4.0.9. Additional EDN checks cover escaping, empty reports, exact Rational values, negative zero, and nonfinite floats on Ruby 3.3.11 and 3.4.9.
+
+### Automatic batch analysis
+
+Selections of at least 64 files use up to four worker processes, bounded by available processors. Smaller selections, unsupported fork platforms, and hosts with other live Ruby threads remain serial. `--jobs 1` forces serial execution. Result order and all report writes remain controlled by the parent.
+
+The following campaign compares the same `2f23c80` library with `--jobs 1` against its automatic default. It isolates worker selection without changing the loaded library. Each mode has seven alternating measured subprocess runs after one excluded warmup.
+
+| Project | Mode | Serial median | Automatic median | Time reduction |
+| --- | --- | ---: | ---: | ---: |
+| Les | Complexity only | 0.1960 s | 0.1579 s | 19.4% |
+| Les | SimpleCov coverage | 0.2438 s | 0.1800 s | 26.1% |
+| Forem | Complexity only | 0.6207 s | 0.3822 s | 38.4% |
+| Steep | Complexity only | 0.3215 s | 0.2160 s | 32.8% |
+| YARD | Complexity only | 0.2507 s | 0.1732 s | 30.9% |
+
+A separate paired campaign against the earlier optimized serial implementation, `6a1701b`, measured reductions of 19.6% to 40.0%. All reports matched. The raw data keeps this comparison separate from the original-baseline and worker-override campaigns.
+
+Real-project subsets support the 64-file automatic threshold. The phase experiment includes source reads, parsing, scoring, fork startup, cancellation-thread startup, and result transfer. It excludes discovery, coverage loading, sorting, formatting, and process startup. Each trial has one excluded warmup batch; worker order rotates across seven fresh subprocess trials.
+
+| Project | Selected files | Serial phase median | Four-worker phase median |
+| --- | ---: | ---: | ---: |
+| Forem | 16 | 0.0063 s | 0.0087 s |
+| Forem | 32 | 0.0124 s | 0.0114 s |
+| Forem | 64 | 0.0272 s | 0.0198 s |
+| Forem | 128 | 0.0439 s | 0.0241 s |
+| Les, coverage | 16 | 0.0068 s | 0.0116 s |
+| Les, coverage | 32 | 0.0174 s | 0.0157 s |
+| Les, coverage | 64 | 0.0301 s | 0.0197 s |
+| Les, coverage | 128 | 0.0648 s | 0.0307 s |
+
+Four workers lose at 16 files, show smaller gains at 32, and reduce phase time by 27% to 35% at 64. On the full selections, automatic analysis-and-scoring time was 0.1599 s versus 0.4082 s for Forem, and 0.0575 s versus 0.1186 s for Les. Median total parent-plus-child CPU time increased from 0.4073 s to 0.4615 s on Forem, and from 0.1180 s to 0.1608 s on Les: increases of 13.3% and 36.2%.
+
+Seven alternating memory probes per configuration sampled the sum of CLI parent and worker RSS every 10 ms. This includes startup and reporting; fork telemetry and polling perturb timing, so these probes support no latency claim. Shared pages are counted once per process, and sampling can miss short peaks. These are not measurements of unique physical memory.
+
+| Project | Serial median sampled peak sum RSS | Automatic median sampled peak sum RSS |
+| --- | ---: | ---: |
+| Forem | 73,678,848 bytes | 194,854,912 bytes |
+| Les, coverage | 47,005,696 bytes | 112,443,392 bytes |
+
+Independent QA compared serial baseline `6a1701b` with automatic mode and `--jobs 1/2/4` through actual CLI subprocesses on all four projects. It preserved stdout, stderr, exit statuses, source and coverage inputs, and existing snapshots across three Ruby versions. Controlled probes exercised ordering, exact Rational scores, Unicode, payloads larger than a pipe buffer, malformed results, abnormal exits, first-error ordering, multithreaded fallback, cancellation, and custom SIGCHLD reapers. All probes finished without remaining children. Cleanup made no PID signals and did not replace host signal handlers. The main suite additionally covers unavailable fork, partial startup failure, and SIGINT cancellation.
+
+Review found a stale-PID signaling race when a host reaped worker statuses. The repaired implementation cancels through private pipes and uses a child monitor thread, then validates complete result payloads even if the host has consumed the exit status. The two reproducing regression tests and the full 86-test suite pass. The measurements above include this repair.
+
+A separate [process-group SIGINT probe](benchmark/results/2026-10-29-batch-sigint.json) delivered SIGINT after all four workers started. The CLI terminated on signal 2, preserved its existing snapshot, emitted no report, and left no processes in its group.
+
+Small-input CLI comparisons against `6a1701b` remained serial. Medians for 16 and 32 files ranged from effectively unchanged to 4.0% slower, with overlapping timing ranges. The largest median difference was 5.1 ms. A follow-up rejected deferred loading of `Etc`: `Tempfile` loads it transitively, and repeated load and CLI measurements showed no clear benefit. [The rejected experiment](benchmark/results/2026-10-29-startup-screen.json) retains all samples and its prototype description. EDN serialization was screened separately above. These measurements do not establish a performance maximum.
+
+### Batch screening prototype
+
+An earlier throwaway fork-based prototype screened analysis and scoring across files before the production worker implementation. These historical phase measurements exclude CLI startup, discovery, sorting, formatting, and saving. Seven measured rounds followed one excluded warmup round; worker order rotated. Selected file contents and all returned entries matched across worker counts. The prototype samples are retained in the earlier report-and-score campaign.
+
+| Project and mode | Worker processes | Median elapsed time | Median total CPU time |
+| --- | ---: | ---: | ---: |
+| Forem, complexity only | 1 | 0.4104 s | 0.4059 s |
+| Forem, complexity only | 2 | 0.2656 s | 0.4365 s |
+| Forem, complexity only | 4 | 0.1504 s | 0.4507 s |
+| Les, coverage | 1 | 0.1220 s | 0.1211 s |
+| Les, coverage | 2 | 0.0776 s | 0.1377 s |
+| Les, coverage | 4 | 0.0566 s | 0.1532 s |
+
+Four workers reduced prototype phase latency by 63% on Forem and 54% on Les, while increasing total CPU time by 11% and 26%. Total CPU includes parent and child processes. The production implementation and its resource costs are measured separately above.

data/README.md

@@ -46,7 +46,7 @@ Run these commands from this checkout with Ruby 3.3 or newer:
 ```sh
 bundle install
 gem build crap4ruby.gemspec
-gem install ./crap4ruby-0.2.1.gem
+gem install ./crap4ruby-0.2.2.gem
 ```
 
 To use Bundler in the measured project, add this checkout to that project's `Gemfile`:
@@ -97,6 +97,7 @@ crap4ruby does not configure SimpleCov, delete reports, install dependencies, or
 | `--coverage-command COMMAND` | Run a shell command that refreshes the selected report. |
 | `--no-coverage` | Report complexity with unknown coverage and CRAP. |
 | `--no-save` | Print results without creating or replacing `.metrics/crap.edn`. |
+| `--jobs N` | Set a positive worker count; `1` forces serial analysis. The default selects workers automatically. |
 | `--threshold NUMBER` | Check this finite, nonnegative limit; exit 2 for a measured violation, or 1 if an unknown score could exceed it. |
 | `-h`, `--help` | Print usage. |
 | `-v`, `--version` | Print the gem version. |
@@ -126,6 +127,8 @@ bundle exec crap4ruby --no-coverage --no-save
 `--no-save` preserves the terminal report and threshold exit codes while leaving the snapshot unchanged.
 It also works with coverage enabled.
 
+Selections of at least 64 files automatically use up to four worker processes, limited by the available processors. Workers reduce analysis latency by using more CPU and memory. Use `--jobs 1` to keep analysis in one process, or set a larger count explicitly. The count never exceeds the selected file count. Platforms without fork support and hosts with other live Ruby threads use serial analysis. Worker startup resource failures also fall back to serial analysis. Reports, scores, and snapshot behavior are the same in both modes.
+
 ## Complexity and coverage
 
 The scoring engine uses this formula, with coverage expressed as a fraction between 0 and 1:

data/lib/crap4ruby/analyzer.rb

@@ -17,7 +17,14 @@ module Crap4Ruby
       repeated_combination select! sort! each_key each_pair each_value
       fetch fetch_values has_key? merge merge! transform_keys transform_keys!
       transform_values transform_values!
-    ].freeze
+    ].to_h { |name| [name, true] }.freeze
+
+    # Configures whether analysis collects body lines for coverage scoring.
+    #
+    # @param coverage [Boolean] collect body lines; false leaves MethodInfo#lines nil
+    def initialize(coverage: true)
+      @coverage = coverage
+    end
 
     # Analyzes method bodies with Prism and the RuboCop 1.92.1 counting rules.
     #
@@ -44,52 +51,57 @@ module Crap4Ruby
     # @param scope [Array<String>] lexical namespace components
     # @param singleton [Boolean] whether definitions belong to a singleton class
     # @param path [String] source label
+    # @param methods [Array<MethodInfo>] ordered output shared by the traversal
     # @return [Array<MethodInfo>] discovered method definitions
-    def discover(node, scope, singleton, path)
-      return [] unless node
+    def discover(node, scope, singleton, path, methods = [])
+      return methods unless node
 
       case node
       when Prism::ClassNode, Prism::ModuleNode
-        discover_class(node, scope, singleton, path)
+        discover_class(node, scope, singleton, path, methods)
       when Prism::SingletonClassNode
         owner = node.expression.is_a?(Prism::SelfNode) ? scope : qualify(node.expression, scope)
-        owner ? discover(node.body, owner, true, path) : []
+        discover(node.body, owner, true, path, methods) if owner
       when Prism::DefNode
-        discover_method(node, scope, singleton, path)
+        discover_method(node, scope, singleton, path, methods)
       when Prism::CallNode
-        discover_call(node, scope, singleton, path)
+        discover_call(node, scope, singleton, path, methods)
       else
-        node.compact_child_nodes.flat_map { |child| discover(child, scope, singleton, path) }
+        node.compact_child_nodes.each { |child| discover(child, scope, singleton, path, methods) }
       end
+      methods
     end
 
-    def discover_class(node, scope, singleton, path)
-      # @type var methods: Array[MethodInfo]
-      methods = node.is_a?(Prism::ClassNode) ? discover(node.superclass, scope, singleton, path) : []
+    def discover_class(node, scope, singleton, path, methods)
+      discover(node.superclass, scope, singleton, path, methods) if node.is_a?(Prism::ClassNode)
       owner = qualify(node.constant_path, scope, declaration: true)
-      methods + (owner ? discover(node.body, owner, false, path) : [])
+      discover(node.body, owner, false, path, methods) if owner
     end
 
-    def discover_call(node, scope, singleton, path)
+    def discover_call(node, scope, singleton, path, methods)
       name = defined_name(node)
       block = node.block
       if name && block.is_a?(Prism::BlockNode)
-        discover_block(block, name, scope, singleton, path)
+        discover_block(block, name, scope, singleton, path, methods)
       else
-        node.compact_child_nodes.flat_map { |child| discover(child, scope, singleton, path) }
+        node.compact_child_nodes.each { |child| discover(child, scope, singleton, path, methods) }
       end
     end
 
-    def discover_block(block, name, scope, singleton, path)
+    def discover_block(block, name, scope, singleton, path, methods)
       raise EncodingError unless name.valid_encoding?
 
       name = name.encode(Encoding::UTF_8)
-      parameters = block.parameters
-      header = parameters.is_a?(Prism::BlockParametersNode) ? parameters.location : block.opening_loc
-      lines = body_lines(block.body, after: header.end_line, ending: block.location)
+      if @coverage
+        parameters = block.parameters
+        header = parameters.is_a?(Prism::BlockParametersNode) ? parameters.location : block.opening_loc
+        lines = body_lines(block.body, after: header.end_line, ending: block.location)
+      end
       name = "self.#{name}" if singleton
-      [MethodInfo.new(name, scope.empty? ? "Object" : scope.join("::"), 1 + decisions(block.body), lines, path)] +
-        discover(block.parameters, scope, singleton, path) + discover(block.body, scope, singleton, path)
+      methods << MethodInfo.new(name, scope.empty? ? "Object" : scope.join("::"),
+        1 + decisions(block.body), lines, path)
+      discover(block.parameters, scope, singleton, path, methods)
+      discover(block.body, scope, singleton, path, methods)
     rescue EncodingError
       raise Error, "#{path}:#{block.location.start_line}: define_method name must be representable in UTF-8"
     end
@@ -111,18 +123,21 @@ module Crap4Ruby
     # @param scope [Array<String>] lexical namespace components
     # @param singleton [Boolean] whether the enclosing scope is a singleton class
     # @param path [String] source label
-    # @return [Array<MethodInfo>] this method and its nested definitions
-    def discover_method(node, scope, singleton, path)
+    # @param methods [Array<MethodInfo>] ordered output shared by the traversal
+    # @return [void]
+    def discover_method(node, scope, singleton, path, methods)
       owner = method_owner(node, scope)
-      return [] unless owner
+      return unless owner
 
       name = "#{"self." if singleton || node.receiver}#{node.name}"
-      header = node.equal_loc || node.rparen_loc || node.parameters&.location || node.name_loc
-      lines = body_lines(node.body, after: header.end_line, ending: node.location)
+      if @coverage
+        header = node.equal_loc || node.rparen_loc || node.parameters&.location || node.name_loc
+        lines = body_lines(node.body, after: header.end_line, ending: node.location)
+      end
       complexity = 1 + decisions(node.body)
-      [MethodInfo.new(name, owner.empty? ? "Object" : owner.join("::"), complexity, lines, path)] +
-        discover(node.parameters, scope, singleton, path) +
-        discover(node.body, scope, singleton, path)
+      methods << MethodInfo.new(name, owner.empty? ? "Object" : owner.join("::"), complexity, lines, path)
+      discover(node.parameters, scope, singleton, path, methods)
+      discover(node.body, scope, singleton, path, methods)
     end
 
     def method_owner(node, scope)
@@ -201,10 +216,21 @@ module Crap4Ruby
     def decision?(node)
       return !node.begin_modifier? if node.is_a?(Prism::WhileNode) || node.is_a?(Prism::UntilNode)
 
-      %i[if_node unless_node for_node
-        when_node in_node rescue_modifier_node and_node or_node].include?(node.type) ||
-        node.type.to_s.match?(/_(?:and|or)_write_node\z/) ||
-        (node.is_a?(Prism::BeginNode) && !node.rescue_clause.nil?)
+      case node.type
+      when :if_node, :unless_node, :for_node, :when_node, :in_node,
+          :rescue_modifier_node, :and_node, :or_node,
+          :call_and_write_node, :call_or_write_node,
+          :class_variable_and_write_node, :class_variable_or_write_node,
+          :constant_and_write_node, :constant_or_write_node,
+          :constant_path_and_write_node, :constant_path_or_write_node,
+          :global_variable_and_write_node, :global_variable_or_write_node,
+          :index_and_write_node, :index_or_write_node,
+          :instance_variable_and_write_node, :instance_variable_or_write_node,
+          :local_variable_and_write_node, :local_variable_or_write_node
+        true
+      else
+        node.is_a?(Prism::BeginNode) && !node.rescue_clause.nil?
+      end
     end
 
     def safe_navigation?(node, seen)
@@ -225,7 +251,7 @@ module Crap4Ruby
     end
 
     def iteration?(node)
-      return false unless node.is_a?(Prism::CallNode) && ITERATING_METHODS.include?(node.name)
+      return false unless node.is_a?(Prism::CallNode) && ITERATING_METHODS.key?(node.name)
 
       block = node.block
       return false unless block
@@ -236,10 +262,12 @@ module Crap4Ruby
     end
 
     def boundary?(node)
-      [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].any? do |type|
-        node.is_a?(type)
-      end ||
+      case node
+      when Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode
+        true
+      else
         !defined_name(node).nil?
+      end
     end
 
     # Selects body lines without nested methods, classes, or modules.
@@ -257,7 +285,7 @@ module Crap4Ruby
       return nil if start.location.start_line <= after
 
       excluded = [] #: Array[Integer]
-      last_line = body_end_line(node, excluded)
+      last_line = body_end_node(node, excluded).location.end_line
       lines = (start.location.start_line..last_line).to_a - excluded
       return nil if lines.include?(ending.end_line) && trailing_code?(ending)
 
@@ -270,14 +298,15 @@ module Crap4Ruby
     end
 
     # Heredoc interpolations can extend beyond their parent node's location.
-    def body_end_line(node, excluded)
-      last_line = node.location.end_line
+    # Compare byte offsets to defer line resolution until a range is needed.
+    def body_end_node(node, excluded)
+      last = node
       node.compact_child_nodes.each do |child|
-        child_line = body_end_line(child, excluded)
-        last_line = child_line if child_line > last_line
+        child_end = body_end_node(child, excluded)
+        last = child_end if child_end.end_offset > last.end_offset
       end
-      excluded.concat((node.location.start_line..last_line).to_a) if boundary?(node)
-      last_line
+      excluded.concat((node.location.start_line..last.location.end_line).to_a) if boundary?(node)
+      last
     end
   end
 end

data/lib/crap4ruby/batch.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Crap4Ruby
+  # Analyzes selected files and scores their methods in input order.
+  module Batch
+    # Reads Ruby source without executing it and preserves method order per file.
+    #
+    # @param files [Array<String>] source paths in analysis order
+    # @param coverage [Coverage, nil] measured coverage, or nil for complexity only
+    # @param jobs [Integer, nil] worker count, or nil for automatic selection
+    # @return [Array<Entry>] scored methods in file and traversal order
+    # @raise [ArgumentError] if the requested worker count is not positive
+    def self.call(files, coverage, jobs: nil)
+      raise ArgumentError, "jobs must be positive" if jobs && jobs < 1
+
+      count = worker_count(files.size, jobs)
+      count > 1 ? parallel(files, coverage, count) : serial(files, coverage)
+    end
+
+    class << self
+      private
+
+      def worker_count(size, jobs)
+        return 1 if size < 2 || jobs == 1 || (!jobs && size < 64)
+        return 1 unless Process.respond_to?(:fork) && Thread.list.one?
+
+        [size, jobs || [4, Etc.nprocessors].min].min
+      end
+
+      def serial(files, coverage)
+        analyzer = Analyzer.new(coverage: !coverage.nil?)
+        files.flat_map do |path|
+          analyzer.call(File.binread(path), path: path).map { |method| Score.call(method, coverage) }
+        end
+      end
+
+      def parallel(files, coverage, count)
+        # @type var workers: Array[worker]
+        workers = [] #: Array[worker]
+        begin
+          files.each_slice((files.size + count - 1) / count) do |chunk|
+            Thread.handle_interrupt(Exception => :never) { start_worker(chunk, coverage, workers) }
+          end
+        rescue NotImplementedError, Errno::EAGAIN, Errno::ENOMEM, Errno::EMFILE, Errno::ENFILE
+          cleanup(workers)
+          return serial(files, coverage)
+        end
+        results = workers.map { |worker| receive(worker) }
+        results.flat_map do |result|
+          raise result if result.is_a?(StandardError)
+
+          result
+        end
+      ensure
+        cleanup(workers)
+      end
+
+      def start_worker(files, coverage, workers)
+        # @type var pipes: Array[IO]
+        pipes = []
+        pid = nil #: Integer?
+        begin
+          2.times { pipes.concat(IO.pipe) }
+          pid = Process.fork do
+            run_child(pipes, files, coverage, workers)
+          end
+          workers << [pipes.fetch(0), pid, pipes.fetch(3)]
+        ensure
+          close_pipe(pipes[1])
+          close_pipe(pipes[2])
+          unless pid
+            close_pipe(pipes[0])
+            close_pipe(pipes[3])
+          end
+        end
+      end
+
+      def run_child(pipes, files, coverage, workers)
+        # @type var status: Integer
+        status = 1
+        workers.each do |worker|
+          close_pipe(worker[0])
+          close_pipe(worker[2])
+        end
+        close_pipe(pipes.fetch(0))
+        close_pipe(pipes.fetch(3))
+        cancellation = pipes.fetch(2)
+        Thread.new do
+          cancellation.read
+          Process.exit!(1)
+        end
+        result = child_result(files, coverage)
+        Marshal.dump(result, pipes.fetch(1))
+        status = 0
+      ensure
+        begin
+          close_pipe(pipes[1])
+        ensure
+          Process.exit!(status)
+        end
+      end
+
+      def child_result(files, coverage)
+        serial(files, coverage)
+      rescue StandardError => error
+        error
+      end
+
+      def receive(worker)
+        # @type var reader: IO
+        reader = worker[0]
+        data = reader.read
+        status = reap(worker)
+        if status && !status.success?
+          raise Error,
+            "analysis worker failed (exit #{status.exitstatus || "signal #{status.termsig}"})"
+        end
+
+        payload = decode(data)
+        return payload if payload.is_a?(StandardError)
+        return payload if payload.is_a?(Array) && payload.all?(Entry)
+
+        raise Error, "analysis worker returned invalid results"
+      rescue EOFError, TypeError, ArgumentError => error
+        raise Error, "analysis worker returned an invalid payload: #{error.message}"
+      ensure
+        reader.close unless reader.closed?
+      end
+
+      def decode(data)
+        # Only this call's child processes supply Marshal data; receive validates its shape.
+        # rubocop:disable-next Security/MarshalLoad
+        Marshal.load(data)
+      end
+
+      def cleanup(workers)
+        Thread.handle_interrupt(Exception => :never) do
+          workers.each do |worker|
+            close_pipe(worker[2])
+            close_pipe(worker[0])
+          end
+          # Close every cancellation channel before waiting for any worker.
+          # rubocop:disable-next Style/CombinableLoops
+          workers.each { |worker| reap(worker) }
+        end
+      end
+
+      def reap(worker)
+        pid = worker[1]
+        return unless pid
+
+        Thread.handle_interrupt(Exception => :never) do
+          # @type var status: Process::Status?
+          begin
+            _, status = Process.wait2(pid)
+          rescue Errno::ECHILD
+            # A host's SIGCHLD handler may have consumed the exit status.
+            status = nil
+          end
+          worker[1] = nil
+          status
+        end
+      end
+
+      def close_pipe(pipe)
+        pipe.close if pipe && !pipe.closed?
+      end
+    end
+  end
+end

data/lib/crap4ruby/cli.rb

@@ -33,7 +33,7 @@ module Crap4Ruby
 
       files = Discovery.call(root: root, source_roots: options[:source_roots], paths: paths, changed: options[:changed])
       coverage = load_coverage(options, root) unless options[:no_coverage] || files.empty?
-      entries = Report.sorted(analyze(files, coverage))
+      entries = Report.sorted(Batch.call(files, coverage, jobs: options[:jobs]))
       unless options[:no_save]
         path = Report.write(entries, root: root)
         @stderr.puts("Wrote #{path}")
@@ -47,12 +47,6 @@ module Crap4Ruby
 
     private
 
-    def analyze(files, coverage)
-      files.flat_map do |path|
-        Analyzer.new.call(File.binread(path), path: path).map { |method| Score.call(method, coverage) }
-      end
-    end
-
     # Removes parsed options from arguments and returns the remaining path selectors.
     #
     # @param arguments [Array<String>] mutable command-line tokens
@@ -78,6 +72,12 @@ module Crap4Ruby
         end
         cli.on("--no-coverage", "Complexity only; coverage and CRAP are N/A") { options[:no_coverage] = true }
         cli.on("--no-save", "Print results without writing .metrics/crap.edn") { options[:no_save] = true }
+        cli.on("--jobs N", Integer, "Worker processes (default: automatic; 1 disables workers)") do |jobs|
+          # @type var jobs: Integer
+          raise OptionParser::InvalidArgument, "jobs must be positive" if jobs < 1
+
+          options[:jobs] = jobs
+        end
         cli.on("--use-existing-coverage", "Read reports without running tests (the default)") do
           options[:existing] = true
         end

data/lib/crap4ruby/coverage.rb

@@ -79,7 +79,10 @@ module Crap4Ruby
 
       # Every element was validated above; Steep cannot narrow an array through all?.
       lines = lines #: Array[Integer?]
-      previous = @files[key] || []
+      # @type var previous: Array[Integer?]?
+      previous = @files[key]
+      return @files[key] = lines.dup unless previous
+
       @files[key] = Array.new([previous.size, lines.size].max) do |index|
         [previous[index], lines[index]].compact.max
       end

data/lib/crap4ruby/discovery.rb

@@ -66,8 +66,12 @@ module Crap4Ruby
         name = File.basename(path)
         if File.directory?(path)
           Find.prune if path != root && (name.start_with?(".") || EXCLUDED.include?(name) || File.symlink?(path))
-        elsif !File.symlink?(path) && !name.start_with?(".") && !name.match?(/\A(?:test|spec)_|_(?:test|spec)\.rb\z/)
-          paths << path
+        else
+          unless File.symlink?(path) || name.start_with?(".") || name.match?(/\A(?:test|spec)_|_(?:test|spec)\.rb\z/)
+            paths << path
+          end
+          # The file type is known; skip Find's repeated lstat.
+          Find.prune
         end
       end
       paths

data/lib/crap4ruby/report.rb

@@ -26,11 +26,8 @@ module Crap4Ruby
           entry.crap ? format("%.1f", entry.crap) : "N/A"]
       end
       widths = rows.transpose.map { |column| column.map(&:length).max }
-      lines = rows.map do |row|
-        row.each_with_index.map do |value, index|
-          index < 2 ? value.ljust(widths[index]) : value.rjust(widths[index])
-        end.join("  ")
-      end
+      template = "%-#{widths[0]}s  %-#{widths[1]}s  %#{widths[2]}s  %#{widths[3]}s  %#{widths[4]}s"
+      lines = rows.map { |row| format(template, *row) }
       lines.insert(1, "-" * lines.first.length)
       "#{(["CRAP Report", "==========="] + lines).join("\n")}\n"
     end
@@ -63,7 +60,8 @@ module Crap4Ruby
     def self.number(value)
       return "nil" if value.nil?
 
-      text = format("%.4f", value).sub(/0+\z/, "")
+      text = format("%.4f", value)
+      text.sub!(/0+\z/, "")
       text.end_with?(".") ? "#{text}0" : text
     end
 

data/lib/crap4ruby/score.rb

@@ -12,8 +12,12 @@ module Crap4Ruby
     def self.call(method, coverage)
       fraction = coverage&.fraction(method)
       if fraction
-        uncovered = 1 - fraction
-        crap = (method.complexity * method.complexity * uncovered * uncovered * uncovered) + method.complexity
+        # Combine integer terms before constructing the exact score.
+        denominator = fraction.denominator
+        uncovered = denominator - fraction.numerator
+        cube = denominator * denominator * denominator
+        complexity = method.complexity
+        crap = Rational((complexity * complexity * uncovered * uncovered * uncovered) + (complexity * cube), cube)
       end
       Entry.new(method.name, method.namespace, method.complexity, fraction && (fraction * 100).to_f, crap, method.path)
     end

data/lib/crap4ruby/version.rb

@@ -2,5 +2,5 @@
 
 module Crap4Ruby
   # Gem version used by the CLI and release process.
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/lib/crap4ruby.rb

@@ -26,7 +26,7 @@ module Crap4Ruby
   #     attr_reader :namespace
   #     # @return [Integer] cyclomatic complexity of the body
   #     attr_reader :complexity
-  #     # @return [Array<Integer>, nil] one-based body lines, or nil when line ownership is ambiguous
+  #     # @return [Array<Integer>, nil] one-based body lines, or nil when disabled or ambiguous
   #     attr_reader :lines
   #     # @return [String] source path supplied to the analyzer
   #     attr_reader :path
@@ -50,6 +50,7 @@ end
 require_relative "crap4ruby/analyzer"
 require_relative "crap4ruby/coverage"
 require_relative "crap4ruby/score"
+require_relative "crap4ruby/batch"
 require_relative "crap4ruby/report"
 require_relative "crap4ruby/discovery"
 require_relative "crap4ruby/cli"

data/sig/crap4ruby.rbs

@@ -31,14 +31,16 @@ module Crap4Ruby
   end
 
   class Analyzer
-    ITERATING_METHODS: Array[Symbol]
+    @coverage: bool
+    ITERATING_METHODS: Hash[Symbol, bool]
+    def initialize: (?coverage: bool) -> void
     def call: (String source, path: String) -> Array[MethodInfo]
     private
-    def discover: (Prism::Node? node, Array[String] scope, bool singleton, String path) -> Array[MethodInfo]
-    def discover_class: (Prism::ClassNode | Prism::ModuleNode node, Array[String] scope, bool singleton, String path) -> Array[MethodInfo]
-    def discover_call: (Prism::CallNode node, Array[String] scope, bool singleton, String path) -> Array[MethodInfo]
-    def discover_method: (Prism::DefNode node, Array[String] scope, bool singleton, String path) -> Array[MethodInfo]
-    def discover_block: (Prism::BlockNode block, String name, Array[String] scope, bool singleton, String path) -> Array[MethodInfo]
+    def discover: (Prism::Node? node, Array[String] scope, bool singleton, String path, ?Array[MethodInfo] methods) -> Array[MethodInfo]
+    def discover_class: (Prism::ClassNode | Prism::ModuleNode node, Array[String] scope, bool singleton, String path, Array[MethodInfo] methods) -> void
+    def discover_call: (Prism::CallNode node, Array[String] scope, bool singleton, String path, Array[MethodInfo] methods) -> void
+    def discover_method: (Prism::DefNode node, Array[String] scope, bool singleton, String path, Array[MethodInfo] methods) -> void
+    def discover_block: (Prism::BlockNode block, String name, Array[String] scope, bool singleton, String path, Array[MethodInfo] methods) -> void
     def defined_name: (Prism::Node node) -> String?
     def method_owner: (Prism::DefNode node, Array[String] scope) -> Array[String]?
     def qualify: (Prism::Node? node, Array[String] scope, ?declaration: bool) -> Array[String]?
@@ -51,7 +53,7 @@ module Crap4Ruby
     def boundary?: (Prism::Node node) -> bool
     def body_lines: (Prism::Node? node, after: Integer, ending: Prism::Location) -> Array[Integer]?
     def trailing_code?: (Prism::Location location) -> bool
-    def body_end_line: (Prism::Node node, Array[Integer] excluded) -> Integer
+    def body_end_node: (Prism::Node node, Array[Integer] excluded) -> Prism::Node
   end
 
   type json = nil | bool | Integer | Float | String | Array[json] | Hash[String, json]
@@ -79,6 +81,22 @@ module Crap4Ruby
     def self.call: (MethodInfo method, Coverage? coverage) -> Entry
   end
 
+  module Batch
+    type worker = [IO, Integer?, IO]
+    def self.call: (Array[String] files, Coverage? coverage, ?jobs: Integer?) -> Array[Entry]
+    def self.worker_count: (Integer size, Integer? jobs) -> Integer
+    def self.serial: (Array[String] files, Coverage? coverage) -> Array[Entry]
+    def self.parallel: (Array[String] files, Coverage? coverage, Integer count) -> Array[Entry]
+    def self.start_worker: (Array[String] files, Coverage? coverage, Array[worker] workers) -> void
+    def self.run_child: (Array[IO] pipes, Array[String] files, Coverage? coverage, Array[worker] workers) -> void
+    def self.child_result: (Array[String] files, Coverage? coverage) -> (Array[Entry] | StandardError)
+    def self.receive: (worker worker) -> (Array[Entry] | StandardError)
+    def self.decode: (String data) -> Object
+    def self.cleanup: (Array[worker] workers) -> void
+    def self.reap: (worker worker) -> Process::Status?
+    def self.close_pipe: (IO? pipe) -> void
+  end
+
   module Report
     def self.sorted: (Array[Entry] entries) -> Array[Entry]
     def self.table: (Array[Entry] entries) -> String
@@ -95,13 +113,13 @@ module Crap4Ruby
 
   class CLI
     type options = { root: String, source_roots: Array[String], changed: bool, coverage: String,
-      ?help: bool, ?version: bool, ?no_coverage: bool, ?no_save: bool, ?existing: bool, ?command: String, ?threshold: Rational }
+      ?help: bool, ?version: bool, ?no_coverage: bool, ?no_save: bool, ?existing: bool, ?command: String,
+      ?threshold: Rational, ?jobs: Integer }
     @stdout: _Output
     @stderr: _Output
     def initialize: (?stdout: _Output, ?stderr: _Output) -> void
     def run: (Array[String] arguments) -> Integer
     private
-    def analyze: (Array[String] files, Coverage? coverage) -> Array[Entry]
     def parse_options: (Array[String] arguments) -> [options, OptionParser, Array[String]]
     def validate_options: (options options) -> void
     def threshold_status: (Array[Entry] entries, Rational? threshold) -> Integer

data/sig/process.rbs

@@ -0,0 +1,12 @@
+# Fork-related APIs missing or incomplete in the bundled core signatures.
+module Process
+  def self.fork: () { () -> void } -> Integer
+  def self.exit!: (?Integer status) -> bot
+end
+
+class Thread
+  def self.list: () -> Array[Thread]
+               | ...
+  def self.handle_interrupt: [T] (Hash[Class, Symbol] mask) { () -> T } -> T
+                          | ...
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crap4ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -40,12 +40,14 @@ files:
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
 - LICENSE
+- PERFORMANCE.md
 - README.md
 - SECURITY.md
 - VERSIONING.md
 - exe/crap4ruby
 - lib/crap4ruby.rb
 - lib/crap4ruby/analyzer.rb
+- lib/crap4ruby/batch.rb
 - lib/crap4ruby/cli.rb
 - lib/crap4ruby/coverage.rb
 - lib/crap4ruby/discovery.rb
@@ -57,6 +59,7 @@ files:
 - scoring-audit.md
 - sig/crap4ruby.rbs
 - sig/manifest.yaml
+- sig/process.rbs
 - sig/stdlib.rbs
 homepage: https://github.com/svyatov/crap4ruby
 licenses: