crap4ruby 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef4ff5757bc98e35d4f9a59b34c2de273c8372b4b3019f0f1cd2234393900150
-  data.tar.gz: 7d05a4a6376b345e41ccaaba2311392e22608c4712ae61bae210a8ad392f540a
+  metadata.gz: e5227286a59e47edaf5fe8e20c8ce9c1abe6391b4f95304f8352c6b98fdf53dd
+  data.tar.gz: 2a569cea7aa8f9172d2ce2c854dec0d62c76ae3e73f1f3618f911b3d55c6deff
 SHA512:
-  metadata.gz: d0f0ae1b378c537b8eaac2972fa8bf866aeb3b0771fe0e66062b7e51309e2d08ae45c91a697ed948f5cb2e3837b2d0d7c21064c2fbf3542c9a764a1295bed790
-  data.tar.gz: b9454920d722a74389ae717afaa0cf01205b16ba08aeea24a814161ebf3b519ad2388d2b82a2a78bb9e8b244b723f5f8fcfd8c7198b9e0c55bb4e93564a7c5e3
+  metadata.gz: 25f98c5d9ca08faa51388483dc63735238f4dc0a20daf13a80ad104086e48c36d91fb2204a2d4e25a903ce17ccdd510cb8059be09b47ea4a582921fee1a5b649
+  data.tar.gz: b819b05ff07ec266c2316f77b317b2f45975e4ebd7ed2e4f325aea8553a2fa767033d4351086ab67979f9230523497f1d91aab3f49fad540ae911c529fd4dbce

data/CHANGELOG.md

@@ -5,6 +5,22 @@ Version numbers follow [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-28
+
+### Changed
+
+- Use RuboCop 1.92.1 complexity rules, including iteration blocks, safe-navigation discounts, rescue groups, and nested bodies, while excluding a method's own parameter defaults.
+- Discover bare `define_method` calls with literal symbol or string names and blocks.
+- Reject literal `define_method` names that cannot be represented in UTF-8, preserving the previous snapshot.
+- Report N/A for coverage and CRAP when a body shares its declaration line. Unknown scores pass a requested threshold only when their maximum possible score fits it; otherwise the check returns exit 1. These scoring and exit-code changes require a minor release. Regenerate coverage and snapshots and review thresholds when upgrading.
+
+### Fixed
+
+- Include executable interpolation lines when a method ends with a heredoc.
+- Discover explicit method definitions inside parameter defaults and superclass expressions.
+- Compare exact CRAP scores with decimal thresholds without floating-point rounding errors.
+- Avoid attributing trailing code on a method's closing line to the method, and escape control characters in displayed method names.
+
 ## [0.1.1] - 2026-10-28
 
 ### Changed
@@ -26,6 +42,7 @@ 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.1.1...HEAD
+[Unreleased]: https://github.com/svyatov/crap4ruby/compare/v0.2.0...HEAD
+[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
 [0.1.0]: https://github.com/svyatov/crap4ruby/releases/tag/v0.1.0

data/CONTRIBUTING.md

@@ -12,15 +12,25 @@ bin/setup
 bundle exec rake
 ```
 
-Before each commit, hooks scan staged changes for secrets and whitespace errors.
+Before each commit, hooks run Ruby lint checks and scan staged changes for secrets and whitespace errors.
 Commit messages must use Conventional Commits.
 Before each push, hooks run `bundle exec rake`.
 Put machine-specific hook settings in the ignored `lefthook-local.yml` file.
 
-The default check runs Steep, requires 100% typed calls across every Ruby file, runs tests with fresh SimpleCov coverage, and validates YARD documentation.
+The default check, also available as `bundle exec rake check`, runs RuboCop, Steep, tests with fresh SimpleCov coverage, YARD validation, and dependency audits.
+Every Ruby file must have 100% typed calls.
 Every library method's CRAP score must be at most 10.
 Use `bundle exec rake test` for tests alone. Open `coverage/index.html` to inspect line coverage.
 
+Run `bundle exec rake lint` to check Ruby style, formatting, performance, Minitest assertions, and Rake tasks.
+Run `bundle exec rake format` to apply RuboCop's safe corrections, then review the diff.
+RuboCop targets Ruby 3.3 and preserves the project's double-quoted strings and compact hashes.
+YARD and CRAP enforce documentation and complexity requirements; RuboCop's overlapping documentation and metrics checks are disabled.
+
+Run `bundle exec rake audit` to check both the development and release lockfiles for known vulnerabilities and insecure gem sources.
+The audit updates RubySec's advisory database over the network and stores it in the ignored `.cache/` directory.
+The default check and pre-push hook therefore require network access.
+
 Run `bundle exec rake types` for type checks alone.
 Keep library signatures in `sig/` and signatures for tests and development tools in `sig-development/`.
 The type gate rejects unchecked Ruby files, untyped signatures, and any call that Steep cannot type.

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.1.1.gem
+gem install ./crap4ruby-0.2.0.gem
 ```
 
 To use Bundler in the measured project, add this checkout to that project's `Gemfile`:
@@ -96,7 +96,7 @@ crap4ruby does not configure SimpleCov, delete reports, install dependencies, or
 | `--use-existing-coverage` | Explicitly select the default: read reports without running tests. |
 | `--coverage-command COMMAND` | Run a shell command that refreshes the selected report. |
 | `--no-coverage` | Report complexity with unknown coverage and CRAP. |
-| `--threshold NUMBER` | Exit 2 when any unrounded score exceeds this finite, nonnegative value. |
+| `--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. |
 
@@ -109,9 +109,12 @@ Discovery includes `.rb` files. It skips hidden directories, test/spec files, an
 Test filenames are `test_*.rb`, `spec_*.rb`, `*_test.rb`, and `*_spec.rb`.
 An explicitly named file overrides these exclusions. Directory traversal does not follow symbolic links.
 
-Exit 0 means analysis succeeded. Exit 1 means invalid usage, unreadable or invalid input, a Git failure, or a coverage command failure.
-Exit 2 means analysis succeeded but exceeded the threshold. No threshold applies unless you set one.
-Every successful analysis replaces the snapshot, including filtered analyses and empty selections.
+Exit 0 means analysis succeeded and any requested threshold was verified. Exit 1 means invalid usage, unreadable or invalid input, a Git failure, a coverage command failure, or an uncertain threshold result.
+Exit 2 means a measured score exceeded the threshold. A measured violation takes precedence over uncertainty. No threshold applies unless you set one.
+Decimal thresholds are compared exactly with the computed scores, before display rounding.
+For unknown scores, the check uses the maximum possible score, `CC^2 + CC`, at zero coverage. If this maximum fits the threshold, the method passes; otherwise, the check returns exit 1 and names the method. Its displayed score remains N/A. This also applies with `--no-coverage`.
+For example, an unknown score at CC 2 passes a threshold of 6, but cannot pass a threshold of 5. Supply fresh, measurable coverage or adjust the limit to resolve uncertainty.
+Every completed analysis replaces the snapshot, including filtered analyses, empty selections, and failed threshold checks.
 
 ## Complexity and coverage
 
@@ -121,26 +124,34 @@ The scoring engine uses this formula, with coverage expressed as a fraction betw
 CRAP = CC^2 * (1 - coverage)^3 + CC
 ```
 
-Cyclomatic complexity (CC) starts at 1. Each of these adds 1:
+The formula follows the [original CRAP definition](https://www.artima.com/weblogs/viewpost.jsp?thread=210575). This tool uses line coverage as a proxy for the original definition's basis path coverage. These measurements are not equivalent.
+
+Cyclomatic complexity (CC) follows [RuboCop 1.92.1](https://github.com/rubocop/rubocop/blob/aa228eb03094d66aca26664839ca14b10d76f702/lib/rubocop/cop/metrics/cyclomatic_complexity.rb). It starts at 1. Each of these adds 1:
 
 - `if`, `elsif`, `unless`, and ternary conditions, including modifier forms.
-- `while`, `until`, and `for` loops.
-- Each `when` or pattern-matching `in` clause, including a separate increment for a guard condition.
-- Each rescue clause and rescue modifier.
-- Each `&&`, `||`, `and`, `or`, `&&=`, `||=`, and safe-navigation operation.
+- `while`, `until`, and `for` loops, except post-test `begin ... end while/until` forms.
+- Each `when` or pattern-matching `in` clause. A pattern guard's `if`/`unless` wrapper adds nothing; decisions within its condition still count.
+- Each rescue group, regardless of its number of clauses, and each rescue modifier.
+- Each `&&`, `||`, `and`, `or`, `&&=`, and `||=` operation.
+- Each safe-navigation operation, except repeated use of the same local receiver until its next assignment.
+- Each ordinary block or block argument passed to a [known iteration method](https://github.com/rubocop/rubocop/blob/aa228eb03094d66aca26664839ca14b10d76f702/lib/rubocop/cop/metrics/utils/iterating_block.rb), such as `map`, `each`, or `reduce`.
 
 A `when` clause adds 1 regardless of its number of alternatives. `else` and `ensure` add nothing.
 Decisions inside ordinary blocks and lambdas belong to their enclosing method.
-Decisions in parameter defaults also count; coverage still measures only the body.
-Nested methods are separate entries. Their bodies and nested class/module bodies do not increase the enclosing method's score.
-Calling `each`, `map`, or another iterator does not itself add complexity.
+The method's own parameter defaults do not count. Nested definitions and their defaults, including nested class/module bodies, contribute decisions to the enclosing body, as in RuboCop.
+The safe-navigation discount follows local variable names across that entire body, including nested scopes, in RuboCop's AST traversal order. Assignments reset it; parameters, pattern bindings, and named regexp captures do not.
+RuboCop 1.92.1 does not add an iteration point for numbered or implicit-`it` blocks. This tool preserves that version's behavior. Iterator calls without a block add nothing.
+Nested methods are also separate entries. Definitions inside parameter defaults and superclass expressions are discovered too.
 
 Coverage is the fraction of executable method-body lines with positive hit counts.
-Separate `def` headers are excluded: loading a definition does not prove that tests called its method.
+Declaration lines and nested method/class/module bodies are excluded from coverage. Loading a definition does not prove that tests called its method.
+When the body shares a line with its declaration, coverage and CRAP are N/A, even if that line has hits. This includes ordinary inline methods, one-line endless methods, and inline `define_method` blocks. Put the body on separate lines to obtain measurable coverage.
+Coverage is also N/A when a selected body line contains trailing code after the definition, including enclosing delimiters that cannot be separated from that line's hit count. Put the closing delimiter on its own line. Comments and empty statement separators do not trigger this check.
+Executable heredoc interpolation lines are included, even when the heredoc is the method's final expression.
 Null lines do not enter the denominator. Multiple suites are merged by covered-line union, without applying an age cutoff.
 Coverage paths must match absolute source paths or paths relative to the project root; unrelated checkout prefixes are not guessed.
 
-A method absent from a valid report receives 0% coverage. A body with no measurable lines receives N/A.
+A method with unambiguous body lines in a file absent from a valid report receives 0% coverage. A reported body with no measurable lines receives N/A.
 Missing or malformed reports stop analysis unless `--no-coverage` is explicit.
 Reports are accepted as supplied; generate fresh coverage after changing source files.
 
@@ -164,12 +175,15 @@ A filtered run writes only its selected methods. Reopened classes and repeated d
 
 ## Limits
 
-Analysis covers explicit method definitions, including private and endless methods.
-It does not execute Ruby or resolve runtime metaprogramming, `define_method`, aliases, generated accessors, or dynamic singleton receivers.
+Analysis covers explicit method definitions, including private and endless methods, and bare `define_method` calls with one literal symbol/string name and a block.
+Literal `define_method` names must be representable in UTF-8; unsupported names produce an error without replacing the previous snapshot.
+It does not execute Ruby or resolve other runtime metaprogramming, dynamic `define_method` names, calls with explicit receivers, aliases, generated accessors, or dynamic singleton receivers.
 Namespaces derived from expressions, such as `factory::Thing`, are skipped with their contents.
-Line coverage cannot distinguish expressions or methods sharing a source line, or separate evaluation of default parameters.
+Line coverage cannot distinguish expressions sharing a source line or separate evaluation of default parameters.
 Branch coverage is not used. Static namespace names do not reflect runtime constant reassignment.
 
+These counting and threshold rules change results from 0.1.x and require a minor release under the versioning policy. Regenerate coverage and snapshots and review existing limits when upgrading.
+
 ## Development
 
 ```sh

data/lib/crap4ruby/analyzer.rb

@@ -1,9 +1,25 @@
 # frozen_string_literal: true
 
 module Crap4Ruby
-  # Finds explicit Ruby method definitions without executing source code.
+  # Finds explicit methods and literal define_method blocks without executing code.
   class Analyzer
-    # Analyzes method bodies and parameter defaults with Prism.
+    # RuboCop 1.92.1 Metrics::Utils::IteratingBlock's method-name policy.
+    ITERATING_METHODS = %i[
+      all? any? chain chunk chunk_while collect collect_concat count cycle
+      detect drop drop_while each each_cons each_entry each_slice
+      each_with_index each_with_object entries filter filter_map find
+      find_all find_index flat_map grep grep_v group_by inject lazy map
+      max max_by min min_by minmax minmax_by none? one? partition reduce
+      reject reverse_each select slice_after slice_before slice_when sort
+      sort_by sum take take_while tally to_h uniq zip with_index with_object
+      bsearch bsearch_index collect! combination d_permutation delete_if
+      each_index keep_if map! permutation product reject! repeat
+      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
+
+    # Analyzes method bodies with Prism and the RuboCop 1.92.1 counting rules.
     #
     # @param source [String] Ruby source text
     # @param path [String] source label used in results and parse errors
@@ -34,19 +50,62 @@ module Crap4Ruby
 
       case node
       when Prism::ClassNode, Prism::ModuleNode
-        owner = qualify(node.constant_path, scope, declaration: true)
-        owner ? discover(node.body, owner, false, path) : []
+        discover_class(node, scope, singleton, path)
       when Prism::SingletonClassNode
         owner = node.expression.is_a?(Prism::SelfNode) ? scope : qualify(node.expression, scope)
         owner ? discover(node.body, owner, true, path) : []
       when Prism::DefNode
         discover_method(node, scope, singleton, path)
+      when Prism::CallNode
+        discover_call(node, scope, singleton, path)
+      else
+        node.compact_child_nodes.flat_map { |child| discover(child, scope, singleton, path) }
+      end
+    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) : []
+      owner = qualify(node.constant_path, scope, declaration: true)
+      methods + (owner ? discover(node.body, owner, false, path) : [])
+    end
+
+    def discover_call(node, scope, singleton, path)
+      name = defined_name(node)
+      block = node.block
+      if name && block.is_a?(Prism::BlockNode)
+        discover_block(block, name, scope, singleton, path)
       else
         node.compact_child_nodes.flat_map { |child| discover(child, scope, singleton, path) }
       end
     end
 
-    # Measures a definition independently from definitions nested within it.
+    def discover_block(block, name, scope, singleton, path)
+      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)
+      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)
+    rescue EncodingError
+      raise Error, "#{path}:#{block.location.start_line}: define_method name must be representable in UTF-8"
+    end
+
+    def defined_name(node)
+      return unless node.is_a?(Prism::CallNode) && node.name == :define_method && node.receiver.nil?
+      return unless node.block.is_a?(Prism::BlockNode)
+
+      arguments = node.arguments&.arguments
+      return unless arguments && arguments.size == 1
+
+      name = arguments.first
+      name.unescaped if name.is_a?(Prism::SymbolNode) || name.is_a?(Prism::StringNode)
+    end
+
+    # Builds this method's entry and discovers nested definitions.
     #
     # @param node [Prism::DefNode] method definition
     # @param scope [Array<String>] lexical namespace components
@@ -54,16 +113,22 @@ module Crap4Ruby
     # @param path [String] source label
     # @return [Array<MethodInfo>] this method and its nested definitions
     def discover_method(node, scope, singleton, path)
-      owner = node.receiver && !node.receiver.is_a?(Prism::SelfNode) ? qualify(node.receiver, scope) : scope
+      owner = method_owner(node, scope)
       return [] unless owner
 
-      name = "#{'self.' if singleton || node.receiver}#{node.name}"
-      lines = body_lines(node.body)
-      complexity = 1 + decisions(node.parameters) + decisions(node.body)
+      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)
+      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)
     end
 
+    def method_owner(node, scope)
+      node.receiver && !node.receiver.is_a?(Prism::SelfNode) ? qualify(node.receiver, scope) : scope
+    end
+
     # Resolves constant syntax without looking up runtime constants.
     # Declarations append names; references can reuse a lexical ancestor.
     #
@@ -86,50 +151,133 @@ module Crap4Ruby
       end
     end
 
-    # Counts branch operations, including safe navigation, outside nested definitions.
+    # Counts the entire body, with RuboCop's per-method safe-navigation discount.
     #
     # @param node [Prism::Node, nil] subtree to measure
     # @return [Integer] number of decisions, excluding the method's base complexity
-    def decisions(node)
+    # @param seen [Hash<Symbol, Boolean>] local receivers since their last assignment
+    # @param target [Boolean] whether a target node belongs to an assignment
+    def decisions(node, seen = {}, target: false)
       return 0 unless node
-      return 0 if boundary?(node)
 
-      decision = [:if_node, :unless_node, :while_node, :until_node, :for_node,
-        :when_node, :in_node, :rescue_node, :rescue_modifier_node, :and_node, :or_node].include?(node.type) ||
-        node.type.to_s.match?(/_(?:and|or)_write_node\z/)
-      count = decision ? 1 : 0
+      case node
+      when Prism::LocalVariableWriteNode, Prism::LocalVariableAndWriteNode,
+          Prism::LocalVariableOrWriteNode, Prism::LocalVariableOperatorWriteNode
+        seen.delete(node.name)
+      when Prism::LocalVariableTargetNode
+        seen.delete(node.name) if target
+      end
+      count = decision?(node) ? 1 : 0
+      count += 1 if iteration?(node)
+      count += 1 if safe_navigation?(node, seen)
+      count + child_decisions(node, seen, target)
+    end
+
+    def child_decisions(node, seen, target)
+      # RuboCop visits unless branches and guarded patterns in this order.
+      if node.is_a?(Prism::UnlessNode)
+        return decisions(node.predicate, seen) + decisions(node.else_clause, seen) + decisions(node.statements, seen)
+      end
+
+      if node.is_a?(Prism::InNode)
+        guard = node.pattern
+        if guard.is_a?(Prism::IfNode) || guard.is_a?(Prism::UnlessNode)
+          return decisions(guard.statements, seen) + decisions(guard.predicate, seen) + decisions(node.statements, seen)
+        end
+      end
+      node.compact_child_nodes.sum { |child| decisions(child, seen, target: assignment_target?(node, child, target)) }
+    end
+
+    def assignment_target?(node, child, target)
+      case node
+      when Prism::MultiWriteNode then child != node.value
+      when Prism::MultiTargetNode, Prism::SplatNode then target
+      when Prism::ForNode then child == node.index
+      when Prism::RescueNode then child == node.reference
+      else false
+      end
+    end
+
+    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?)
+    end
+
+    def safe_navigation?(node, seen)
       case node
       when Prism::CallNode, Prism::CallAndWriteNode, Prism::CallOrWriteNode,
           Prism::CallOperatorWriteNode, Prism::CallTargetNode, Prism::IndexAndWriteNode,
           Prism::IndexOrWriteNode, Prism::IndexOperatorWriteNode, Prism::IndexTargetNode
-        count += 1 if node.safe_navigation?
+        return false unless node.safe_navigation?
+
+        receiver = node.receiver
+        return true unless receiver.is_a?(Prism::LocalVariableReadNode)
+        return false if seen[receiver.name]
+
+        seen[receiver.name] = true
+      else
+        false
       end
-      count + node.compact_child_nodes.sum { |child| decisions(child) }
+    end
+
+    def iteration?(node)
+      return false unless node.is_a?(Prism::CallNode) && ITERATING_METHODS.include?(node.name)
+
+      block = node.block
+      return false unless block
+      return true unless block.is_a?(Prism::BlockNode)
+
+      parameters = block.parameters
+      !parameters || parameters.is_a?(Prism::BlockParametersNode)
     end
 
     def boundary?(node)
-      [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].any? { |type| node.is_a?(type) }
+      [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].any? do |type|
+        node.is_a?(type)
+      end ||
+        !defined_name(node).nil?
     end
 
     # Selects body lines without nested methods, classes, or modules.
     #
     # @param node [Prism::Node, nil] method body
-    # @return [Array<Integer>] one-based source lines; empty for an absent body
-    def body_lines(node)
+    # @param after [Integer] last line of the method declaration
+    # @param ending [Prism::Location] definition location, including its closing delimiter
+    # @return [Array<Integer>, nil] body lines; nil when shared with the declaration
+    def body_lines(node, after:, ending:)
       return [] unless node
 
-      lines = (node.location.start_line..node.location.end_line).to_a
+      # @type var start: Prism::Node?
+      start = node.is_a?(Prism::BeginNode) && !node.begin_keyword_loc ? node.compact_child_nodes.first : node
+      return [] unless start
+      return nil if start.location.start_line <= after
+
       excluded = [] #: Array[Integer]
-      collect_boundaries(node, excluded)
-      lines - excluded
+      last_line = body_end_line(node, excluded)
+      lines = (start.location.start_line..last_line).to_a - excluded
+      return nil if lines.include?(ending.end_line) && trailing_code?(ending)
+
+      lines
     end
 
-    def collect_boundaries(node, excluded)
-      if boundary?(node)
-        excluded.concat((node.location.start_line..node.location.end_line).to_a)
-      else
-        node.compact_child_nodes.each { |child| collect_boundaries(child, excluded) }
+    def trailing_code?(location)
+      tail = location.slice_lines.lines.last.to_s.byteslice(location.end_column..).to_s
+      !tail.match?(/\A[;\s]*(?:#|\z)/)
+    end
+
+    # Heredoc interpolations can extend beyond their parent node's location.
+    def body_end_line(node, excluded)
+      last_line = node.location.end_line
+      node.compact_child_nodes.each do |child|
+        child_line = body_end_line(child, excluded)
+        last_line = child_line if child_line > last_line
       end
+      excluded.concat((node.location.start_line..last_line).to_a) if boundary?(node)
+      last_line
     end
   end
 end

data/lib/crap4ruby/cli.rb

@@ -19,7 +19,7 @@ module Crap4Ruby
     # Expected usage, input, filesystem, and command errors are printed to stderr.
     #
     # @param arguments [Array<String>] command-line tokens; option parsing mutates this array
-    # @return [Integer] 0 on success, 1 on a handled error, or 2 when a score exceeds the threshold
+    # @return [Integer] 0 on success, 1 on error or an uncertain threshold, 2 on a measured violation
     # @example Analyze complexity without coverage
     #   CLI.new.run(["--no-coverage", "--source-root", "lib"])
     def run(arguments)
@@ -33,10 +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 = files.flat_map do |path|
-        Analyzer.new.call(File.binread(path), path: path).map { |method| Score.call(method, coverage) }
-      end
-      entries = Report.sorted(entries)
+      entries = Report.sorted(analyze(files, coverage))
       path = Report.write(entries, root: root)
       @stdout.write(Report.table(entries))
       @stderr.puts("Wrote #{path}")
@@ -48,6 +45,12 @@ 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
@@ -72,17 +75,22 @@ module Crap4Ruby
           options[:coverage] = path
         end
         cli.on("--no-coverage", "Complexity only; coverage and CRAP are N/A") { options[:no_coverage] = true }
-        cli.on("--use-existing-coverage", "Read reports without running tests (the default)") { options[:existing] = true }
+        cli.on("--use-existing-coverage", "Read reports without running tests (the default)") do
+          options[:existing] = true
+        end
         cli.on("--coverage-command COMMAND", "Run a shell command that refreshes the resultset") do |command|
           # @type var command: String
           options[:command] = command
         end
-        cli.on("--threshold NUMBER", "Exit 2 when CRAP exceeds this value") do |value|
+        cli.on("--threshold NUMBER", "Exit 2 above limit; exit 1 if unknown scores could exceed it") do |value|
           # @type var value: String
           number = Float(value)
-          raise OptionParser::InvalidArgument, "threshold must be finite and nonnegative" unless number.finite? && number >= 0
+          raise ArgumentError unless number.finite?
 
-          options[:threshold] = number
+          threshold = Rational(value, exception: false) || number.to_r
+          raise ArgumentError if threshold.negative?
+
+          options[:threshold] = threshold
         rescue ArgumentError
           raise OptionParser::InvalidArgument, "threshold must be finite and nonnegative"
         end
@@ -98,23 +106,30 @@ module Crap4Ruby
     # @return [void]
     # @raise [Error] if coverage options conflict
     def validate_options(options)
-      if options[:command] && (options[:no_coverage] || options[:existing])
-        raise Error, "--coverage-command cannot be combined with --no-coverage or --use-existing-coverage"
-      end
+      return unless options[:command] && (options[:no_coverage] || options[:existing])
+
+      raise Error, "--coverage-command cannot be combined with --no-coverage or --use-existing-coverage"
     end
 
-    # Compares unrounded, known CRAP scores with a strict upper limit.
+    # Checks measured scores and bounds unknown scores at zero coverage.
     #
     # @param entries [Array<Entry>] scored methods
-    # @param threshold [Float, nil] maximum allowed score, or nil to disable the check
-    # @return [Integer] 2 after reporting a violation to stderr, otherwise 0
+    # @param threshold [Rational, nil] maximum allowed score, or nil to disable the check
+    # @return [Integer] 2 for a measured violation, 1 if uncertain, otherwise 0
     def threshold_status(entries, threshold)
-      if threshold && entries.any? { |entry| entry.crap && entry.crap > threshold }
-        @stderr.puts("CRAP threshold exceeded: #{threshold}")
-        2
-      else
-        0
+      return 0 unless threshold
+
+      if entries.any? { |entry| entry.crap && entry.crap > threshold }
+        @stderr.puts("CRAP threshold exceeded")
+        return 2
       end
+
+      uncertain = entries.select { |entry| !entry.crap && entry.complexity * (entry.complexity + 1) > threshold }
+      uncertain.each do |entry|
+        @stderr.puts("Cannot verify CRAP threshold: #{Report.label("#{entry.namespace}##{entry.name}")} " \
+                     "has unknown coverage (maximum #{entry.complexity * (entry.complexity + 1)})")
+      end
+      uncertain.empty? ? 0 : 1
     end
 
     def load_coverage(options, root)
@@ -141,7 +156,10 @@ module Crap4Ruby
         output.each_line { |line| @stderr.write(line) }
         process.value
       end
-      raise Error, "coverage command failed (exit #{status.exitstatus || "signal #{status.termsig}"})" unless status.success?
+      unless status.success?
+        raise Error,
+          "coverage command failed (exit #{status.exitstatus || "signal #{status.termsig}"})"
+      end
       raise Error, "coverage command did not refresh #{report}" if report_stamp(report) == before
     end
 

data/lib/crap4ruby/coverage.rb

@@ -14,7 +14,8 @@ module Crap4Ruby
     def self.load(path, root:)
       new(JSON.parse(File.read(path)), root: root)
     rescue SystemCallError => error
-      raise Error, "#{path}: cannot read coverage report; generate SimpleCov coverage or use --no-coverage (#{error.message})"
+      raise Error,
+        "#{path}: cannot read coverage report; generate SimpleCov coverage or use --no-coverage (#{error.message})"
     rescue JSON::ParserError, Error => error
       raise Error, "#{path}: invalid SimpleCov report (#{error.message})"
     end
@@ -35,27 +36,29 @@ module Crap4Ruby
     # Null and out-of-range lines do not enter the denominator.
     #
     # @param method [MethodInfo] method whose path and body lines select coverage
-    # @return [Float, nil] fraction from 0 to 1; zero for an absent file,
-    #   or nil when a reported file has no measurable body lines
+    # @return [Rational, nil] exact fraction from 0 to 1; zero for an absent file,
+    #   or nil when body lines are ambiguous or no reported lines are measurable
     def fraction(method)
+      body = method.lines
+      return nil unless body
+
       path = File.expand_path(method.path)
       path = File.realpath(path) if File.exist?(path)
       # @type var lines: Array[Integer?]?
       lines = @files[path]
-      return 0.0 unless lines
+      return Rational(0) unless lines
 
-      hits = method.lines.filter_map { |line| lines[line - 1] }
+      hits = body.filter_map { |line| lines[line - 1] }
       return nil if hits.empty?
 
-      hits.count(&:positive?).fdiv(hits.size)
+      Rational(hits.count(&:positive?), hits.size)
     end
 
     private
 
     def add_suite(suite, root)
-      unless suite.is_a?(Hash) && suite["coverage"].is_a?(Hash)
-        raise Error, "expected a coverage object for each suite"
-      end
+      raise Error, "expected a coverage object for each suite" unless suite.is_a?(Hash) && suite["coverage"].is_a?(Hash)
+
       suite["coverage"].each { |path, data| add_file(path, data, root) }
     end
 
@@ -73,6 +76,7 @@ module Crap4Ruby
       unless lines.is_a?(Array) && lines.all? { |hit| hit.nil? || (hit.is_a?(Integer) && hit >= 0) }
         raise Error, "#{path}: expected nonnegative line counts or null"
       end
+
       # Every element was validated above; Steep cannot narrow an array through all?.
       lines = lines #: Array[Integer?]
       previous = @files[key] || []