rigortype 0.2.7 → 0.2.8

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

@@ -8,17 +8,13 @@ require_relative "factorybot/factory_index"
 
 module Rigor
   module Plugin
-    # rigor-factorybot — validates `FactoryBot.create(:name,
-    # key: ...)` and the build / build_stubbed /
-    # attributes_for / *_list family against a per-run index
-    # built from `factory_search_paths`.
+    # rigor-factorybot — validates `FactoryBot.create(:name, key: ...)` and the build / build_stubbed /
+    # attributes_for / *_list family against a per-run index built from `factory_search_paths`.
     #
-    # Recognises factory NAMES + literal ATTRIBUTE KEYS in
-    # the call's keyword hash. The AR column cross-check uses
-    # the `rigor-activerecord` `:model_index` ADR-9 fact when
-    # that plugin is loaded (optional `consumes:`).
-    # Traits, sequences, parent / child factories, and dynamic
-    # factory names are deferred to follow-up slices.
+    # Recognises factory NAMES + literal ATTRIBUTE KEYS in the call's keyword hash. The AR column
+    # cross-check uses the `rigor-activerecord` `:model_index` ADR-9 fact when that plugin is loaded
+    # (optional `consumes:`). Traits, sequences, parent / child factories, and dynamic factory names are
+    # deferred to follow-up slices.
     #
     # ## Configuration
     #
@@ -33,43 +29,32 @@ module Rigor
     #
     # ## What it checks
     #
-    # - **Factory existence** — every entry call's first
-    #   positional Symbol / String literal is looked up in
-    #   the index. Missing factories emit `unknown-factory`
-    #   with a `DidYouMean` suggestion.
-    # - **Attribute key existence** — every literal-Symbol
-    #   keyword-argument key is matched against the factory's
-    #   declared attribute names. Missing keys emit
-    #   `unknown-attribute` with a `DidYouMean` suggestion.
-    # - **Trace** — recognised entry calls also emit a
-    #   `factory-call` info diagnostic listing the factory's
-    #   declared attribute set.
+    # - **Factory existence** — every entry call's first positional Symbol / String literal is looked up
+    #   in the index. Missing factories emit `unknown-factory` with a `DidYouMean` suggestion.
+    # - **Attribute key existence** — every literal-Symbol keyword-argument key is matched against the
+    #   factory's declared attribute names. Missing keys emit `unknown-attribute` with a `DidYouMean`
+    #   suggestion.
+    # - **Trace** — recognised entry calls also emit a `factory-call` info diagnostic listing the
+    #   factory's declared attribute set.
     #
     # ## Recognised entry methods
     #
-    # `FactoryBot.create`, `.build`, `.build_stubbed`,
-    # `.attributes_for`, `.create_list`, `.build_list`,
-    # `.build_stubbed_list`. The legacy `FactoryGirl` constant
-    # is recognised identically. Implicit-receiver calls
-    # (`create(:name)` inside an `include FactoryBot::Syntax::Methods`
-    # context) are NOT recognised — too many false positives on
-    # plain `create` calls outside test files; deferred until
-    # receiver-type inference can disambiguate.
+    # `FactoryBot.create`, `.build`, `.build_stubbed`, `.attributes_for`, `.create_list`, `.build_list`,
+    # `.build_stubbed_list`. The legacy `FactoryGirl` constant is recognised identically. Implicit-receiver
+    # calls (`create(:name)` inside an `include FactoryBot::Syntax::Methods` context) are NOT recognised —
+    # too many false positives on plain `create` calls outside test files; deferred until receiver-type
+    # inference can disambiguate.
     #
     # ## What's recognised inside `factory :name do ... end`
     #
-    # - `name { "Alice" }` — implicit attribute via
-    #   `method_missing` with a block (modern syntax).
-    # - `name "Alice"` — implicit attribute with a positional
-    #   argument (legacy syntax).
+    # - `name { "Alice" }` — implicit attribute via `method_missing` with a block (modern syntax).
+    # - `name "Alice"` — implicit attribute with a positional argument (legacy syntax).
     # - `add_attribute(:name) { "Alice" }` — explicit form.
     #
-    # Sequences (`sequence(:email) { ... }`), associations
-    # (`association :author`), traits (`trait :admin do ... end`),
-    # and parent / child relationships (`factory :admin,
-    # parent: :user do ... end`) are deferred to follow-up
-    # slices. Factories whose name is a non-literal expression
-    # (`factory FACTORY_NAME do ... end`) are silently skipped.
+    # Sequences (`sequence(:email) { ... }`), associations (`association :author`), traits (`trait :admin
+    # do ... end`), and parent / child relationships (`factory :admin, parent: :user do ... end`) are
+    # deferred to follow-up slices. Factories whose name is a non-literal expression (`factory
+    # FACTORY_NAME do ... end`) are silently skipped.
     class Factorybot < Rigor::Plugin::Base
       manifest(
         id: "factorybot",
@@ -96,18 +81,16 @@ module Rigor
         @factory_search_paths = Array(config.fetch("factory_search_paths")).map(&:to_s)
       end
 
-      # ADR-37 — per-call factory/attribute validation over the
-      # engine-owned walk. Each violation carries its own location
-      # (the call's message_loc, or the offending attribute key), so it
-      # is positioned via `diagnostic(node, location:)`. No file-level
-      # diagnostic remains, so there is no `diagnostics_for_file`.
+      # ADR-37 — per-call factory/attribute validation over the engine-owned walk. Each violation carries
+      # its own location (the call's message_loc, or the offending attribute key), so it is positioned
+      # via `diagnostic(node, location:)`. No file-level diagnostic remains, so there is no
+      # `diagnostics_for_file`.
       node_rule Prism::CallNode do |node, _scope, path|
         index = producer_value(:factory_index)
         next [] if index.nil? || index.empty?
 
-        # `:model_index` is rigor-activerecord's published fact (ADR-9);
-        # nil when that plugin isn't loaded, in which case the analyzer
-        # falls back to factory-attributes-only checking.
+        # `:model_index` is rigor-activerecord's published fact (ADR-9); nil when that plugin isn't
+        # loaded, in which case the analyzer falls back to factory-attributes-only checking.
         violations = Analyzer.violations_for(
           call_node: node, factory_index: index,
           model_index: read_fact(plugin_id: "activerecord", name: :model_index)

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -6,17 +6,13 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class Graphql < Rigor::Plugin::Base
-      # Walks project source for `class T < GraphQL::Schema::Object`
-      # subclasses and emits a `{type_class_fqn => {field_name => {type:, nullable:}}}`
-      # table covering every `field :name, Type, null: ...` declaration
-      # inside the class body.
+      # Walks project source for `class T < GraphQL::Schema::Object` subclasses and emits a
+      # `{type_class_fqn => {field_name => {type:, nullable:}}}` table covering every `field :name, Type,
+      # null: ...` declaration inside the class body.
       module TypeScanner
-        # The canonical GraphQL scalar type names accepted as
-        # `field`'s second positional argument. The plugin maps
-        # each to the underlying Ruby class name so downstream
-        # consumers can cross-reference against Ruby types
-        # without re-implementing the GraphQL→Ruby coercion
-        # table.
+        # The canonical GraphQL scalar type names accepted as `field`'s second positional argument. The
+        # plugin maps each to the underlying Ruby class name so downstream consumers can cross-reference
+        # against Ruby types without re-implementing the GraphQL→Ruby coercion table.
         CANONICAL_TYPES = {
           "String" => "String",
           "Integer" => "Integer",
@@ -26,21 +22,17 @@ module Rigor
           "ID" => "String"
         }.freeze
 
-        # The base class name a Schema::Object subclass MUST
-        # inherit from to be recognised. Match is on the
-        # rightmost segment of the superclass constant chain so
-        # both `GraphQL::Schema::Object` and the locally-aliased
-        # `BaseObject = GraphQL::Schema::Object` shape work when
-        # the alias's RHS is the canonical path.
+        # The base class name a Schema::Object subclass MUST inherit from to be recognised. Match is on
+        # the rightmost segment of the superclass constant chain so both `GraphQL::Schema::Object` and
+        # the locally-aliased `BaseObject = GraphQL::Schema::Object` shape work when the alias's RHS is
+        # the canonical path.
         SCHEMA_OBJECT_TAIL = "Object"
         SCHEMA_ENUM_TAIL = "Enum"
         SCHEMA_INPUT_OBJECT_TAIL = "InputObject"
         SCHEMA_MUTATION_TAIL = "Mutation"
-        # Common path-segment for `Schema::Object` / `Schema::Enum`
-        # / `Schema::InputObject` / `Schema::Mutation`; the
-        # second-to-last segment must be `Schema` (either
-        # fully-qualified `GraphQL::Schema::X` or lexically nested
-        # `Schema::X` inside `module GraphQL`).
+        # Common path-segment for `Schema::Object` / `Schema::Enum` / `Schema::InputObject` /
+        # `Schema::Mutation`; the second-to-last segment must be `Schema` (either fully-qualified
+        # `GraphQL::Schema::X` or lexically nested `Schema::X` inside `module GraphQL`).
         SCHEMA_PARENT_SEGMENTS = %w[Schema GraphQL].freeze
         private_constant :SCHEMA_OBJECT_TAIL, :SCHEMA_ENUM_TAIL,
                          :SCHEMA_INPUT_OBJECT_TAIL, :SCHEMA_MUTATION_TAIL,
@@ -48,15 +40,12 @@ module Rigor
 
         module_function
 
-        # @param paths [Array<String>] absolute paths to `.rb` files
-        #   the project's `paths:` resolves to.
-        # @return [Hash{Symbol => Hash}] frozen 4-key result:
-        #   `:types` (per-`Schema::Object` field table),
-        #   `:enums` (per-`Schema::Enum` value list),
-        #   `:input_objects` (per-`Schema::InputObject` argument table),
-        #   `:mutations` (per-`Schema::Mutation` arguments+fields table).
-        #   Any subset may be empty when no recognisable declaration
-        #   of that kind is found.
+        # @param paths [Array<String>] absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @return [Hash{Symbol => Hash}] frozen 4-key result: `:types` (per-`Schema::Object` field
+        #   table), `:enums` (per-`Schema::Enum` value list), `:input_objects`
+        #   (per-`Schema::InputObject` argument table), `:mutations` (per-`Schema::Mutation`
+        #   arguments+fields table). Any subset may be empty when no recognisable declaration of that
+        #   kind is found.
         def scan(paths:)
           acc = empty_accumulator
           paths.each do |path|
@@ -97,10 +86,9 @@ module Rigor
         end
         private_class_method :scan_file
 
-        # Walks the AST collecting `class X < GraphQL::Schema::Object`,
-        # `Schema::Enum`, `Schema::InputObject`, and `Schema::Mutation`
-        # decls at any nesting level. Returns a 4-key hash so the
-        # caller can publish multiple cross-plugin facts from one walk.
+        # Walks the AST collecting `class X < GraphQL::Schema::Object`, `Schema::Enum`,
+        # `Schema::InputObject`, and `Schema::Mutation` decls at any nesting level. Returns a 4-key hash
+        # so the caller can publish multiple cross-plugin facts from one walk.
         def collect_definitions(node, qualified_prefix)
           return empty_accumulator if node.nil?
 
@@ -154,10 +142,9 @@ module Rigor
         end
         private_class_method :collect_module_node
 
-        # `class X < GraphQL::Schema::<Tail>` matches when the
-        # superclass's last two path segments are `Schema::<Tail>`.
-        # Matches both `< GraphQL::Schema::<Tail>` (fully qualified)
-        # and `< Schema::<Tail>` (lexically inside `module GraphQL`).
+        # `class X < GraphQL::Schema::<Tail>` matches when the superclass's last two path segments are
+        # `Schema::<Tail>`. Matches both `< GraphQL::Schema::<Tail>` (fully qualified) and `<
+        # Schema::<Tail>` (lexically inside `module GraphQL`).
         def schema_subclass?(class_node, tail)
           superclass = class_node.superclass
           return false if superclass.nil?
@@ -193,19 +180,16 @@ module Rigor
         end
         private_class_method :statement_nodes
 
-        # Walks every top-level `value "..."` call inside an
-        # enum subclass body and returns the value names as an
-        # Array<String>. Both shapes graphql-ruby accepts work:
+        # Walks every top-level `value "..."` call inside an enum subclass body and returns the value
+        # names as an Array<String>. Both shapes graphql-ruby accepts work:
         #
         #     value "ACTIVE"
         #     value "DISABLED", value: :off, description: "..."
         #
-        # The first positional must be a String literal — the
-        # graphql-ruby `value` API also accepts a Symbol form
-        # (`value :ACTIVE`) but the documented idiom is String.
-        # Only the GraphQL-side value name is stored; the optional
-        # `value:` kwarg (Ruby-side override) and `description:`
-        # are omitted from the published table.
+        # The first positional must be a String literal — the graphql-ruby `value` API also accepts a
+        # Symbol form (`value :ACTIVE`) but the documented idiom is String. Only the GraphQL-side value
+        # name is stored; the optional `value:` kwarg (Ruby-side override) and `description:` are
+        # omitted from the published table.
         def collect_values(body)
           return [] if body.nil?
 
@@ -220,13 +204,10 @@ module Rigor
         end
         private_class_method :collect_values
 
-        # Walks every top-level `argument :name, Type, required: ...`
-        # call inside an InputObject (or Mutation) subclass body and
-        # returns the per-argument shape table. Argument syntax
-        # mirrors `field` except the nullability axis is named
-        # `required:` (default `false` — per graphql-ruby's
-        # `argument` default; the OPPOSITE polarity of `field`'s
-        # `null:`).
+        # Walks every top-level `argument :name, Type, required: ...` call inside an InputObject (or
+        # Mutation) subclass body and returns the per-argument shape table. Argument syntax mirrors
+        # `field` except the nullability axis is named `required:` (default `false` — per graphql-ruby's
+        # `argument` default; the OPPOSITE polarity of `field`'s `null:`).
         #
         #     argument :name, String, required: true
         #     argument :tags, [String], required: false
@@ -270,10 +251,9 @@ module Rigor
         end
         private_class_method :parse_argument_call
 
-        # Mirror of `extract_nullability` but reads the `required:`
-        # kwarg, defaulting to `false` (graphql-ruby's argument
-        # default — the OPPOSITE polarity of `field`'s `null:` /
-        # nullability default).
+        # Mirror of `extract_nullability` but reads the `required:` kwarg, defaulting to `false`
+        # (graphql-ruby's argument default — the OPPOSITE polarity of `field`'s `null:` / nullability
+        # default).
         # rubocop:disable Naming/PredicateMethod  -- extractor returns the literal required value
         def extract_required_flag(args)
           kwargs = args.last
@@ -293,12 +273,10 @@ module Rigor
         # rubocop:enable Naming/PredicateMethod
         private_class_method :extract_required_flag
 
-        # `field :name, Type, null: false` shape. The first
-        # positional is a Symbol (field name); the second is a
-        # constant reference (GraphQL type) OR a single-element
-        # ArrayNode (`[Type]`) for GraphQL list types; `null:` is
-        # the nullability keyword (defaults to TRUE per
-        # graphql-ruby's field defaults so we mirror that).
+        # `field :name, Type, null: false` shape. The first positional is a Symbol (field name); the
+        # second is a constant reference (GraphQL type) OR a single-element ArrayNode (`[Type]`) for
+        # GraphQL list types; `null:` is the nullability keyword (defaults to TRUE per graphql-ruby's
+        # field defaults so we mirror that).
         def parse_field_call(node)
           args = node.arguments&.arguments
           return nil if args.nil? || args.size < 2
@@ -320,13 +298,10 @@ module Rigor
         end
         private_class_method :parse_field_call
 
-        # Resolves the `Type` positional argument to a
-        # `{type: "ClassName", list: bool}` tuple. ArrayNode
-        # forms (`[String]` / `[Types::User]`) unwrap the single
-        # element and mark `list: true`. Bare constant refs are
-        # not lists. Returns nil for unrecognised shapes (string
-        # types `"User"`, Proc lazy types, etc.) so callers drop
-        # the field.
+        # Resolves the `Type` positional argument to a `{type: "ClassName", list: bool}` tuple.
+        # ArrayNode forms (`[String]` / `[Types::User]`) unwrap the single element and mark `list: true`.
+        # Bare constant refs are not lists. Returns nil for unrecognised shapes (string types `"User"`,
+        # Proc lazy types, etc.) so callers drop the field.
         def resolve_field_type(node)
           if node.is_a?(Prism::ArrayNode)
             element = node.elements.first
@@ -354,9 +329,8 @@ module Rigor
         end
         private_class_method :resolve_constant_type
 
-        # Defaults to `true` (matches graphql-ruby's `field`
-        # default nullability). Looks for an explicit `null:`
-        # keyword and reads its boolean literal.
+        # Defaults to `true` (matches graphql-ruby's `field` default nullability). Looks for an explicit
+        # `null:` keyword and reads its boolean literal.
         # rubocop:disable Naming/PredicateMethod  -- extractor returns the literal nullability value
         def extract_nullability(args)
           kwargs = args.last
@@ -376,9 +350,8 @@ module Rigor
         # rubocop:enable Naming/PredicateMethod
         private_class_method :extract_nullability
 
-        # Returns the constant chain as an Array of String
-        # segments (`["GraphQL", "Schema", "Object"]`). Empty
-        # array for unrecognised node kinds.
+        # Returns the constant chain as an Array of String segments (`["GraphQL", "Schema", "Object"]`).
+        # Empty array for unrecognised node kinds.
         def constant_path_segments(node)
           case node
           when Prism::ConstantReadNode then [node.name.to_s]
@@ -397,9 +370,8 @@ module Rigor
         end
         private_class_method :constant_path_segments
 
-        # Joined `::`-form of {.constant_path_segments}. Returns
-        # nil for unrecognised node kinds (so callers can short-
-        # circuit).
+        # Joined `::`-form of {.constant_path_segments}. Returns nil for unrecognised node kinds (so
+        # callers can short-circuit).
         def constant_name_for(node)
           segments = constant_path_segments(node)
           segments.empty? ? nil : segments.join("::")

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

@@ -12,51 +12,41 @@ module Rigor
     # [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md)
     # § "3D".
     #
-    # Recognises `class T < GraphQL::Schema::Object` subclasses
-    # and walks every `field :name, Type, null: false` declaration
-    # inside, publishing the resulting field-type map as the
-    # `:graphql_type_table` cross-plugin fact (ADR-9). The macro
-    # expansion library survey at
-    # [docs/notes/20260515-macro-expansion-library-survey.md](../../../../../docs/notes/20260515-macro-expansion-library-survey.md)
-    # § "GraphQL-Ruby" documents WHY this is a pure metadata-recorder
-    # plugin rather than an ADR-16 substrate consumer: graphql-ruby's
-    # `field` DSL emits NO Ruby methods (it just records a
-    # `Schema::Field` on the class's `own_fields`). The user writes
-    # resolver methods themselves; rigor's value here is producing a
-    # static type table downstream consumers can cross-reference.
+    # Recognises `class T < GraphQL::Schema::Object` subclasses and walks every `field :name, Type,
+    # null: false` declaration inside, publishing the resulting field-type map as the
+    # `:graphql_type_table` cross-plugin fact (ADR-9). The macro expansion library survey at
+    # docs/notes/20260515-macro-expansion-library-survey.md § "GraphQL-Ruby" documents WHY this is a
+    # pure metadata-recorder plugin rather than an ADR-16
+    # substrate consumer: graphql-ruby's `field` DSL emits NO Ruby methods (it just records a
+    # `Schema::Field` on the class's `own_fields`). The user writes resolver methods themselves; rigor's
+    # value here is producing a static type table downstream consumers can cross-reference.
     #
     # ## What downstream consumers DO with the published facts
     #
-    # The tables are the substrate for two future capabilities
-    # (demand-driven, not yet implemented):
+    # The tables are the substrate for two future capabilities (demand-driven, not yet implemented):
     #
-    # - Resolver-method check: for each `field :name, Type` whose
-    #   `name` is also defined as a Ruby method on the class, verify
-    #   the method's return type matches `Type`'s underlying class.
-    # - Schema-query result typing: a future `rigor-graphql-execute`
-    #   plugin could type `Schema.execute(query).to_h` against the
-    #   queried fields.
+    # - Resolver-method check: for each `field :name, Type` whose `name` is also defined as a Ruby method
+    #   on the class, verify the method's return type matches `Type`'s underlying class.
+    # - Schema-query result typing: a future `rigor-graphql-execute` plugin could type
+    #   `Schema.execute(query).to_h` against the queried fields.
     #
     # ## What's recognised
     #
-    # - `class T < GraphQL::Schema::Object` subclasses (including
-    #   nested namespaces); `field :name, Type, null: ...`
-    #   declarations with constant-reference or list-array types
-    #   and GraphQL→Ruby scalar mapping.
+    # - `class T < GraphQL::Schema::Object` subclasses (including nested namespaces); `field :name, Type,
+    #   null: ...` declarations with constant-reference or list-array types and GraphQL→Ruby scalar
+    #   mapping.
     # - `class T < GraphQL::Schema::Enum`; `value "ACTIVE"` calls.
-    # - `class T < GraphQL::Schema::InputObject` /
-    #   `GraphQL::Schema::Mutation`; `argument :name, Type,
+    # - `class T < GraphQL::Schema::InputObject` / `GraphQL::Schema::Mutation`; `argument :name, Type,
     #   required: ...` declarations.
     # - No user-facing diagnostics yet.
     #
     # ## Deferred (demand-driven)
     #
     # - **`resolver:` / `mutation:` reroute** recognition.
-    # - **String type expressions** (`field :foo, "User"`) — defeats
-    #   static resolution by design (graphql-ruby's `BuildType.parse_type`
-    #   constantizes at runtime); a future slice could surface these
-    #   as `graphql.string-type` `:info` diagnostics pointing the
-    #   user at the constant-reference form for static typing.
+    # - **String type expressions** (`field :foo, "User"`) — defeats static resolution by design
+    #   (graphql-ruby's `BuildType.parse_type` constantizes at runtime); a future slice could surface
+    #   these as `graphql.string-type` `:info` diagnostics pointing the user at the constant-reference
+    #   form for static typing.
     class Graphql < Rigor::Plugin::Base
       manifest(
         id: "graphql",

data/plugins/rigor-graphql/lib/rigor-graphql.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# Gem entry point. Required by Rigor's plugin loader when
-# `.rigor.yml` lists `rigor-graphql` under `plugins:`. The
-# loader expects this `require` to side-effect a call to
-# `Rigor::Plugin.register`, which the body of
-# `lib/rigor/plugin/graphql.rb` performs at load time.
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-graphql` under
+# `plugins:`. The loader expects this `require` to side-effect a call to `Rigor::Plugin.register`,
+# which the body of `lib/rigor/plugin/graphql.rb` performs at load time.
 require_relative "rigor/plugin/graphql"

data/plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb

@@ -5,16 +5,12 @@ require "prism"
 module Rigor
   module Plugin
     class Hanami < Rigor::Plugin::Base
-      # Checks the "presence" half of the Hanami::Action
-      # ADR-28 protocol contract.
+      # Checks the "presence" half of the Hanami::Action ADR-28 protocol contract.
       #
-      # Every class defined in a file matching a contract's
-      # `path_glob` must declare `#handle(request, response)`.
-      # The "provide" half — binding `Hanami::Action::Request`
-      # and `Hanami::Action::Response` into the method body —
-      # is handled engine-side by
-      # `Inference::MethodParameterBinder`. Return type is
-      # void so no conformance check is performed here.
+      # Every class defined in a file matching a contract's `path_glob` must declare `#handle(request,
+      # response)`. The "provide" half — binding `Hanami::Action::Request` and `Hanami::Action::Response`
+      # into the method body — is handled engine-side by `Inference::MethodParameterBinder`. Return type
+      # is void so no conformance check is performed here.
       class ActionChecker
         FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB
 
@@ -22,11 +18,10 @@ module Rigor
           @contracts = contracts
         end
 
-        # Per-`ClassNode` check over the engine-owned walk (ADR-37):
-        # called once per class node the `node_rule` in `hanami.rb`
-        # dispatches, against every contract whose `path_glob` matches
-        # the file. No cross-class-node state is needed, so the checker
-        # ships no `class_nodes` traversal of its own.
+        # Per-`ClassNode` check over the engine-owned walk (ADR-37): called once per class node the
+        # `node_rule` in `hanami.rb` dispatches, against every contract whose `path_glob` matches the
+        # file. No cross-class-node state is needed, so the checker ships no `class_nodes` traversal of
+        # its own.
         def check_class(class_node, path:)
           @contracts.filter_map do |contract|
             next unless path_matches?(contract.path_glob, path)
@@ -42,9 +37,8 @@ module Rigor
 
         private
 
-        # Contract globs are project-root-relative; the analyzer
-        # may supply a relative or absolute path, so the glob is
-        # matched both directly and with a `**/`-prefixed suffix.
+        # Contract globs are project-root-relative; the analyzer may supply a relative or absolute path,
+        # so the glob is matched both directly and with a `**/`-prefixed suffix.
         def path_matches?(glob, path)
           return false if path.nil?
 

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

@@ -9,37 +9,28 @@ module Rigor
   module Plugin
     # rigor-hanami — enforces the Hanami::Action protocol.
     #
-    # Hanami 3.x actions inherit from `Hanami::Action` and
-    # define a single entry-point:
+    # Hanami 3.x actions inherit from `Hanami::Action` and define a single entry-point:
     #
     #   def handle(request, response)
     #     response.status = 200
     #     response.body = "Hello"
     #   end
     #
-    # The method is void — the response is mutated in-place;
-    # the return value is discarded by the framework.
+    # The method is void — the response is mutated in-place; the return value is discarded by the
+    # framework.
     #
-    # This plugin uses the **ADR-28 path-scoped
-    # method-protocol contract** to:
+    # This plugin uses the **ADR-28 path-scoped method-protocol contract** to:
     #
-    # 1. **Provide** `Hanami::Action::Request` and
-    #    `Hanami::Action::Response` as the types of the
-    #    first and second parameters of every `#handle`
-    #    method defined inside `app/actions/**/*.rb`.
-    #    The engine substitutes these types for the usual
-    #    `Dynamic[Top]` fallback, so misuse of `request` or
-    #    `response` inside an action body surfaces as a
-    #    core diagnostic.
+    # 1. **Provide** `Hanami::Action::Request` and `Hanami::Action::Response` as the types of the first
+    #    and second parameters of every `#handle` method defined inside `app/actions/**/*.rb`. The
+    #    engine substitutes these types for the usual `Dynamic[Top]` fallback, so misuse of `request` or
+    #    `response` inside an action body surfaces as a core diagnostic.
     #
-    # 2. **Check** that every class under `app/actions/`
-    #    defines `#handle`. Missing definitions emit
+    # 2. **Check** that every class under `app/actions/` defines `#handle`. Missing definitions emit
     #    `missing-handle-method`.
     #
-    # Return-type conformance is NOT checked — Hanami
-    # actions are void by contract, and checking a void
-    # return would produce false positives on every `if`
-    # branch that doesn't end with an explicit `nil`.
+    # Return-type conformance is NOT checked — Hanami actions are void by contract, and checking a void
+    # return would produce false positives on every `if` branch that doesn't end with an explicit `nil`.
     #
     # ## Configuration
     #
@@ -55,10 +46,8 @@ module Rigor
     # | action class defines no `#handle`        | `:error` | `missing-handle-method` |
     # | `request` / `response` misuse in body    | core engine diagnostic  |
     #
-    # A misused `request` or `response` (e.g.
-    # `request.no_such_method`) surfaces as a standard
-    # engine `call.undefined-method` diagnostic once the
-    # plugin provides the parameter types.
+    # A misused `request` or `response` (e.g. `request.no_such_method`) surfaces as a standard engine
+    # `call.undefined-method` diagnostic once the plugin provides the parameter types.
     class Hanami < Rigor::Plugin::Base
       manifest(
         id: "hanami",
@@ -91,20 +80,17 @@ module Rigor
           end
       end
 
-      # ADR-28: override so the per-project `action_path` config
-      # reaches both the engine's parameter-provision tier and
-      # this plugin's check half.
+      # ADR-28: override so the per-project `action_path` config reaches both the engine's
+      # parameter-provision tier and this plugin's check half.
       def protocol_contracts
         @protocol_contracts || manifest.protocol_contracts
       end
 
-      # ADR-37 — per-class-node validation over the engine-owned walk.
-      # Each `Prism::ClassNode` is checked against every contract
-      # independently, so the plugin no longer ships its own `class_nodes`
-      # traversal; `ActionChecker#check_class` keeps the per-class
-      # contract logic. (A per-class contract check is exactly what
-      # `node_rule` is for — the return type is void, so no `scope`
-      # query is needed.)
+      # ADR-37 — per-class-node validation over the engine-owned walk. Each `Prism::ClassNode` is checked
+      # against every contract independently, so the plugin no longer ships its own `class_nodes`
+      # traversal; `ActionChecker#check_class` keeps the per-class contract logic. (A per-class contract
+      # check is exactly what `node_rule` is for — the return type is void, so no `scope` query is
+      # needed.)
       node_rule Prism::ClassNode do |node, _scope, path|
         contracts = protocol_contracts
         next [] if contracts.empty?