rigortype 0.2.7 → 0.2.8

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -17,56 +17,44 @@ module Rigor
     #       include Dry.Types()
     #     end
     #
-    # and publishes the resulting `{aliased_name => underlying_class}`
-    # table as the `:dry_type_aliases` cross-plugin fact (ADR-9).
-    # Other dry-rb adapter plugins consume this fact:
+    # and publishes the resulting `{aliased_name => underlying_class}` table as the `:dry_type_aliases`
+    # cross-plugin fact (ADR-9). Other dry-rb adapter plugins consume this fact:
     #
-    # - `rigor-dry-struct` reads it so `attribute :city, Types::String`
-    #   promotes `address.city` from `Dynamic[Top]` to `Nominal[String]`
-    #   via ADR-18's `returns_from_arg:` fact lookup.
-    # - `rigor-dry-validation` / `rigor-dry-schema` read it for
-    #   per-key type recognition in `schema { … }` / `params { … }`
-    #   blocks (separate plugin slice).
+    # - `rigor-dry-struct` reads it so `attribute :city, Types::String` promotes `address.city` from
+    #   `Dynamic[Top]` to `Nominal[String]` via ADR-18's `returns_from_arg:` fact lookup.
+    # - `rigor-dry-validation` / `rigor-dry-schema` read it for per-key type recognition in `schema { … }`
+    #   / `params { … }` blocks (separate plugin slice).
     #
     # ## Floor / ceiling (slice 1)
     #
     # Slice 1 ships the **floor**:
     #
-    # - Recognises `module X; include Dry.Types(); end` for any
-    #   constant module name `X` (commonly `Types`, sometimes
-    #   `MyTypes` / `AppTypes`).
-    # - Maps the **basic** dry-types constants: `String`, `Integer`,
-    #   `Float`, `Decimal`, `Symbol`, `Bool`, `True`, `False`, `Nil`,
-    #   `Date`, `DateTime`, `Time`, `Hash`, `Array`, `Any`.
-    # - Publishes the table as `{ "<Module>::<Alias>" =>
-    #   "<UnderlyingClass>" }` so consumers can match on the
-    #   qualified constant name they see in source.
+    # - Recognises `module X; include Dry.Types(); end` for any constant module name `X` (commonly
+    #   `Types`, sometimes `MyTypes` / `AppTypes`).
+    # - Maps the **basic** dry-types constants: `String`, `Integer`, `Float`, `Decimal`, `Symbol`, `Bool`,
+    #   `True`, `False`, `Nil`, `Date`, `DateTime`, `Time`, `Hash`, `Array`, `Any`.
+    # - Publishes the table as `{ "<Module>::<Alias>" => "<UnderlyingClass>" }` so consumers can match on
+    #   the qualified constant name they see in source.
     #
     # Implemented beyond the floor:
     #
-    # - Nested-namespace aliases (`Types::Coercible::Integer`,
-    #   `Types::Strict::Symbol`, `Types::Params::Bool`,
-    #   `Types::JSON::Date`) — the four coercion categories each
-    #   map to the same underlying class as their canonical shortcut.
-    # - User-authored compositions (`Email = Types::String.constrained(...)`,
-    #   transitive resolution through composition chains) — the alias
-    #   surface extends beyond the 15 canonical names.
+    # - Nested-namespace aliases (`Types::Coercible::Integer`, `Types::Strict::Symbol`,
+    #   `Types::Params::Bool`, `Types::JSON::Date`) — the four coercion categories each map to the same
+    #   underlying class as their canonical shortcut.
+    # - User-authored compositions (`Email = Types::String.constrained(...)`, transitive resolution
+    #   through composition chains) — the alias surface extends beyond the 15 canonical names.
     #
     # Deferred:
     #
-    # - `dry-types.unknown-alias` / `dry-types.alias-shadow`
-    #   diagnostics when downstream code references a name that
-    #   wasn't published.
+    # - `dry-types.unknown-alias` / `dry-types.alias-shadow` diagnostics when downstream code references
+    #   a name that wasn't published.
     #
     # ## Why no `diagnostics_for_file` at the floor?
     #
-    # The plugin's user-visible value at slice 1 is the published
-    # fact — every downstream uplift (precision promotion in
-    # `address.city`, schema-key recognition in `rigor-dry-validation`)
-    # consumes the fact rather than the plugin itself emitting
-    # diagnostics. The diagnostics surface lands when the
-    # `dry-types.*` rule family becomes load-bearing for
-    # demand-driven cases.
+    # The plugin's user-visible value at slice 1 is the published fact — every downstream uplift
+    # (precision promotion in `address.city`, schema-key recognition in `rigor-dry-validation`) consumes
+    # the fact rather than the plugin itself emitting diagnostics. The diagnostics surface lands when the
+    # `dry-types.*` rule family becomes load-bearing for demand-driven cases.
     class DryTypes < Rigor::Plugin::Base
       manifest(
         id: "dry-types",
@@ -75,12 +63,9 @@ module Rigor
         produces: [:dry_type_aliases]
       )
 
-      # Walks every project file once during `prepare(services)` to
-      # build the alias table, then publishes via the ADR-9 fact
-      # store. The walk is bounded by the configured `paths:`
-      # surface; each file's parse error degrades to "no
-      # contribution" without polluting the user-visible
-      # diagnostic stream.
+      # Walks every project file once during `prepare(services)` to build the alias table, then publishes
+      # via the ADR-9 fact store. The walk is bounded by the configured `paths:` surface; each file's
+      # parse error degrades to "no contribution" without polluting the user-visible diagnostic stream.
       def prepare(services)
         aliases = AliasScanner.scan(paths: scannable_paths(services))
         return if aliases.empty?
@@ -98,11 +83,9 @@ module Rigor
 
       private
 
-      # Resolves the project's `paths:` to a flat list of `.rb`
-      # files the scanner walks. Mirrors `Analysis::Runner`'s
-      # `expand_paths` floor; we don't need the runner's full
-      # exclude/sort surface because the alias table is a
-      # union — any duplicate scan is a no-op.
+      # Resolves the project's `paths:` to a flat list of `.rb` files the scanner walks. Mirrors
+      # `Analysis::Runner`'s `expand_paths` floor; we don't need the runner's full exclude/sort surface
+      # because the alias table is a union — any duplicate scan is a no-op.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if File.directory?(entry)

data/plugins/rigor-dry-types/lib/rigor-dry-types.rb

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

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation/contract_scanner.rb

@@ -5,18 +5,15 @@ require "prism"
 module Rigor
   module Plugin
     class DryValidation < Rigor::Plugin::Base
-      # Walks project source for `class T < Dry::Validation::Contract`
-      # subclasses and returns the contract class FQN set.
+      # Walks project source for `class T < Dry::Validation::Contract` subclasses and returns the
+      # contract class FQN set.
       #
-      # Recognition tightness: the superclass match accepts EITHER
-      # the fully-qualified `Dry::Validation::Contract` (3-segment
-      # path) OR the lexical-nested `Validation::Contract`
-      # (2-segment path, when the class body lives inside
-      # `module Dry`). The bare `< Contract` form (1-segment)
-      # is NOT recognised — too ambiguous; users who deeply nest
-      # under `Dry::Validation` should use the explicit form.
-      # Unrelated `< MyApp::Validation::Contract` shapes with the
-      # same tail do NOT register.
+      # Recognition tightness: the superclass match accepts EITHER the fully-qualified
+      # `Dry::Validation::Contract` (3-segment path) OR the lexical-nested `Validation::Contract`
+      # (2-segment path, when the class body lives inside `module Dry`). The bare `< Contract` form
+      # (1-segment) is NOT recognised — too ambiguous; users who deeply nest under `Dry::Validation`
+      # should use the explicit form. Unrelated `< MyApp::Validation::Contract` shapes with the same tail
+      # do NOT register.
       module ContractScanner
         CONTRACT_FULL_PATH = %w[Dry Validation Contract].freeze
         CONTRACT_LEXICAL_DRY_PATH = %w[Validation Contract].freeze
@@ -24,10 +21,8 @@ module Rigor
 
         module_function
 
-        # @param paths [Array<String>] absolute paths to `.rb`
-        #   files the project's `paths:` resolves to.
-        # @return [Array<String>] frozen, sorted list of
-        #   recognized contract class FQNs (e.g.
+        # @param paths [Array<String>] absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @return [Array<String>] frozen, sorted list of recognized contract class FQNs (e.g.
         #   `["App::NewUserContract", "Types::EmailContract"]`).
         def scan(paths:)
           contracts = []
@@ -77,11 +72,9 @@ module Rigor
         end
         private_class_method :collect_module_node
 
-        # Matches superclasses whose constant chain is EXACTLY
-        # `Dry::Validation::Contract` (full path) OR EXACTLY
-        # `Validation::Contract` (lexical-Dry path). Other shapes
-        # — including same-tail-but-different-root chains and
-        # the ambiguous bare `Contract` — do not match.
+        # Matches superclasses whose constant chain is EXACTLY `Dry::Validation::Contract` (full path) OR
+        # EXACTLY `Validation::Contract` (lexical-Dry path). Other shapes — including
+        # same-tail-but-different-root chains and the ambiguous bare `Contract` — do not match.
         def contract_subclass?(class_node)
           superclass = class_node.superclass
           return false if superclass.nil?

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -15,31 +15,23 @@ module Rigor
     #
     # Slice 1 floor:
     #
-    # - Walks the project for `class T < Dry::Validation::Contract`
-    #   subclasses and publishes the resulting set of contract
-    #   class FQNs as the `:dry_validation_contracts` ADR-9
-    #   cross-plugin fact.
-    # - Ships an RBS overlay (`sig/dry_validation.rbs`) typing
-    #   `Dry::Validation::Contract#call` (returns Result) and
-    #   `Dry::Validation::Result#{success?, failure?, to_h}`.
-    #   The manifest's `signature_paths: ["sig"]` auto-contributes
-    #   the overlay (ADR-25) — no project-side wiring needed.
+    # - Walks the project for `class T < Dry::Validation::Contract` subclasses and publishes the
+    #   resulting set of contract class FQNs as the `:dry_validation_contracts` ADR-9 cross-plugin fact.
+    # - Ships an RBS overlay (`sig/dry_validation.rbs`) typing `Dry::Validation::Contract#call` (returns
+    #   Result) and `Dry::Validation::Result#{success?, failure?, to_h}`. The manifest's
+    #   `signature_paths: ["sig"]` auto-contributes the overlay (ADR-25) — no project-side wiring needed.
     #
     # Slice 2 (deferred, per design note):
     #
-    # - Integrate with `:dry_schema_table` (published by
-    #   `rigor-dry-schema`) so the `params { ... }` block inside a
-    #   Contract contributes a typed `result.to_h` shape per the
-    #   schema. Until this lands, `result.to_h` types as
-    #   `Hash[Symbol, untyped]` (the generic RBS overlay shape).
+    # - Integrate with `:dry_schema_table` (published by `rigor-dry-schema`) so the `params { ... }`
+    #   block inside a Contract contributes a typed `result.to_h` shape per the schema. Until this lands,
+    #   `result.to_h` types as `Hash[Symbol, untyped]` (the generic RBS overlay shape).
     #
-    # Slice 3 (deferred): `json { ... }` adapter parity with
-    # `params { ... }`. Same shape as slice 2.
+    # Slice 3 (deferred): `json { ... }` adapter parity with `params { ... }`. Same shape as slice 2.
     #
-    # No ADR-3 amendment is needed for the validation surface
-    # itself; `Dry::Validation::Result` is a generic class, not a
-    # sum type (the `success?` / `failure?` predicates narrow via
-    # existing bool flow facts).
+    # No ADR-3 amendment is needed for the validation surface itself; `Dry::Validation::Result` is a
+    # generic class, not a sum type (the `success?` / `failure?` predicates narrow via existing bool flow
+    # facts).
     class DryValidation < Rigor::Plugin::Base
       manifest(
         id: "dry-validation",
@@ -47,9 +39,8 @@ module Rigor
         description: "Recognises `class T < Dry::Validation::Contract` subclasses and " \
                      "publishes the contract FQN set.",
         produces: [:dry_validation_contracts],
-        # Auto-contribute the bundled RBS overlay (Contract#call -> Result,
-        # Result#success?/#to_h/...) per ADR-25, so no project-side
-        # signature_paths wiring is needed.
+        # Auto-contribute the bundled RBS overlay (Contract#call -> Result, Result#success?/#to_h/...)
+        # per ADR-25, so no project-side signature_paths wiring is needed.
         signature_paths: ["sig"]
       )
 

data/plugins/rigor-dry-validation/lib/rigor-dry-validation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-# Gem entry point. Required by Rigor's plugin loader when
-# `.rigor.yml` lists `rigor-dry-validation` under `plugins:`.
-# Side-effects a `Rigor::Plugin.register` call via the
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-dry-validation`
+# under `plugins:`. Side-effects a `Rigor::Plugin.register` call via the
 # `lib/rigor/plugin/dry_validation.rb` class body.
 require_relative "rigor/plugin/dry_validation"

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)