rigortype 0.2.7 → 0.2.9

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,17 +83,14 @@ 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]) }
+          unknown = keyword_pairs.reject { |pair| nested_condition?(pair[:value]) || valid_query_key?(entry, pair[:key]) }
           if unknown.empty?
             keyword_pairs.each { |pair| validate_enum_value(node, entry, pair) }
             push_recognised(node, entry, keyword_pairs.map { |p| p[: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,19 @@ 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.
+        # A keyword pair with a Hash value is a nested / joined-table condition (`Approval.where(approvals:
+        # { user_id: 1 })`, `where(users: { name: 'x' })`), where the key names an association or a joined
+        # table, not a column on the receiver. Rails resolves it through the join, so it must not be checked
+        # against the receiver's own columns. (An Array value — `where(status: [:a, :b])` — is an IN query on
+        # a real column, not nested, so only a Hash is skipped.)
+        def nested_condition?(value_node)
+          value_node.is_a?(Prism::HashNode) || value_node.is_a?(Prism::KeywordHashNode)
+        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.
         def validate_enum_value(node, entry, pair)
           return unless entry.enum?(pair[:key])
           return unless pair[:value].is_a?(Prism::SymbolNode)
@@ -199,13 +194,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,27 +23,35 @@ 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.
+        # Declaration macros whose column's runtime value is a rich object, not the SQL scalar. Their column
+        # must NOT be narrowed to the schema type (see {ModelIndex.build}'s type-override remap).
+        TYPE_OVERRIDE_METHODS = %i[serialize mount_uploader mount_uploaders].freeze
+
         def initialize(io_boundary:, search_paths:, base_classes:)
           @io_boundary = io_boundary
           @search_paths = search_paths
           @base_classes = base_classes.to_set
+          # Global set of column names whose declared runtime type overrides the schema scalar
+          # (`serialize` / `mount_uploader` / `attribute :x, CustomType`). Collected across every class AND
+          # concern module walked — a serialize inside a concern's `included do … end` is invisible to the
+          # per-model view (the discoverer doesn't follow `include`), so overrides are tracked globally by
+          # column name and applied wherever that column appears. Over-suppresses a same-named scalar
+          # column elsewhere (a precision cost, never a false positive).
+          @type_override_columns = Set.new
         end
 
+        attr_reader :type_override_columns
+
         # @return [Array<Hash>] rows of { class_name:, table_name_override:, sti_parent:, ... }
         def discover
           candidates = []
@@ -64,17 +67,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 +107,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 +144,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?
@@ -158,6 +154,8 @@ module Rigor
           full_name = (lexical_path + [class_local_name]).join("::")
           superclass = constant_path_name(node.superclass) if node.superclass
 
+          collect_type_overrides(node.body)
+
           yield({
             class_name: full_name,
             superclass_name: superclass,
@@ -179,12 +177,57 @@ module Rigor
           module_local_name = constant_path_name(node.constant_path)
           return if module_local_name.nil?
 
+          # Concerns (`module DiffPositionableNote`) carry `serialize` / `mount_uploader` inside an
+          # `included do … end` block; collect their overrides even though the module itself is not a model.
+          collect_type_overrides(node.body)
+
           inner_path = lexical_path + [module_local_name]
           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
+        # Records the column name of every `serialize :col` / `mount_uploader(s) :col` / `attribute :col,
+        # CustomType` in `body` (descending into `with_options` and concern `included do` blocks) into the
+        # global {#type_override_columns} set. `attribute :col, :symbol_type` (a built-in scalar type) is
+        # NOT an override — only a custom type CONSTANT is.
+        def collect_type_overrides(body)
+          type_override_declaration_calls(body).each do |node|
+            next if node.receiver
+
+            column = Rigor::Source::Literals.symbol_name(node.arguments&.arguments&.first)
+            next if column.nil?
+
+            if TYPE_OVERRIDE_METHODS.include?(node.name)
+              @type_override_columns << column
+            elsif node.name == :attribute && custom_type_attribute?(node)
+              @type_override_columns << column
+            end
+          end
+        end
+
+        # `declaration_calls` variant that also descends into a concern's `included do … end` block (the
+        # ActiveSupport::Concern idiom where models' shared `serialize` declarations live).
+        def type_override_declaration_calls(body)
+          return [] if body.nil?
+
+          body.compact_child_nodes.flat_map do |node|
+            next [] unless node.is_a?(Prism::CallNode)
+
+            if %i[with_options included].include?(node.name) && node.block.is_a?(Prism::BlockNode)
+              type_override_declaration_calls(node.block.body)
+            else
+              [node]
+            end
+          end
+        end
+
+        # True when an `attribute :col, <type>` call's type argument is a custom type CLASS (a constant),
+        # whose runtime value is a rich object — not a built-in `:symbol` type, which stays a scalar.
+        def custom_type_attribute?(node)
+          type_arg = node.arguments&.arguments&.[](1)
+          type_arg.is_a?(Prism::ConstantReadNode) || type_arg.is_a?(Prism::ConstantPathNode)
+        end
+
+        # 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 +251,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 +266,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 +284,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 +313,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 +345,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 +358,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 +378,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 +408,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 +464,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 +486,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 +503,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 +532,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 +556,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?