rigortype 0.2.7 → 0.2.8

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_index.rb

@@ -3,22 +3,17 @@
 module Rigor
   module Plugin
     class Activejob < Rigor::Plugin::Base
-      # Frozen catalogue of discovered ActiveJob subclasses
-      # keyed by qualified class name. Each entry holds the
-      # `#perform` method's arity envelope so the analyzer can
-      # validate `Job.perform_later(...)` call sites.
+      # Frozen catalogue of discovered ActiveJob subclasses keyed by qualified class name. Each entry
+      # holds the `#perform` method's arity envelope so the analyzer can validate
+      # `Job.perform_later(...)` call sites.
       #
-      # `min_arity` / `max_arity` form a closed range
-      # (`Float::INFINITY` for the upper bound when `*args`
-      # is present). `keyword_required` lists any required
-      # keyword arguments — Active Job supports keyword args
-      # but they're rare in user code, so the analyzer
-      # validates positional arity only (keyword arity
-      # validation is deferred).
+      # `min_arity` / `max_arity` form a closed range (`Float::INFINITY` for the upper bound when
+      # `*args` is present). `keyword_required` lists any required keyword arguments — Active Job
+      # supports keyword args but they're rare in user code, so the analyzer validates positional arity
+      # only (keyword arity validation is deferred).
       class JobIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required) do
-          # Flexible-friendly textual form of the arity for
-          # error messages: `1`, `1..2`, `2+`.
+          # Flexible-friendly textual form of the arity for error messages: `1`, `1..2`, `2+`.
           def arity_label
             return "#{min_arity}+" if max_arity == Float::INFINITY
             return min_arity.to_s if min_arity == max_arity

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

@@ -8,14 +8,12 @@ require_relative "activejob/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-activejob — validates `Job.perform_later(...)` /
-    # `.perform_now(...)` / `.perform(...)` argument arity
-    # against the discovered `#perform` definitions.
+    # rigor-activejob — validates `Job.perform_later(...)` / `.perform_now(...)` / `.perform(...)`
+    # argument arity against the discovered `#perform` definitions.
     #
     # Tier 1D of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Statically discovers ActiveJob subclasses by walking
-    # the configured `job_search_paths` and parsing each
-    # file with Prism — no `active_job` runtime dependency.
+    # Statically discovers ActiveJob subclasses by walking the configured `job_search_paths` and
+    # parsing each file with Prism — no `active_job` runtime dependency.
     #
     # ## Configuration
     #
@@ -27,16 +25,12 @@ module Rigor
     #
     # ## Limitations (v0.1.0)
     #
-    # - Direct-superclass match only. `class WelcomeJob <
-    #   BaseJob` where `BaseJob < ApplicationJob` is NOT
-    #   discovered. Add `BaseJob` to `job_base_classes` if
-    #   needed.
-    # - The `#perform` arity is read from the syntactic
-    #   parameter list. Methods built via `define_method`
-    #   are out of scope.
-    # - Required keyword arguments are recognised but not
-    #   validated at the call site (positional arity only
-    #   for v0.1.0).
+    # - Direct-superclass match only. `class WelcomeJob < BaseJob` where `BaseJob < ApplicationJob` is
+    #   NOT discovered. Add `BaseJob` to `job_base_classes` if needed.
+    # - The `#perform` arity is read from the syntactic parameter list. Methods built via
+    #   `define_method` are out of scope.
+    # - Required keyword arguments are recognised but not validated at the call site (positional arity
+    #   only for v0.1.0).
     class Activejob < Rigor::Plugin::Base
       manifest(
         id: "activejob",
@@ -48,11 +42,10 @@ module Rigor
         }
       )
 
-      # Cached: discovered job index. `watch:` (ADR-60 WD3) covers
-      # every `.rb` under `job_search_paths` so the cache invalidates
-      # when a job is added, removed, or edited; the discoverer's
-      # in-block `IoBoundary` reads are captured into the record-and-
-      # validate dependency descriptor after the block runs.
+      # Cached: discovered job index. `watch:` (ADR-60 WD3) covers every `.rb` under `job_search_paths`
+      # so the cache invalidates when a job is added, removed, or edited; the discoverer's in-block
+      # `IoBoundary` reads are captured into the record-and-validate dependency descriptor after the
+      # block runs.
       producer :job_index, watch: -> { [[@job_search_paths, "**/*.rb"]] } do |_params|
         JobDiscoverer.new(
           io_boundary: io_boundary,
@@ -66,9 +59,8 @@ module Rigor
         @job_base_classes = Array(config.fetch("job_base_classes")).map(&:to_s)
       end
 
-      # File-level only: the load-error emission. Per-call arity
-      # validation runs over the engine-owned walk via the node_rule
-      # below (ADR-37). The job index is lazily loaded + memoised by
+      # File-level only: the load-error emission. Per-call arity validation runs over the engine-owned
+      # walk via the node_rule below (ADR-37). The job index is lazily loaded + memoised by
       # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:job_index)

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

@@ -5,9 +5,8 @@ require "prism"
 module Rigor
   module Plugin
     class Activerecord < Rigor::Plugin::Base
-      # Per-file AST walker. For each `Model.find(...)` /
-      # `Model.find_by(...)` / `Model.where(...)` call where
-      # `Model` is a name in the {ModelIndex}, emits diagnostics:
+      # Per-file AST walker. For each `Model.find(...)` / `Model.find_by(...)` / `Model.where(...)` call
+      # where `Model` is a name in the {ModelIndex}, emits diagnostics:
       #
       # | Method | Recognised arg shape | Validation |
       # | --- | --- | --- |
@@ -16,17 +15,13 @@ module Rigor
       # | `Model.where(col: v, ...)` | keyword args | each key must be a column |
       # | `Model.where(string)` | String literal | parser-side; not validated |
       #
-      # Successful matches surface as `:info` diagnostics naming
-      # the resolved table; unknown columns surface as `:error`.
-      # Calls whose receiver is not a model in the index, and
-      # calls with non-keyword arguments to `where` / `find_by`,
-      # stay silent.
+      # Successful matches surface as `:info` diagnostics naming the resolved table; unknown columns
+      # surface as `:error`. Calls whose receiver is not a model in the index, and calls with
+      # non-keyword arguments to `where` / `find_by`, stay silent.
       class Analyzer
-        # Methods that take a column → value Hash and need each key
-        # validated against the receiver's column set. The bang
-        # variants (`find_by!` raises instead of returning nil;
-        # `find_or_create_by!` raises on a validation failure) and
-        # `create_or_find_by` / `create_or_find_by!` take the
+        # Methods that take a column → value Hash and need each key validated against the receiver's
+        # column set. The bang variants (`find_by!` raises instead of returning nil; `find_or_create_by!`
+        # raises on a validation failure) and `create_or_find_by` / `create_or_find_by!` take the
         # identical column-hash argument shape.
         COLUMN_HASH_METHODS = %i[
           where
@@ -88,14 +83,11 @@ module Rigor
           keyword_pairs = keyword_argument_pairs(node)
           return push_recognised(node, entry) if keyword_pairs.empty?
 
-          # Models with no schema-side columns are virtual — backed
-          # by a database VIEW (Mastodon's `Instance` model wraps a
-          # SQL view that isn't in `db/schema.rb`), seeded from an
-          # external source, or otherwise opaque to our schema
-          # parser. Without a column set we cannot meaningfully
-          # check query keys; surface the call as recognised and
-          # skip column validation entirely rather than firing a
-          # false `unknown-column` against every key.
+          # Models with no schema-side columns are virtual — backed by a database VIEW (Mastodon's
+          # `Instance` model wraps a SQL view that isn't in `db/schema.rb`), seeded from an external
+          # source, or otherwise opaque to our schema parser. Without a column set we cannot meaningfully
+          # check query keys; surface the call as recognised and skip column validation entirely rather
+          # than firing a false `unknown-column` against every key.
           return push_recognised(node, entry, keyword_pairs.map { |p| p[:key] }) if entry.column_names.empty?
 
           unknown = keyword_pairs.reject { |pair| valid_query_key?(entry, pair[:key]) }
@@ -114,23 +106,20 @@ module Rigor
           end
         end
 
-        # ActiveRecord's `where` / `find_by` / `find_or_initialize_by`
-        # accept either a column name *or* a singular association
-        # name (belongs_to / has_one). The latter resolves to the
-        # association's FK column behind the scenes:
+        # ActiveRecord's `where` / `find_by` / `find_or_initialize_by` accept either a column name *or* a
+        # singular association name (belongs_to / has_one). The latter resolves to the association's FK
+        # column behind the scenes:
         #
         #   AccountPin.find_by(account: x)
         #   # → SELECT … WHERE account_id = x.id
         #
-        # Without this allowance, every `find_by(<assoc>:)` call
-        # surfaces as an `unknown-column` false positive — Mastodon
-        # saw ~100 such hits across the API controllers, all of
-        # which were the canonical Rails idiom rather than typos.
+        # Without this allowance, every `find_by(<assoc>:)` call surfaces as an `unknown-column` false
+        # positive — Mastodon saw ~100 such hits across the API controllers, all of which were the
+        # canonical Rails idiom rather than typos.
         #
-        # `alias_attribute` names resolve to their target before
-        # the column / association check — querying by an aliased
-        # attribute is a valid Rails idiom and must not surface as
-        # an `unknown-column`.
+        # `alias_attribute` names resolve to their target before the column / association check —
+        # querying by an aliased attribute is a valid Rails idiom and must not surface as an
+        # `unknown-column`.
         def valid_query_key?(entry, key)
           key = entry.resolve_alias(key) if entry.alias?(key)
 
@@ -140,13 +129,10 @@ module Rigor
           assoc && assoc[:kind] == :singular
         end
 
-        # When the column is an enum-bearing column AND the
-        # passed value is a Symbol literal, the value MUST be
-        # one of the declared enum values. Non-Symbol values
-        # (variables, expressions) decline so dynamic call
-        # sites stay silent. Sequences (`status: [:active,
-        # :archived]`) are intentionally NOT walked here —
-        # the relation-shape check belongs in a future track.
+        # When the column is an enum-bearing column AND the passed value is a Symbol literal, the value
+        # MUST be one of the declared enum values. Non-Symbol values (variables, expressions) decline so
+        # dynamic call sites stay silent. Sequences (`status: [:active, :archived]`) are intentionally NOT
+        # walked here — the relation-shape check belongs in a future track.
         def validate_enum_value(node, entry, pair)
           return unless entry.enum?(pair[:key])
           return unless pair[:value].is_a?(Prism::SymbolNode)
@@ -199,13 +185,10 @@ module Rigor
           node.arguments.arguments.size
         end
 
-        # Returns the symbol-keyed pairs of any KeywordHashNode
-        # argument as `{ key:, value: }` rows. Plain hash-literal
-        # arguments (`Model.where({a: 1})`) are NOT walked —
-        # Rails accepts both, but the keyword form is the
-        # idiomatic one. The `value` Prism node is preserved so
-        # the enum check downstream can recognise Symbol
-        # literals without re-walking the call.
+        # Returns the symbol-keyed pairs of any KeywordHashNode argument as `{ key:, value: }` rows. Plain
+        # hash-literal arguments (`Model.where({a: 1})`) are NOT walked — Rails accepts both, but the
+        # keyword form is the idiomatic one. The `value` Prism node is preserved so the enum check
+        # downstream can recognise Symbol literals without re-walking the call.
         def keyword_argument_pairs(node)
           return [] if node.arguments.nil?
 

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb

@@ -6,20 +6,15 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class Activerecord < Rigor::Plugin::Base
-      # Walks the configured model search paths via the plugin's
-      # `IoBoundary`, parses each `.rb` file with Prism, and
-      # collects class declarations that resolve to ActiveRecord
-      # models.
+      # Walks the configured model search paths via the plugin's `IoBoundary`, parses each `.rb` file with
+      # Prism, and collects class declarations that resolve to ActiveRecord models.
       #
-      # Discovery is a two-step pass. First every class declaration
-      # is captured as a *candidate* (its name, its superclass
-      # name, and its DSL metadata). Then a fixpoint marks a
-      # candidate as a model when its superclass is a configured
-      # base class OR (transitively) the class name of another
-      # model — this is what makes single-table-inheritance
-      # subclasses (`class Admin < User`) discoverable. Each STI
-      # child carries an `sti_parent:` pointer the {ModelIndex}
-      # uses to inherit the root model's table and DSL surface.
+      # Discovery is a two-step pass. First every class declaration is captured as a *candidate* (its
+      # name, its superclass name, and its DSL metadata). Then a fixpoint marks a candidate as a model
+      # when its superclass is a configured base class OR (transitively) the class name of another model
+      # — this is what makes single-table-inheritance subclasses (`class Admin < User`) discoverable.
+      # Each STI child carries an `sti_parent:` pointer the {ModelIndex} uses to inherit the root model's
+      # table and DSL surface.
       #
       # Returns rows the {ModelIndex} consumes:
       #
@@ -28,21 +23,16 @@ module Rigor
       #
       # Limitations (intentional for v0.1.0 of the plugin):
       #
-      # - `self.table_name = "..."` recognised only when the RHS
-      #   is a String literal. Computed names
+      # - `self.table_name = "..."` recognised only when the RHS is a String literal. Computed names
       #   (`self.table_name = "#{tenant}_users"`) are skipped.
-      # - Modules (`class Admin::User < ApplicationRecord`) are
-      #   recognised; the resulting class name is the lexical
-      #   path (`Admin::User`).
-      # - The STI fixpoint matches a superclass name against model
-      #   class names tolerating a leading `::`; richer constant
-      #   resolution (relative namespacing) is not modelled.
+      # - Modules (`class Admin::User < ApplicationRecord`) are recognised; the resulting class name is
+      #   the lexical path (`Admin::User`).
+      # - The STI fixpoint matches a superclass name against model class names tolerating a leading `::`;
+      #   richer constant resolution (relative namespacing) is not modelled.
       class ModelDiscoverer
         # @param io_boundary [Rigor::Plugin::IoBoundary]
-        # @param search_paths [Array<String>] absolute or
-        #   project-relative paths.
-        # @param base_classes [Array<String>] superclass names that
-        #   identify a class as an AR model.
+        # @param search_paths [Array<String>] absolute or project-relative paths.
+        # @param base_classes [Array<String>] superclass names that identify a class as an AR model.
         def initialize(io_boundary:, search_paths:, base_classes:)
           @io_boundary = io_boundary
           @search_paths = search_paths
@@ -64,17 +54,13 @@ module Rigor
 
         private
 
-        # Fixpoint over the captured class candidates: a candidate
-        # is a model when its superclass is a configured base
-        # class, or — transitively — the class name of an
-        # already-known model. The second arm is what discovers
-        # STI subclasses; the matched parent name is stamped onto
-        # the row as `sti_parent:` so the {ModelIndex} can inherit
-        # the root model's table and association surface.
+        # Fixpoint over the captured class candidates: a candidate is a model when its superclass is a
+        # configured base class, or — transitively — the class name of an already-known model. The
+        # second arm is what discovers STI subclasses; the matched parent name is stamped onto the row as
+        # `sti_parent:` so the {ModelIndex} can inherit the root model's table and association surface.
         #
-        # Non-model classes (POROs, service objects that happen to
-        # live under `app/models/`) never enter `model_names` and
-        # are dropped.
+        # Non-model classes (POROs, service objects that happen to live under `app/models/`) never enter
+        # `model_names` and are dropped.
         def resolve_models(candidates)
           model_names = {}
           sti_parent = {}
@@ -108,9 +94,8 @@ module Rigor
           end
         end
 
-        # Resolves a superclass NAME against the set of known
-        # model class names, tolerating a leading `::`. Returns
-        # the matched model class name, or nil.
+        # Resolves a superclass NAME against the set of known model class names, tolerating a leading
+        # `::`. Returns the matched model class name, or nil.
         def model_match(superclass_name, model_names)
           return superclass_name if model_names.key?(superclass_name)
 
@@ -146,11 +131,9 @@ module Rigor
           end
         end
 
-        # Captures EVERY class declaration as a candidate — the
-        # `resolve_models` fixpoint decides afterwards which ones
-        # are models. The DSL metadata is extracted eagerly; for a
-        # non-model class it is simply discarded when the candidate
-        # is dropped.
+        # Captures EVERY class declaration as a candidate — the `resolve_models` fixpoint decides
+        # afterwards which ones are models. The DSL metadata is extracted eagerly; for a non-model class
+        # it is simply discarded when the candidate is dropped.
         def visit_class(node, lexical_path, &)
           class_local_name = constant_path_name(node.constant_path)
           return if class_local_name.nil?
@@ -183,8 +166,7 @@ module Rigor
           walk_for_classes(node.body, inner_path, &) if node.body
         end
 
-        # Renders a constant-path node (`Admin::User`,
-        # `::ApplicationRecord`) as a String. Returns nil for
+        # Renders a constant-path node (`Admin::User`, `::ApplicationRecord`) as a String. Returns nil for
         # shapes the discoverer chooses not to handle.
         def constant_path_name(node)
           return nil if node.nil?
@@ -208,9 +190,8 @@ module Rigor
           end
         end
 
-        # Looks for `self.table_name = "..."` at the top level of
-        # the class body. Returns the literal String when found,
-        # nil otherwise.
+        # Looks for `self.table_name = "..."` at the top level of the class body. Returns the literal
+        # String when found, nil otherwise.
         def lookup_table_name_override(body)
           return nil if body.nil?
 
@@ -224,19 +205,14 @@ module Rigor
           nil
         end
 
-        # Recognised single-instance and collection association
-        # DSL methods. The kind drives the eventual return-type
-        # contribution: singular associations narrow to
-        # `Nominal[Target] | nil`, plural ones narrow to
-        # `ActiveRecord::Relation[Target]`.
+        # Recognised single-instance and collection association DSL methods. The kind drives the eventual
+        # return-type contribution: singular associations narrow to `Nominal[Target] | nil`, plural ones
+        # narrow to `ActiveRecord::Relation[Target]`.
         #
-        # `composed_of` value-object aggregations and
-        # `delegated_type` roles are folded in here too — both
-        # accept the association name as a `where` / `find_by`
-        # query key, so omitting them turns every such query into
-        # a false `unknown-column`. `composed_of` resolves to its
-        # value class (a real target); `delegated_type` is
-        # polymorphic (no single target).
+        # `composed_of` value-object aggregations and `delegated_type` roles are folded in here too — both
+        # accept the association name as a `where` / `find_by` query key, so omitting them turns every
+        # such query into a false `unknown-column`. `composed_of` resolves to its value class (a real
+        # target); `delegated_type` is polymorphic (no single target).
         ASSOCIATION_METHODS = {
           belongs_to: :singular,
           has_one: :singular,
@@ -247,28 +223,21 @@ module Rigor
         }.freeze
         private_constant :ASSOCIATION_METHODS
 
-        # Association DSL methods that are ALWAYS polymorphic —
-        # the accessor has no single static target class.
-        # `belongs_to` / `has_one` become polymorphic only with
-        # an explicit `polymorphic: true` option.
+        # Association DSL methods that are ALWAYS polymorphic — the accessor has no single static target
+        # class. `belongs_to` / `has_one` become polymorphic only with an explicit `polymorphic: true`
+        # option.
         POLYMORPHIC_BY_DEFAULT = %i[delegated_type].freeze
         private_constant :POLYMORPHIC_BY_DEFAULT
 
-        # Class-body declaration calls — the top-level `CallNode`s
-        # PLUS those nested inside a `with_options(...) do … end`
-        # block. `with_options` is Rails' idiom for sharing
-        # options across a group of `belongs_to` / `validates` /
-        # etc. declarations; without descending into it every
-        # association / enum / validation declared inside is
-        # invisible to the discoverer, turning `where(<assoc>:
-        # ...)` into a false `unknown-column`. Nested
-        # `with_options` blocks recurse.
+        # Class-body declaration calls — the top-level `CallNode`s PLUS those nested inside a
+        # `with_options(...) do … end` block. `with_options` is Rails' idiom for sharing options across a
+        # group of `belongs_to` / `validates` / etc. declarations; without descending into it every
+        # association / enum / validation declared inside is invisible to the discoverer, turning
+        # `where(<assoc>: ...)` into a false `unknown-column`. Nested `with_options` blocks recurse.
         #
-        # The options the `with_options` call itself carries (e.g.
-        # `with_options class_name: 'Account'`) are NOT merged into
-        # the nested calls — discovering the declaration name is
-        # what clears the false positive; the merged-option target
-        # precision is a separate refinement.
+        # The options the `with_options` call itself carries (e.g. `with_options class_name: 'Account'`)
+        # are NOT merged into the nested calls — discovering the declaration name is what clears the
+        # false positive; the merged-option target precision is a separate refinement.
         def declaration_calls(body)
           return [] if body.nil?
 
@@ -283,17 +252,13 @@ module Rigor
           end
         end
 
-        # Walks the class body for association DSL calls and
-        # returns a list of rows shaped:
+        # Walks the class body for association DSL calls and returns a list of rows shaped:
         #
         #     { name: "user", kind: :singular, target: "User" }
         #
-        # The `target` is resolved from an explicit
-        # `class_name: "Foo"` option when supplied, otherwise
-        # inferred from the association name via
-        # {Inflector.classify}. Calls whose first arg is not a
-        # Symbol literal (or whose `class_name:` is a non-literal
-        # expression) decline rather than guess.
+        # The `target` is resolved from an explicit `class_name: "Foo"` option when supplied, otherwise
+        # inferred from the association name via {Inflector.classify}. Calls whose first arg is not a
+        # Symbol literal (or whose `class_name:` is a non-literal expression) decline rather than guess.
         def lookup_associations(body)
           return [] if body.nil?
 
@@ -319,10 +284,8 @@ module Rigor
           polymorphic = POLYMORPHIC_BY_DEFAULT.include?(node.name) ||
                         association_option(args, "polymorphic") == true
 
-          # A polymorphic association has no single static target
-          # class — `target` is nil and the flow contribution
-          # declines to narrow rather than inventing a wrong
-          # `Nominal[<classified-name>]`.
+          # A polymorphic association has no single static target class — `target` is nil and the flow
+          # contribution declines to narrow rather than inventing a wrong `Nominal[<classified-name>]`.
           if polymorphic
             target = nil
           else
@@ -334,15 +297,12 @@ module Rigor
             nullable: association_nullable?(node.name, args) }
         end
 
-        # Whether a `:singular` association's accessor can return
-        # `nil`. `has_one` genuinely can (no associated record →
-        # `nil`). `belongs_to` is **required (non-`nil`) by default
-        # since Rails 5** (`belongs_to_required_by_default`); it
-        # becomes nullable only when the call passes `optional: true`
-        # or `required: false`. `composed_of` is non-nullable
-        # unless `allow_nil: true`. `delegated_type` roles are
-        # required. A non-literal option value declines to the
-        # default rather than guessing.
+        # Whether a `:singular` association's accessor can return `nil`. `has_one` genuinely can (no
+        # associated record → `nil`). `belongs_to` is **required (non-`nil`) by default since Rails 5**
+        # (`belongs_to_required_by_default`); it becomes nullable only when the call passes
+        # `optional: true` or `required: false`. `composed_of` is non-nullable unless `allow_nil: true`.
+        # `delegated_type` roles are required. A non-literal option value declines to the default rather
+        # than guessing.
         def association_nullable?(method_name, args)
           case method_name
           when :has_one
@@ -357,9 +317,8 @@ module Rigor
           end
         end
 
-        # Reads a literal boolean association option (`optional:` /
-        # `required:`). Returns `true` / `false` for a literal, or
-        # `nil` when the key is absent or its value is non-literal.
+        # Reads a literal boolean association option (`optional:` / `required:`). Returns `true` / `false`
+        # for a literal, or `nil` when the key is absent or its value is non-literal.
         def association_option(args, key)
           args.each do |arg|
             next unless arg.is_a?(Prism::KeywordHashNode)
@@ -388,10 +347,9 @@ module Rigor
           nil
         end
 
-        # `enum status: { active: 0, archived: 1 }` (Rails ≤6)
-        # and `enum :status, [:active, :archived]` (Rails 7+).
-        # Returns `Hash<column_name => Array<Symbol>>`.
-        # Non-literal forms decline rather than guess.
+        # `enum status: { active: 0, archived: 1 }` (Rails ≤6) and `enum :status, [:active, :archived]`
+        # (Rails 7+). Returns `Hash<column_name => Array<Symbol>>`. Non-literal forms decline rather than
+        # guess.
         def lookup_enums(body)
           return {} if body.nil?
 
@@ -445,10 +403,9 @@ module Rigor
           end
         end
 
-        # `scope :active, -> { ... }`. Records the scope name
-        # only (the body is intentionally NOT introspected —
-        # the caller contributes `ActiveRecord::Relation[Model]`
-        # based on the name alone via `class_scope_return_type`).
+        # `scope :active, -> { ... }`. Records the scope name only (the body is intentionally NOT
+        # introspected — the caller contributes `ActiveRecord::Relation[Model]` based on the name alone
+        # via `class_scope_return_type`).
         def lookup_scopes(body)
           return [] if body.nil?
 
@@ -468,11 +425,9 @@ module Rigor
           scopes.freeze
         end
 
-        # `validates :name, presence: true, length: { maximum: 100 }`.
-        # Records the attribute name (the validator option set
-        # is ignored — the value here is the diagnostic
-        # `validates :unknown_attr` surfacing when the attribute
-        # isn't a column on the table).
+        # `validates :name, presence: true, length: { maximum: 100 }`. Records the attribute name (the
+        # validator option set is ignored — the value here is the diagnostic `validates :unknown_attr`
+        # surfacing when the attribute isn't a column on the table).
         def lookup_validations(body)
           return [] if body.nil?
 
@@ -487,10 +442,9 @@ module Rigor
           attrs.uniq.freeze
         end
 
-        # `before_save :foo`, `after_create :bar`, etc. Records
-        # the referenced method name (a Symbol literal). The
-        # diagnostic value is "did you forget to `def` this?".
-        # Block callbacks (`before_save { ... }`) decline.
+        # `before_save :foo`, `after_create :bar`, etc. Records the referenced method name (a Symbol
+        # literal). The diagnostic value is "did you forget to `def` this?". Block callbacks
+        # (`before_save { ... }`) decline.
         CALLBACK_METHODS = %i[
           before_validation after_validation
           before_save after_save around_save
@@ -517,12 +471,10 @@ module Rigor
           targets.freeze
         end
 
-        # `alias_attribute :new_name, :old_name`. Records the
-        # mapping so the analyzer accepts the alias as a query
-        # key — without it every `where(<alias>: ...)` /
-        # `find_by(<alias>: ...)` call surfaces as a false
-        # `unknown-column`. Returns `Hash<alias => target>`;
-        # non-Symbol-literal forms decline rather than guess.
+        # `alias_attribute :new_name, :old_name`. Records the mapping so the analyzer accepts the alias
+        # as a query key — without it every `where(<alias>: ...)` / `find_by(<alias>: ...)` call surfaces
+        # as a false `unknown-column`. Returns `Hash<alias => target>`; non-Symbol-literal forms decline
+        # rather than guess.
         def lookup_aliases(body)
           return {} if body.nil?
 
@@ -543,10 +495,8 @@ module Rigor
           aliases.freeze
         end
 
-        # Collects every Symbol-literal positional argument
-        # from a CallNode. Used by both `lookup_validations`
-        # and `lookup_callbacks` to extract the attribute /
-        # method name list.
+        # Collects every Symbol-literal positional argument from a CallNode. Used by both
+        # `lookup_validations` and `lookup_callbacks` to extract the attribute / method name list.
         def symbol_args(node)
           args = node.arguments&.arguments
           return [] if args.nil?