rigortype 0.2.7 → 0.2.9

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_type_resolver.rb

@@ -6,28 +6,22 @@ require "rigor/type"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Resolves the runtime type of a
-      # `let(:name) { body }` or `subject(:name) { body }`
-      # block by pattern-matching its body's tail expression.
+      # Resolves the runtime type of a `let(:name) { body }` or `subject(:name) { body }` block by
+      # pattern-matching its body's tail expression.
       #
       # Recognised body shapes (floor):
       #
       # - `ConstantClass.new(...)` → `Nominal[ConstantClass]`
       # - `Foo::Bar.new(...)` → `Nominal[Foo::Bar]`
-      # - `described_class.new(...)` → `Nominal[<describe const>]`
-      #   when the surrounding describe block has a constant
-      #   anchor.
-      # - `create(:factory)` / `build(:factory)` /
-      #   `build_stubbed(:factory)` / `attributes_for(:factory)`
-      #   → `Nominal[<factory.model_class>]` when the
-      #   `:factory_index` ADR-9 fact is available and the
+      # - `described_class.new(...)` → `Nominal[<describe const>]` when the surrounding describe block has
+      #   a constant anchor.
+      # - `create(:factory)` / `build(:factory)` / `build_stubbed(:factory)` / `attributes_for(:factory)` →
+      #   `Nominal[<factory.model_class>]` when the `:factory_index` ADR-9 fact is available and the
       #   factory name is known.
-      # - `FactoryBot.create(:factory)` etc. — same as the
-      #   implicit-receiver factorybot form.
+      # - `FactoryBot.create(:factory)` etc. — same as the implicit-receiver factorybot form.
       #
-      # Returns `nil` for any other body shape. Multi-statement
-      # bodies use the LAST statement (the block's return
-      # value).
+      # Returns `nil` for any other body shape. Multi-statement bodies use the LAST statement (the block's
+      # return value).
       module LetTypeResolver
         FACTORYBOT_ENTRY_METHODS = %i[
           create build build_stubbed attributes_for
@@ -38,9 +32,8 @@ module Rigor
 
         # @param block_node [Prism::BlockNode]
         # @param describe_const [String, nil]
-        # @param factory_index [Object, nil] something
-        #   responding to `find(factory_name)` and returning
-        #   an entry that responds to `model_class`.
+        # @param factory_index [Object, nil] something responding to `find(factory_name)` and returning an
+        #   entry that responds to `model_class`.
         # @param environment [Rigor::Environment, nil]
         # @return [Rigor::Type, nil]
         def resolve(block_node, describe_const:, factory_index:, environment:)
@@ -103,10 +96,8 @@ module Rigor
           nominal_for(model_class, environment: environment)
         end
 
-        # Recognises both `create(:name)` (implicit receiver,
-        # via `include FactoryBot::Syntax::Methods`) and the
-        # explicit `FactoryBot.create(:name)` /
-        # `FactoryGirl.create(:name)` (legacy) forms.
+        # Recognises both `create(:name)` (implicit receiver, via `include FactoryBot::Syntax::Methods`)
+        # and the explicit `FactoryBot.create(:name)` / `FactoryGirl.create(:name)` (legacy) forms.
         def factorybot_call?(call_node)
           return false unless FACTORYBOT_ENTRY_METHODS.include?(call_node.name)
 

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb

@@ -8,59 +8,42 @@ require "rigor/flow_contribution/fact"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Recognises `expect(x).to MATCHER`
-      # patterns at per-call recognition time and emits
-      # `post_return_facts` that narrow the named local on the
-      # post-call edge.
+      # Recognises `expect(x).to MATCHER` patterns at per-call recognition time and emits
+      # `post_return_facts` that narrow the named local on the post-call edge.
       #
-      # The supported matchers are the lowest-false-positive
-      # floor of the RSpec matcher DSL:
+      # The supported matchers are the lowest-false-positive floor of the RSpec matcher DSL:
       #
-      # - `be_a(T)` / `be_kind_of(T)` — `x is_a?(T)` style class
-      #   membership; narrows `x` to `T`.
-      # - `be_instance_of(T)` — exact-class match; narrows
-      #   `x` to `T` (the engine currently treats Nominal[T]
-      #   uniformly, so the distinction with `be_a` is observed
-      #   at the carrier level but not the runtime).
+      # - `be_a(T)` / `be_kind_of(T)` — `x is_a?(T)` style class membership; narrows `x` to `T`.
+      # - `be_instance_of(T)` — exact-class match; narrows `x` to `T` (the engine currently treats
+      #   Nominal[T] uniformly, so the distinction with `be_a` is observed at the carrier level but not the
+      #   runtime).
       # - `be_nil` — narrows `x` to `Constant<nil>`.
-      # - `eq(LITERAL)` for a literal-value argument — narrows
-      #   `x` to `Constant<literal>`.
+      # - `eq(LITERAL)` for a literal-value argument — narrows `x` to `Constant<literal>`.
       #
-      # The matchers below this floor (`be_truthy` / `be_falsey`
-      # / `be_within` / `be > / < / >=` / `include` / `start_with`
-      # / `match(regex)` / `raise_error` / receive-style mocks)
-      # require either edge-aware fragments (`truthy_facts` /
-      # `falsey_facts` rather than `post_return_facts`) or
-      # diagnostic-only enforcement; both are queued for follow-up
-      # slices.
+      # The matchers below this floor (`be_truthy` / `be_falsey` / `be_within` / `be > / < / >=` /
+      # `include` / `start_with` / `match(regex)` / `raise_error` / receive-style mocks) require either
+      # edge-aware fragments (`truthy_facts` / `falsey_facts` rather than `post_return_facts`) or
+      # diagnostic-only enforcement; both are queued for follow-up slices.
       #
       # The analyzer fires ONLY when:
       #
-      # 1. The call node is one of `<recv>.to(matcher)` /
-      #    `<recv>.not_to(matcher)` / `<recv>.to_not(matcher)`.
-      #    `not_to` / `to_not` flip the fact's `negative` flag
-      #    so the engine narrows AWAY from the matcher's type
-      #    (e.g. `not_to be_nil` removes nil from the receiver).
-      # 2. The receiver is `expect(<local_var>)` — exactly one
-      #    positional argument that's a LocalVariableReadNode.
-      #    Composite receivers (`expect(foo.bar)`,
-      #    `expect { ... }.to raise_error`) fall through.
-      # 3. The matcher is one of the recognised forms above
-      #    (`be_a` / `be_kind_of` / `be_instance_of` /
-      #    `be_an_instance_of` / `be_nil` / `eq(literal)` /
-      #    `eql(literal)` / `match(/regex/)`).
+      # 1. The call node is one of `<recv>.to(matcher)` / `<recv>.not_to(matcher)` /
+      #    `<recv>.to_not(matcher)`. `not_to` / `to_not` flip the fact's `negative` flag so the engine
+      #    narrows AWAY from the matcher's type (e.g. `not_to be_nil` removes nil from the receiver).
+      # 2. The receiver is `expect(<local_var>)` — exactly one positional argument that's a
+      #    LocalVariableReadNode. Composite receivers (`expect(foo.bar)`, `expect { ... }.to raise_error`)
+      #    fall through.
+      # 3. The matcher is one of the recognised forms above (`be_a` / `be_kind_of` / `be_instance_of` /
+      #    `be_an_instance_of` / `be_nil` / `eq(literal)` / `eql(literal)` / `match(/regex/)`).
       module MatcherAnalyzer
         module_function
 
-        # @param call_node [Prism::CallNode] the call whose
-        #   contribution we're computing. Returns nil when the
-        #   call shape does not match `expect(local).to matcher`.
-        # @param environment [Rigor::Environment, nil] the
-        #   surrounding environment used to resolve a matcher's
-        #   class-name argument to a `Type::Nominal`. When nil,
-        #   class-name resolution falls back to a bare
-        #   `Nominal[<name>]` carrier (sound — the receiver
-        #   constant may be a user class not in RBS).
+        # @param call_node [Prism::CallNode] the call whose contribution we're computing. Returns nil when
+        #   the call shape does not match `expect(local).to matcher`.
+        # @param environment [Rigor::Environment, nil] the surrounding environment used to resolve a
+        #   matcher's class-name argument to a `Type::Nominal`. When nil, class-name resolution falls back
+        #   to a bare `Nominal[<name>]` carrier (sound — the receiver constant may be a user class not in
+        #   RBS).
         # @return [Rigor::FlowContribution, nil]
         def contribution_for(call_node, environment:)
           verb = assertion_verb(call_node)
@@ -136,11 +119,9 @@ module Rigor
           when :eq, :eql
             constant_type_for_literal_arg(matcher)
           when :match
-            # `match(/regex/)` narrows x to String. `match("...")`
-            # or `match(arbitrary_object)` falls through — the
-            # broader matcher dispatch needs the receiver to be a
-            # String, but we can only assert that for a literal
-            # regex.
+            # `match(/regex/)` narrows x to String. `match("...")` or `match(arbitrary_object)` falls
+            # through — the broader matcher dispatch needs the receiver to be a String, but we can only
+            # assert that for a literal regex.
             string_type_for_regex_arg(matcher)
           end
         end
@@ -184,10 +165,9 @@ module Rigor
         NO_LITERAL = Object.new.freeze
         private_constant :NO_LITERAL
 
-        # Returns the Ruby value of a literal-AST argument, or
-        # `NO_LITERAL` when the node isn't a recognised literal
-        # shape. Recognised forms cover the common `eq(literal)`
-        # case: integer, float, true/false/nil, string, symbol.
+        # Returns the Ruby value of a literal-AST argument, or `NO_LITERAL` when the node isn't a
+        # recognised literal shape. Recognised forms cover the common `eq(literal)` case: integer, float,
+        # true/false/nil, string, symbol.
         def literal_value_for(node)
           case node
           when Prism::IntegerNode then node.value
@@ -206,10 +186,8 @@ module Rigor
           args.nil? || args.empty?
         end
 
-        # Renders a `Prism::ConstantReadNode` /
-        # `Prism::ConstantPathNode` chain as a `"Foo::Bar"`
-        # String. Returns nil when the node isn't a constant
-        # reference.
+        # Renders a `Prism::ConstantReadNode` / `Prism::ConstantPathNode` chain as a `"Foo::Bar"` String.
+        # Returns nil when the node isn't a constant reference.
         def constant_path_name(node)
           case node
           when Prism::ConstantReadNode

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/scope_walker.rb

@@ -6,52 +6,40 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Walks an RSpec spec file's AST and yields, for each
-      # describe / context block (including the outer
-      # `RSpec.describe`), a `Scope` value with the `let`
-      # and `subject` declarations recorded inside that
+      # Walks an RSpec spec file's AST and yields, for each describe / context block (including the outer
+      # `RSpec.describe`), a `Scope` value with the `let` and `subject` declarations recorded inside that
       # scope.
       #
-      # Scope hierarchy is preserved: each `Scope` carries
-      # a list of its `nested_scopes`. The analyzer uses the
-      # hierarchy to detect cross-scope shadowing.
+      # Scope hierarchy is preserved: each `Scope` carries a list of its `nested_scopes`. The analyzer uses
+      # the hierarchy to detect cross-scope shadowing.
       #
-      # Recognised scope methods (when called without a
-      # receiver, or with `RSpec` as the receiver):
+      # Recognised scope methods (when called without a receiver, or with `RSpec` as the receiver):
       #
-      # - `describe` / `context` — both open a new nested
-      #   scope.
+      # - `describe` / `context` — both open a new nested scope.
       # - `RSpec.describe` — the outermost scope.
       #
-      # Recognised declaration methods (inside any scope,
-      # called without a receiver):
+      # Recognised declaration methods (inside any scope, called without a receiver):
       #
-      # - `let(:name) { ... }` — caches the block result
-      #   per-example; recorded as a Declaration.
-      # - `let!(:name) { ... }` — same, but evaluated
-      #   eagerly via a `before` hook; same shape for our
+      # - `let(:name) { ... }` — caches the block result per-example; recorded as a Declaration.
+      # - `let!(:name) { ... }` — same, but evaluated eagerly via a `before` hook; same shape for our
       #   purposes.
-      # - `subject(:name) { ... }` — special-cases name
-      #   `:subject` when called without a name.
+      # - `subject(:name) { ... }` — special-cases name `:subject` when called without a name.
       module ScopeWalker
         SCOPE_METHODS = %i[describe context].freeze
         DECLARATION_METHODS = %i[let let! subject].freeze
 
         # @!attribute [r] kind
-        #   `:describe`, `:context`, or `:rspec_describe` for
-        #   the root.
+        #   `:describe`, `:context`, or `:rspec_describe` for the root.
         # @!attribute [r] declarations
         #   `Array<Declaration>` declared in this scope.
         # @!attribute [r] nested_scopes
         #   `Array<Scope>` nested under this scope.
         # @!attribute [r] location
-        #   `Prism::Location` of the call node that opened
-        #   this scope.
+        #   `Prism::Location` of the call node that opened this scope.
         Scope = Struct.new(:kind, :declarations, :nested_scopes, :location, keyword_init: true)
 
         # @!attribute [r] name
-        #   `Symbol` declared name (`:user`, `:subject`,
-        #   ...).
+        #   `Symbol` declared name (`:user`, `:subject`, ...).
         # @!attribute [r] kind
         #   `:let`, `:let!`, or `:subject`.
         # @!attribute [r] location
@@ -62,18 +50,15 @@ module Rigor
 
         module_function
 
-        # Walks the parsed file and returns an array of
-        # top-level scopes (each `RSpec.describe` is a
-        # separate root). Files with no recognised scopes
-        # return an empty array.
+        # Walks the parsed file and returns an array of top-level scopes (each `RSpec.describe` is a
+        # separate root). Files with no recognised scopes return an empty array.
         def collect_scopes(root)
           scopes = []
           walk_top_level(root, scopes)
           scopes
         end
 
-        # Walks every scope in a tree (root + descendants)
-        # and yields each in turn.
+        # Walks every scope in a tree (root + descendants) and yields each in turn.
         def each_scope(scope, &)
           yield scope
           scope.nested_scopes.each { |child| each_scope(child, &) }
@@ -89,8 +74,7 @@ module Rigor
           end
         end
 
-        # Returns true for `RSpec.describe ... do |...| ...
-        # end` calls.
+        # Returns true for `RSpec.describe ... do |...| ... end` calls.
         def rspec_describe_call?(node)
           return false unless node.is_a?(Prism::CallNode)
           return false unless node.name == :describe
@@ -100,10 +84,8 @@ module Rigor
           %w[RSpec ::RSpec].include?(receiver_name)
         end
 
-        # Returns true for `describe ... do ... end` /
-        # `context ... do ... end` (called without an
-        # explicit receiver — `RSpec.describe` is handled
-        # separately by `rspec_describe_call?`).
+        # Returns true for `describe ... do ... end` / `context ... do ... end` (called without an
+        # explicit receiver — `RSpec.describe` is handled separately by `rspec_describe_call?`).
         def nested_scope_call?(node)
           node.is_a?(Prism::CallNode) &&
             SCOPE_METHODS.include?(node.name) &&
@@ -117,9 +99,8 @@ module Rigor
             node.receiver.nil?
         end
 
-        # Constructs a Scope from a describe / context /
-        # RSpec.describe call node. Walks the block body
-        # for declarations + nested scopes.
+        # Constructs a Scope from a describe / context / RSpec.describe call node. Walks the block body for
+        # declarations + nested scopes.
         def build_scope(call_node, kind:)
           declarations = []
           nested = []
@@ -146,8 +127,7 @@ module Rigor
 
         def build_declaration(call_node)
           first_arg = call_node.arguments&.arguments&.first
-          # `subject(&block)` (no name) defaults to the
-          # implicit subject; record it as `:subject`.
+          # `subject(&block)` (no name) defaults to the implicit subject; record it as `:subject`.
           if first_arg.nil?
             return nil unless call_node.name == :subject
 

data/plugins/rigor-rspec/lib/rigor/plugin/rspec.rb

@@ -10,62 +10,41 @@ require_relative "rspec/let_type_resolver"
 
 module Rigor
   module Plugin
-    # rigor-rspec — validates RSpec `let` / `subject`
-    # declarations within each describe / context scope,
-    # narrows `expect(x).to MATCHER` assertions downstream,
-    # and binds `let`/`subject` locals to their inferred
-    # return types inside `it` bodies.
+    # rigor-rspec — validates RSpec `let` / `subject` declarations within each describe / context scope,
+    # narrows `expect(x).to MATCHER` assertions downstream, and binds `let`/`subject` locals to their
+    # inferred return types inside `it` bodies.
     #
     # Tier 3A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
     # Ships four checks:
     #
-    # 1. **Duplicate `let` / `subject` declarations** in
-    #    the same scope (`warning`). RSpec's runtime lets
-    #    the last declaration win, so the first one is
-    #    silently shadowed — almost always a copy-paste
-    #    bug.
-    # 2. **Self-referencing `let` / `subject`** — calling
-    #    the declared name *inside* its own block body
-    #    (`error`). At runtime this infinite-loops; users
-    #    typically meant to call a different method or
+    # 1. **Duplicate `let` / `subject` declarations** in the same scope (`warning`). RSpec's runtime lets
+    #    the last declaration win, so the first one is silently shadowed — almost always a copy-paste bug.
+    # 2. **Self-referencing `let` / `subject`** — calling the declared name *inside* its own block body
+    #    (`error`). At runtime this infinite-loops; users typically meant to call a different method or
     #    forgot to introduce a `super`.
-    # 3. **`expect(x).to MATCHER` narrowing** — narrows
-    #    the named local `x` on the post-call edge for
-    #    eight matchers (see `MatcherAnalyzer`).
-    # 4. **`let`/`subject` local binding** — binds `let`
-    #    / `subject` names in `it` bodies to the block's
+    # 3. **`expect(x).to MATCHER` narrowing** — narrows the named local `x` on the post-call edge for eight
+    #    matchers (see `MatcherAnalyzer`).
+    # 4. **`let`/`subject` local binding** — binds `let` / `subject` names in `it` bodies to the block's
     #    inferred return type (see `LetTypeResolver`).
     #
     # ## Configuration
     #
-    # No configuration knobs. The plugin walks every
-    # analysed file for `RSpec.describe ... do` blocks;
-    # spec files outside the project's `paths:` are not
-    # scanned.
+    # No configuration knobs. The plugin walks every analysed file for `RSpec.describe ... do` blocks; spec
+    # files outside the project's `paths:` are not scanned.
     #
     # ## Limitations
     #
-    # - **No let-typo detection.** Detecting an `it`
-    #   block's reference to a misspelled `let` name
-    #   requires resolving every method call inside the
-    #   block against the let scope chain, the included
-    #   modules, the matchers DSL, and helper methods.
-    #   Reliable diagnostics here need a much heavier
-    #   walker — see the README's `Future direction`.
-    # - **No mock-target validation.**
-    #   `expect(x).to receive(:nme)` validating against
-    #   `x`'s methods is a separate slice; it overlaps with
-    #   the engine's general method-existence
-    #   diagnostics and needs careful coordination to avoid
-    #   double-firing.
-    # - **No shared-context resolution.** `include_context`,
-    #   `shared_context`, and `it_behaves_like` are
-    #   recognised as scope-opening calls but their
-    #   declarations are not pulled into the host scope.
-    # - **Constant validation is not done here.**
-    #   `RSpec.describe SomeClass do` does not validate
-    #   `SomeClass`; the engine's `inference.unresolved-constant`
-    #   already catches that.
+    # - **No let-typo detection.** Detecting an `it` block's reference to a misspelled `let` name requires
+    #   resolving every method call inside the block against the let scope chain, the included modules,
+    #   the matchers DSL, and helper methods. Reliable diagnostics here need a much heavier walker — see
+    #   the README's `Future direction`.
+    # - **No mock-target validation.** `expect(x).to receive(:nme)` validating against `x`'s methods is a
+    #   separate slice; it overlaps with the engine's general method-existence diagnostics and needs
+    #   careful coordination to avoid double-firing.
+    # - **No shared-context resolution.** `include_context`, `shared_context`, and `it_behaves_like` are
+    #   recognised as scope-opening calls but their declarations are not pulled into the host scope.
+    # - **Constant validation is not done here.** `RSpec.describe SomeClass do` does not validate
+    #   `SomeClass`; the engine's `inference.unresolved-constant` already catches that.
     class Rspec < Rigor::Plugin::Base
       manifest(
         id: "rspec",
@@ -79,10 +58,9 @@ module Rigor
           { plugin_id: "factorybot", name: :factory_index, optional: true }
         ],
         additional_initializers: [
-          # ADR-38 block-form: `before { @ivar = … }`, `let(:x) { @ivar = … }`,
-          # and `subject { @ivar = … }` establish ivar state before `it` bodies
-          # run. Declaring them here suppresses the read-before-write nil
-          # widening that would otherwise appear on those ivars in `it` / `specify`
+          # ADR-38 block-form: `before { @ivar = … }`, `let(:x) { @ivar = … }`, and `subject { @ivar = … }`
+          # establish ivar state before `it` bodies run. Declaring them here suppresses the
+          # read-before-write nil widening that would otherwise appear on those ivars in `it` / `specify`
           # sibling blocks.
           Rigor::Plugin::AdditionalInitializer.new(
             receiver_constraint: "RSpec::ExampleGroup",
@@ -92,53 +70,44 @@ module Rigor
       )
 
       def init(_services)
-        # Per-path `LetScopeIndex` cache. The let-binding
-        # `dynamic_return` rule (and its `file_methods:` gate)
-        # consult the index per call node; building it once
-        # per file is essential for performance.
+        # Per-path `LetScopeIndex` cache. The let-binding `dynamic_return` rule (and its `file_methods:`
+        # gate) consult the index per call node; building it once per file is essential for performance.
         @let_index_cache = {}
       end
 
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        # Build the let-scope index for this file while we
-        # have the parsed root in hand — the let-binding rule
-        # picks it up from `@let_index_cache` keyed on path.
+        # Build the let-scope index for this file while we have the parsed root in hand — the let-binding
+        # rule picks it up from `@let_index_cache` keyed on path.
         @let_index_cache[path] ||= LetScopeIndex.build(root)
         Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
       end
 
-      # ADR-37 slice 2 — matcher narrowing
-      # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
+      # ADR-37 slice 2 — matcher narrowing (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
       narrowing_facts methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 
-      # ADR-52 slice 5a — binds local reads in `it` /
-      # spec bodies to their `let(:name) { ... }` block's inferred return
-      # type. The name set varies per file (each spec file's
-      # `describe`/`let` structure), so the rule gates on the per-file
-      # `file_methods:` form: the engine resolves the file's let names
-      # once per analysed file and consults the block only for a listed
-      # name; the line-scoped shadowing resolution stays in the block.
+      # ADR-52 slice 5a — binds local reads in `it` / spec bodies to their `let(:name) { ... }` block's
+      # inferred return type. The name set varies per file (each spec file's `describe`/`let` structure),
+      # so the rule gates on the per-file `file_methods:` form: the engine resolves the file's let names
+      # once per analysed file and consults the block only for a listed name; the line-scoped shadowing
+      # resolution stays in the block.
       dynamic_return file_methods: ->(path) { let_names_for(path) } do |call_node, scope|
         let_binding_return_type(call_node, scope)
       end
 
       private
 
-      # The `file_methods:` gate set — every `let` / `subject` name the
-      # file declares anywhere. A safe over-approximation of the block's
-      # own `let_block_at` line-scoped lookup (a name read outside its
+      # The `file_methods:` gate set — every `let` / `subject` name the file declares anywhere. A safe
+      # over-approximation of the block's own `let_block_at` line-scoped lookup (a name read outside its
       # describe scope passes the gate and is declined by the block).
       def let_names_for(path)
         let_scope_index_for(path)&.let_names || []
       end
 
-      # When the call node is a no-receiver
-      # method call (`user`, `subject`, etc.) inside an RSpec
-      # `describe` block whose lets include a matching name,
-      # return the let block's inferred type.
+      # When the call node is a no-receiver method call (`user`, `subject`, etc.) inside an RSpec
+      # `describe` block whose lets include a matching name, return the let block's inferred type.
       def let_binding_return_type(call_node, scope)
         return nil if scope.nil?
         return nil unless candidate_call?(call_node)
@@ -163,10 +132,9 @@ module Rigor
         call_node.is_a?(Prism::CallNode) &&
           call_node.receiver.nil? &&
           call_node.block.nil? &&
-          # Calls with arguments are matcher / DSL invocations,
-          # not let-bound name reads. `subject` / `user` etc.
-          # without args are the implicit-method-call shape RSpec
-          # uses to expose let / subject in `it` bodies.
+          # Calls with arguments are matcher / DSL invocations, not let-bound name reads. `subject` /
+          # `user` etc. without args are the implicit-method-call shape RSpec uses to expose let / subject
+          # in `it` bodies.
           (call_node.arguments.nil? || call_node.arguments.arguments.empty?)
       end
 

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/have_http_status_analyzer.rb

@@ -7,48 +7,39 @@ require_relative "http_status_codes"
 module Rigor
   module Plugin
     class RspecRails < Rigor::Plugin::Base
-      # Validates `expect(response).to have_http_status(arg)` /
-      # the negated `.not_to have_http_status(arg)` and the
-      # bare matcher form `should have_http_status(arg)`.
+      # Validates `expect(response).to have_http_status(arg)` / the negated `.not_to have_http_status(arg)`
+      # and the bare matcher form `should have_http_status(arg)`.
       #
       # Recognised argument shapes:
       #
-      # - **IntegerNode**: must be in `100..599`. Numbers outside
-      #   that range fire `have_http_status.out-of-range`.
-      # - **SymbolNode**: must be one of the known
-      #   `Rack::Utils::SYMBOL_TO_STATUS_CODE` keys OR a Rails
-      #   status-group alias (`:success` / `:successful` /
-      #   `:missing` / `:redirect` / `:error` / `:client_error` /
-      #   `:server_error` / `:informational`). Unknown symbols
-      #   fire `have_http_status.unknown-symbol` (typo-flavoured).
-      # - **StringNode**: passed through silently (a literal
-      #   `"200"` is accepted by Rails at runtime; we don't
-      #   second-guess the user's intent for the String form).
-      # - **Anything else** (variable, method call, computed
-      #   expression): skipped — the plugin can't statically
-      #   prove the runtime value.
+      # - **IntegerNode**: must be in `100..599`. Numbers outside that range fire
+      #   `have_http_status.out-of-range`.
+      # - **SymbolNode**: must be one of the known `Rack::Utils::SYMBOL_TO_STATUS_CODE` keys OR a Rails
+      #   status-group alias (`:success` / `:successful` / `:missing` / `:redirect` / `:error` /
+      #   `:client_error` / `:server_error` / `:informational`). Unknown symbols fire
+      #   `have_http_status.unknown-symbol` (typo-flavoured).
+      # - **StringNode**: passed through silently (a literal `"200"` is accepted by Rails at runtime; we
+      #   don't second-guess the user's intent for the String form).
+      # - **Anything else** (variable, method call, computed expression): skipped — the plugin can't
+      #   statically prove the runtime value.
       #
-      # Walks every `Prism::CallNode` looking for matcher
-      # invocations rather than only the `expect(...).to ...`
-      # chain because `have_http_status` is also used as a
-      # plain matcher inside Rails' `assert_response` shim and
-      # in shared-context bodies; the diagnostic is the same
-      # regardless of the surrounding chain.
+      # Walks every `Prism::CallNode` looking for matcher invocations rather than only the
+      # `expect(...).to ...` chain because `have_http_status` is also used as a plain matcher inside Rails'
+      # `assert_response` shim and in shared-context bodies; the diagnostic is the same regardless of the
+      # surrounding chain.
       module HaveHttpStatusAnalyzer
-        # One matcher violation: the kebab-case `rule` and the
-        # human-readable `message`. Carries no location/path — the
-        # caller (the `node_rule` block) positions the diagnostic at the
-        # matcher's `message_loc` via `Plugin::Base#diagnostic`.
+        # One matcher violation: the kebab-case `rule` and the human-readable `message`. Carries no
+        # location/path — the caller (the `node_rule` block) positions the diagnostic at the matcher's
+        # `message_loc` via `Plugin::Base#diagnostic`.
         Violation = Struct.new(:rule, :message, keyword_init: true)
 
         MATCHER_NAME = :have_http_status
 
         module_function
 
-        # The matcher violation for a single CallNode, or nil when the
-        # node is not a `have_http_status(<int|symbol>)` matcher or its
-        # argument is statically valid. ADR-37: the engine owns the
-        # walk, so this is per-node logic — no traversal here.
+        # The matcher violation for a single CallNode, or nil when the node is not a
+        # `have_http_status(<int|symbol>)` matcher or its argument is statically valid. ADR-37: the engine
+        # owns the walk, so this is per-node logic — no traversal here.
         #
         # @param call_node [Prism::Node]
         # @return [Violation, nil]
@@ -58,12 +49,9 @@ module Rigor
           diagnostic_for(call_node)
         end
 
-        # `have_http_status` is a matcher — called either with
-        # no receiver (`have_http_status(200)` inside `.to(...)`)
-        # or with a receiver chain we don't care about here.
-        # Either way we want the call node whose name is
-        # `have_http_status` and that carries exactly one
-        # positional argument.
+        # `have_http_status` is a matcher — called either with no receiver (`have_http_status(200)` inside
+        # `.to(...)`) or with a receiver chain we don't care about here. Either way we want the call node
+        # whose name is `have_http_status` and that carries exactly one positional argument.
         def call_to_matcher?(node)
           node.is_a?(Prism::CallNode) &&
             node.name == MATCHER_NAME &&
@@ -97,8 +85,8 @@ module Rigor
         def symbol_violation(symbol_node)
           sym = symbol_node.unescaped.to_sym
           known = HttpStatusCodes.known_symbols
-          # ADR-39: Rack unavailable → the accepted symbol set is
-          # unknowable, so decline rather than flag from a guess.
+          # ADR-39: Rack unavailable → the accepted symbol set is unknowable, so decline rather than flag
+          # from a guess.
           return nil if known.nil?
           return nil if known.include?(sym)