rigortype 0.2.7 → 0.2.9

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

@@ -7,34 +7,27 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class Factorybot < Rigor::Plugin::Base
-      # Per-file walker — visits every `FactoryBot.<entry>(...)`
-      # call (and the `FactoryGirl` legacy alias) and validates
-      # the factory name + the keyword-argument attribute keys
-      # against the per-run {FactoryIndex}.
+      # Per-file walker — visits every `FactoryBot.<entry>(...)` call (and the `FactoryGirl` legacy alias)
+      # and validates the factory name + the keyword-argument attribute keys against the per-run
+      # {FactoryIndex}.
       #
-      # Recognised entry methods cover the canonical create /
-      # build / build_stubbed / attributes_for family; the same
-      # validation applies to every entry (the runtime semantics
-      # differ — one persists, one returns a hash — but the
-      # call-site shape is identical from the static check's
-      # perspective).
+      # Recognised entry methods cover the canonical create / build / build_stubbed / attributes_for
+      # family; the same validation applies to every entry (the runtime semantics differ — one persists,
+      # one returns a hash — but the call-site shape is identical from the static check's perspective).
       module Analyzer
         ENTRY_METHODS = %i[create build build_stubbed attributes_for create_list build_list build_stubbed_list].freeze
 
-        # One violation. Carries its own `location` because a single
-        # entry call yields diagnostics at different positions — the
-        # matcher/method name (`message_loc`) for factory-call /
-        # unknown-factory, and the attribute key node for
-        # unknown-attribute. The caller positions each via
-        # `Plugin::Base#diagnostic(node, location:)`.
+        # One violation. Carries its own `location` because a single entry call yields diagnostics at
+        # different positions — the matcher/method name (`message_loc`) for factory-call /
+        # unknown-factory, and the attribute key node for unknown-attribute. The caller positions each
+        # via `Plugin::Base#diagnostic(node, location:)`.
         Violation = Data.define(:location, :message, :severity, :rule)
 
         module_function
 
-        # The violations for a single entry call (`FactoryBot.create(...)`
-        # etc.), or `[]` when the node is not an entry call or its first
-        # argument is not a literal factory name. ADR-37: the engine owns
-        # the walk.
+        # The violations for a single entry call (`FactoryBot.create(...)` etc.), or `[]` when the node
+        # is not an entry call or its first argument is not a literal factory name. ADR-37: the engine
+        # owns the walk.
         #
         # @param call_node [Prism::Node]
         # @param factory_index [FactoryIndex]
@@ -80,20 +73,14 @@ module Rigor
             [factory_call_violation(call_node, factory_name, entry)]
         end
 
-        # The keyword-argument attribute keys come from the
-        # trailing `Prism::KeywordHashNode` (Ruby's
-        # `name: "value"` syntax). Each AssocNode whose key is
-        # a `Prism::SymbolNode` is treated as a literal
-        # attribute reference.
+        # The keyword-argument attribute keys come from the trailing `Prism::KeywordHashNode` (Ruby's
+        # `name: "value"` syntax). Each AssocNode whose key is a `Prism::SymbolNode` is treated as a
+        # literal attribute reference.
         #
-        # When `model_index` (the cross-plugin `:model_index`
-        # fact published by rigor-activerecord) is present,
-        # the effective accepted key set is the UNION of the
-        # factory's declared attributes plus the corresponding
-        # model's columns. FactoryBot's runtime accepts any AR
-        # attribute regardless of whether the factory declared
-        # it, so the cross-check broadens the acceptance
-        # accordingly.
+        # When `model_index` (the cross-plugin `:model_index` fact published by rigor-activerecord) is
+        # present, the effective accepted key set is the UNION of the factory's declared attributes plus
+        # the corresponding model's columns. FactoryBot's runtime accepts any AR attribute regardless of
+        # whether the factory declared it, so the cross-check broadens the acceptance accordingly.
         def unknown_attribute_violations(call_node, entry, model_index)
           accepted_keys, suggestion_dictionary = effective_keys(entry, model_index)
           attr_spell_checker = DidYouMean::SpellChecker.new(dictionary: suggestion_dictionary)
@@ -119,10 +106,8 @@ module Rigor
           [(factory_keys + model_columns).uniq.freeze, (factory_keys + model_columns).uniq.freeze]
         end
 
-        # Convention: `:user` → `User`, `:order_item` →
-        # `OrderItem`. Mirrors rigor-actionpack Phase 1's
-        # convention; namespaced models (`:admin_user` →
-        # `Admin::User`) are deferred.
+        # Convention: `:user` → `User`, `:order_item` → `OrderItem`. Mirrors rigor-actionpack Phase 1's
+        # convention; namespaced models (`:admin_user` → `Admin::User`) are deferred.
         def model_class_for(factory_name)
           factory_name.to_s.split("_").map(&:capitalize).join
         end

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

@@ -8,13 +8,10 @@ require_relative "factory_index"
 module Rigor
   module Plugin
     class Factorybot < Rigor::Plugin::Base
-      # Walks `factory_search_paths` and parses each `.rb` file
-      # into a {FactoryIndex}. The search-path list contains
-      # both directory paths (recursively walked) and direct
-      # file paths (read once); the typical default
-      # `["spec/factories", "spec/factories.rb"]` covers both
-      # the multi-file convention RSpec uses today and the
-      # legacy single-file form.
+      # Walks `factory_search_paths` and parses each `.rb` file into a {FactoryIndex}. The search-path
+      # list contains both directory paths (recursively walked) and direct file paths (read once); the
+      # typical default `["spec/factories", "spec/factories.rb"]` covers both the multi-file convention
+      # RSpec uses today and the legacy single-file form.
       #
       # The walker recognises:
       #
@@ -22,21 +19,16 @@ module Rigor
       # - `factory "users" do ... end` — string form
       # - `factory :users, aliases: [:author] do ... end` — alias form
       #
-      # Inside a factory block, attribute declarations come in
-      # several shapes. Only literal-name forms are recognised
-      # (Symbol arg / String arg):
+      # Inside a factory block, attribute declarations come in several shapes. Only literal-name forms
+      # are recognised (Symbol arg / String arg):
       #
-      # - `name { "Alice" }` — implicit attribute via
-      #   `method_missing` with a block (FactoryBot's modern
+      # - `name { "Alice" }` — implicit attribute via `method_missing` with a block (FactoryBot's modern
       #   syntax)
-      # - `name "Alice"` — implicit attribute via
-      #   `method_missing` with a positional argument (legacy)
-      # - `add_attribute(:name) { "Alice" }` — the explicit
-      #   form
+      # - `name "Alice"` — implicit attribute via `method_missing` with a positional argument (legacy)
+      # - `add_attribute(:name) { "Alice" }` — the explicit form
       #
-      # Sequences (`sequence(:email) { ... }`), associations
-      # (`association :author`), traits, and parent / child
-      # relationships are deferred to later slices.
+      # Sequences (`sequence(:email) { ... }`), associations (`association :author`), traits, and parent
+      # / child relationships are deferred to later slices.
       class FactoryDiscoverer
         def initialize(io_boundary:, search_paths:)
           @io_boundary = io_boundary
@@ -83,12 +75,10 @@ module Rigor
           nil
         end
 
-        # Yields `(factory_name, [attribute_names])` for every
-        # `factory :name do ... end` call discovered in the
-        # subtree. The walker recurses into top-level wrapping
-        # blocks (`FactoryBot.define do ... end`) and into
-        # arbitrary container nodes so factories inside `module`
-        # / `class` blocks are still picked up.
+        # Yields `(factory_name, [attribute_names])` for every `factory :name do ... end` call
+        # discovered in the subtree. The walker recurses into top-level wrapping blocks
+        # (`FactoryBot.define do ... end`) and into arbitrary container nodes so factories inside
+        # `module` / `class` blocks are still picked up.
         def walk_for_factories(node, &)
           return unless node.is_a?(Prism::Node)
 
@@ -116,26 +106,20 @@ module Rigor
           Rigor::Source::Literals.symbol_or_string_name(call_node.arguments&.arguments&.first)
         end
 
-        # Resolves the model class name for the factory.
-        # Three sources, in priority order:
+        # Resolves the model class name for the factory. Three sources, in priority order:
         #
-        # 1. Explicit `class: <Const>` keyword arg —
-        #    ConstantReadNode / ConstantPathNode value.
-        # 2. Explicit `class: "<name>"` keyword arg — String
-        #    value (supports `"Admin::User"`).
-        # 3. Inflected from the factory name — `:user` →
-        #    `"User"`, `:admin_user` → `"AdminUser"`. The
-        #    factory name is already singular by FactoryBot
-        #    convention, so we only need camelization.
+        # 1. Explicit `class: <Const>` keyword arg — ConstantReadNode / ConstantPathNode value.
+        # 2. Explicit `class: "<name>"` keyword arg — String value (supports `"Admin::User"`).
+        # 3. Inflected from the factory name — `:user` → `"User"`, `:admin_user` → `"AdminUser"`. The
+        #    factory name is already singular by FactoryBot convention, so we only need camelization.
         #
         # Returns a String (the canonical class name).
         def factory_model_class(call_node, factory_name)
           explicit = explicit_class_option(call_node)
           return explicit if explicit
 
-          # ADR-39: the real ActiveSupport::Inflector camelizes the factory
-          # name to its class (`admin_user` → `AdminUser`,
-          # `admin/user` → `Admin::User`), so the model-class fallback
+          # ADR-39: the real ActiveSupport::Inflector camelizes the factory name to its class
+          # (`admin_user` → `AdminUser`, `admin/user` → `Admin::User`), so the model-class fallback
           # matches Rails' real convention rather than an approximation.
           Rigor::Plugin::Inflector.camelize(factory_name)
         end
@@ -188,10 +172,9 @@ module Rigor
           attributes
         end
 
-        # Walks the block body collecting attribute names. Only
-        # top-level statements are examined — attributes inside
-        # `trait :admin do ... end` or other nested blocks are
-        # not collected (traits deferred to a follow-up).
+        # Walks the block body collecting attribute names. Only top-level statements are examined —
+        # attributes inside `trait :admin do ... end` or other nested blocks are not collected (traits
+        # deferred to a follow-up).
         def collect_attributes_from(node, accumulator)
           return unless node.is_a?(Prism::Node)
 
@@ -204,15 +187,14 @@ module Rigor
 
         def record_attribute(node, accumulator)
           return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
-          # Skip association / sequence / trait / framework
-          # methods — only plain attribute declarations are recorded.
+          # Skip association / sequence / trait / framework methods — only plain attribute declarations
+          # are recorded.
           return if SKIPPED_METHODS.include?(node.name)
 
           name = if node.name == :add_attribute
                    literal_name_arg(node)
                  else
-                   # method_missing form: the call's method
-                   # name IS the attribute name.
+                   # method_missing form: the call's method name IS the attribute name.
                    node.name.to_s
                  end
           accumulator << name if name

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

@@ -3,26 +3,22 @@
 module Rigor
   module Plugin
     class Factorybot < Rigor::Plugin::Base
-      # Per-run frozen index of discovered FactoryBot factories
-      # and the attribute keys each declares. Indexes only
-      # **literal symbol/string** factory names + **literal
-      # symbol** attribute names; sequences, parent/child
-      # relationships, traits, and dynamically-named factories
-      # are deferred to follow-up slices.
+      # Per-run frozen index of discovered FactoryBot factories and the attribute keys each declares.
+      # Indexes only **literal symbol/string** factory names + **literal symbol** attribute names;
+      # sequences, parent/child relationships, traits, and dynamically-named factories are deferred to
+      # follow-up slices.
       #
-      # Each entry carries a `model_class` — the inferred or
-      # explicit class the factory builds. Resolved from:
+      # Each entry carries a `model_class` — the inferred or explicit class the factory builds. Resolved
+      # from:
       #
-      #   1. An explicit `factory :user, class: User do`
-      #      keyword option (ConstantReadNode / ConstantPathNode
-      #      value).
-      #   2. An explicit `factory :user, class: "User"` keyword
-      #      option (String value, supports `"Admin::User"`).
-      #   3. Fallback: inflected from the factory name —
-      #      `:user` → `"User"`, `:admin_user` → `"AdminUser"`.
+      #   1. An explicit `factory :user, class: User do` keyword option (ConstantReadNode /
+      #      ConstantPathNode value).
+      #   2. An explicit `factory :user, class: "User"` keyword option (String value, supports
+      #      `"Admin::User"`).
+      #   3. Fallback: inflected from the factory name — `:user` → `"User"`, `:admin_user` →
+      #      `"AdminUser"`.
       #
-      # The structure is intentionally flat: one entry per
-      # factory name. Attribute lists deduplicate.
+      # The structure is intentionally flat: one entry per factory name. Attribute lists deduplicate.
       class FactoryIndex
         Entry = Data.define(:name, :attribute_names, :model_class)
 

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("::")