rigortype 0.2.7 → 0.2.8

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

@@ -3,44 +3,32 @@
 module Rigor
   module Plugin
     class Activerecord < Rigor::Plugin::Base
-      # Maps a discovered ActiveRecord model class name to its
-      # resolved table name and the column set the schema attaches
-      # to that table. Marshal-clean; the cache producer round-
-      # trips it through the standard pair.
+      # Maps a discovered ActiveRecord model class name to its resolved table name and the column set the
+      # schema attaches to that table. Marshal-clean; the cache producer round-trips it through the
+      # standard pair.
       #
       # Construction is two-phase by design:
-      # 1. {ModelDiscoverer} walks the project source for model
-      #    class declarations (direct base-class children plus
-      #    transitive STI subclasses) and yields a row per model.
-      # 2. The plugin combines those rows with the parsed
-      #    {SchemaTable} to produce this index.
+      # 1. {ModelDiscoverer} walks the project source for model class declarations (direct base-class
+      #    children plus transitive STI subclasses) and yields a row per model.
+      # 2. The plugin combines those rows with the parsed {SchemaTable} to produce this index.
       #
-      # `table_name_override` is non-nil when the source contained
-      # `self.table_name = "..."`. When nil, the table name
-      # derives from {Inflector.tableize}.
+      # `table_name_override` is non-nil when the source contained `self.table_name = "..."`. When nil,
+      # the table name derives from {Inflector.tableize}.
       #
-      # Single-table-inheritance subclasses (`class Admin < User`)
-      # carry an `sti_parent:` pointer; their {Entry} resolves its
-      # table from the root model and inherits the chain's
-      # declared associations / enums / aliases / scopes /
-      # validations / callbacks.
+      # Single-table-inheritance subclasses (`class Admin < User`) carry an `sti_parent:` pointer; their
+      # {Entry} resolves its table from the root model and inherits the chain's declared associations /
+      # enums / aliases / scopes / validations / callbacks.
       class ModelIndex
-        # `associations` is a frozen `Array<Hash>` where each
-        # row carries `{ name:, kind:, target:, nullable: }`:
+        # `associations` is a frozen `Array<Hash>` where each row carries `{ name:, kind:, target:,
+        # nullable: }`:
         #
-        # - `name`   — String, the association method name as
-        #              the user invokes it (`"posts"`).
-        # - `kind`   — `:singular` (`belongs_to` / `has_one`)
-        #              or `:collection` (`has_many`).
-        # - `target` — String, the target class name resolved
-        #              either from an explicit `class_name:`
+        # - `name`   — String, the association method name as the user invokes it (`"posts"`).
+        # - `kind`   — `:singular` (`belongs_to` / `has_one`) or `:collection` (`has_many`).
+        # - `target` — String, the target class name resolved either from an explicit `class_name:`
         #              option or via {Inflector.classify}.
-        # - `nullable` — Boolean; whether a `:singular` accessor
-        #              can return `nil`. `has_one` → `true`;
-        #              `belongs_to` → `false` (required by default
-        #              since Rails 5) unless `optional: true` /
-        #              `required: false`. Meaningless for
-        #              `:collection` rows.
+        # - `nullable` — Boolean; whether a `:singular` accessor can return `nil`. `has_one` → `true`;
+        #              `belongs_to` → `false` (required by default since Rails 5) unless `optional: true`
+        #              / `required: false`. Meaningless for `:collection` rows.
         Entry = Struct.new(:class_name, :table_name, :columns, :associations,
                            :enums, :scopes, :validations, :callbacks, :aliases,
                            keyword_init: true) do
@@ -71,8 +59,7 @@ module Rigor
           # `scopes` is `Array<scope_name>`.
           def scope?(name) = scopes.include?(name.to_s)
 
-          # `validations` is `Array<attribute_name>` covering
-          # both `validates :name, ...` and the
+          # `validations` is `Array<attribute_name>` covering both `validates :name, ...` and the
           # `validates_*_of :name, ...` shorthand families.
           def validation?(name) = validations.include?(name.to_s)
           def validated_attributes = validations
@@ -80,8 +67,8 @@ module Rigor
           # `callbacks` is `Array<{ name:, callback: }>`.
           def callback_targets = callbacks.map { |c| c[:name] }
 
-          # `aliases` is `Hash<alias_name => target_attribute>`
-          # populated from `alias_attribute` declarations.
+          # `aliases` is `Hash<alias_name => target_attribute>` populated from `alias_attribute`
+          # declarations.
           def alias?(name) = aliases.key?(name.to_s)
           def resolve_alias(name) = aliases[name.to_s]
         end
@@ -106,17 +93,14 @@ module Rigor
 
           entries = model_rows.each_with_object({}) do |row, acc|
             class_name = row.fetch(:class_name)
-            # The STI ancestry chain, root → self. For a plain
-            # (non-STI) model this is just `[row]`.
+            # The STI ancestry chain, root → self. For a plain (non-STI) model this is just `[row]`.
             chain = sti_chain(row, rows_by_name)
             table_name = sti_table_name(chain)
             columns = schema_table.columns_for(table_name) || []
 
-            # STI children inherit their ancestors' declared
-            # associations / enums / aliases / scopes /
-            # validations / callbacks. Without the merge a
-            # `where(<parent-association>: ...)` on the child
-            # would surface as a false `unknown-column`.
+            # STI children inherit their ancestors' declared associations / enums / aliases / scopes /
+            # validations / callbacks. Without the merge a `where(<parent-association>: ...)` on the
+            # child would surface as a false `unknown-column`.
             acc[class_name] = Entry.new(
               class_name: class_name,
               table_name: table_name,
@@ -132,8 +116,8 @@ module Rigor
           new(entries.freeze)
         end
 
-        # The STI ancestry chain for a row, ordered root → self.
-        # Walks `sti_parent` pointers, guarding against a cycle.
+        # The STI ancestry chain for a row, ordered root → self. Walks `sti_parent` pointers, guarding
+        # against a cycle.
         def self.sti_chain(row, rows_by_name, seen = [])
           class_name = row.fetch(:class_name)
           parent_name = row[:sti_parent]
@@ -145,9 +129,8 @@ module Rigor
           sti_chain(parent, rows_by_name, seen + [class_name]) + [row]
         end
 
-        # The effective table name for an STI chain: the nearest
-        # explicit `self.table_name =` override walking leaf →
-        # root, else the name inflected from the root class.
+        # The effective table name for an STI chain: the nearest explicit `self.table_name =` override
+        # walking leaf → root, else the name inflected from the root class.
         def self.sti_table_name(chain)
           chain.reverse_each do |row|
             override = row[:table_name_override]
@@ -156,18 +139,16 @@ module Rigor
           Rigor::Plugin::Inflector.tableize(strip_leading_namespace(chain.first.fetch(:class_name)))
         end
 
-        # Dedups association-style rows by `:name`, keeping the
-        # LAST occurrence so a child redeclaration overrides the
-        # inherited ancestor row.
+        # Dedups association-style rows by `:name`, keeping the LAST occurrence so a child redeclaration
+        # overrides the inherited ancestor row.
         def self.merge_named_rows(rows)
           seen = {}
           rows.each { |row| seen[row[:name]] = row }
           seen.values.map(&:freeze).freeze
         end
 
-        # `Hash<column => Array<value>>` merged across the STI
-        # chain; a child redeclaration of the same enum column
-        # overrides the ancestor's value list.
+        # `Hash<column => Array<value>>` merged across the STI chain; a child redeclaration of the same
+        # enum column overrides the ancestor's value list.
         def self.merge_enums(chain)
           chain.each_with_object({}) do |row, acc|
             (row[:enums] || {}).each { |col, values| acc[col] = Array(values).map(&:freeze).freeze }
@@ -181,10 +162,8 @@ module Rigor
           end.freeze
         end
 
-        # `::User` → `User`. The discoverer might prefix with
-        # `::` for top-level constants depending on how it
-        # resolved the path; the table-name derivation uses the
-        # short form regardless.
+        # `::User` → `User`. The discoverer might prefix with `::` for top-level constants depending on
+        # how it resolved the path; the table-name derivation uses the short form regardless.
         def self.strip_leading_namespace(name)
           name.start_with?("::") ? name[2..] : name
         end

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

@@ -21,30 +21,23 @@ module Rigor
       #     end
       #   end
       #
-      # `t.references "x"` becomes an `x_id` integer column
-      # (foreign-key indices and constraints are ignored — only the
-      # column shape matters for type inference); add a `polymorphic:
-      # true` option and an `x_type` string column is emitted too.
-      # `t.timestamps` adds `created_at` and `updated_at` datetime
-      # columns. `t.column "x", :type` is the generic column form.
-      # Any other `t.<method> "name"` call is treated as a column
-      # whose type symbol is the method name — unknown types degrade
-      # to `Object` per `SchemaTable.ruby_type_for` rather than being
-      # dropped. Only the structural calls in {NON_COLUMN_METHODS}
-      # (indexes, constraints, foreign keys) are skipped.
+      # `t.references "x"` becomes an `x_id` integer column (foreign-key indices and constraints are
+      # ignored — only the column shape matters for type inference); add a `polymorphic: true` option and
+      # an `x_type` string column is emitted too. `t.timestamps` adds `created_at` and `updated_at`
+      # datetime columns. `t.column "x", :type` is the generic column form. Any other `t.<method> "name"`
+      # call is treated as a column whose type symbol is the method name — unknown types degrade to
+      # `Object` per `SchemaTable.ruby_type_for` rather than being dropped. Only the structural calls in
+      # {NON_COLUMN_METHODS} (indexes, constraints, foreign keys) are skipped.
       #
-      # Designed for the Prism interpretation pattern from
-      # rigor-lisp-eval — recursive descent on the AST, no eval.
+      # Designed for the Prism interpretation pattern from rigor-lisp-eval — recursive descent on the AST,
+      # no eval.
       class SchemaParser
         TIMESTAMPS_COLUMNS = %w[created_at updated_at].freeze
 
-        # Structural `t.<method>` calls inside a `create_table`
-        # block that declare indexes / constraints rather than
-        # columns. Everything NOT in this set that carries a
-        # literal column name is treated as a column declaration
-        # so a real column is never silently dropped — a dropped
-        # column turns every query against it into a false
-        # `unknown-column` diagnostic.
+        # Structural `t.<method>` calls inside a `create_table` block that declare indexes / constraints
+        # rather than columns. Everything NOT in this set that carries a literal column name is treated as
+        # a column declaration so a real column is never silently dropped — a dropped column turns every
+        # query against it into a false `unknown-column` diagnostic.
         NON_COLUMN_METHODS = %i[
           index check_constraint exclusion_constraint
           unique_constraint foreign_key primary_keys
@@ -114,10 +107,9 @@ module Rigor
           false
         end
 
-        # Walks the block body collecting `t.<method>(...)` calls.
-        # Skips nested blocks (e.g. inside `if`-conditioned columns)
-        # only at the top level — for richer schema constructs the
-        # parser falls back silently.
+        # Walks the block body collecting `t.<method>(...)` calls. Skips nested blocks (e.g. inside
+        # `if`-conditioned columns) only at the top level — for richer schema constructs the parser falls
+        # back silently.
         def collect_column_calls(node, &)
           return if node.nil?
 
@@ -139,13 +131,11 @@ module Rigor
           when :column
             parse_generic_column(call_node)
           else
-            # Structural DSL call (index / constraint / FK) —
-            # not a column.
+            # Structural DSL call (index / constraint / FK) — not a column.
             return nil if NON_COLUMN_METHODS.include?(method)
 
-            # Any other `t.<method> "name"` is a column. The
-            # method name is the type symbol; unknown types
-            # degrade to `Object` rather than dropping the column.
+            # Any other `t.<method> "name"` is a column. The method name is the type symbol; unknown
+            # types degrade to `Object` rather than dropping the column.
             parse_typed_column(method, call_node)
           end
         end
@@ -162,11 +152,9 @@ module Rigor
           )
         end
 
-        # `t.references "x"` adds an `x_id` integer column.
-        # `t.references "x", polymorphic: true` additionally adds
-        # an `x_type` string column — without it every
-        # `where(x_type: ...)` on the polymorphic owner surfaces
-        # as a false `unknown-column`.
+        # `t.references "x"` adds an `x_id` integer column. `t.references "x", polymorphic: true`
+        # additionally adds an `x_type` string column — without it every `where(x_type: ...)` on the
+        # polymorphic owner surfaces as a false `unknown-column`.
         def parse_references_column(call_node)
           name = string_argument(call_node, 0)
           return nil if name.nil?
@@ -184,10 +172,9 @@ module Rigor
           keyword_true?(call_node, :polymorphic)
         end
 
-        # Returns true iff `call_node` has a `name: true` keyword
-        # argument. Used to detect schema modifiers like
-        # `t.bigint "status_ids", array: true` (Postgres array
-        # column) and `t.references "x", polymorphic: true`.
+        # Returns true iff `call_node` has a `name: true` keyword argument. Used to detect schema
+        # modifiers like `t.bigint "status_ids", array: true` (Postgres array column) and `t.references
+        # "x", polymorphic: true`.
         def keyword_true?(call_node, name)
           return false if call_node.arguments.nil?
 
@@ -204,9 +191,8 @@ module Rigor
           false
         end
 
-        # `t.column "name", "type"` / `t.column "name", :type` —
-        # the explicit generic column form. The type lives in the
-        # second argument; an absent type degrades to `:string`.
+        # `t.column "name", "type"` / `t.column "name", :type` — the explicit generic column form. The
+        # type lives in the second argument; an absent type degrades to `:string`.
         def parse_generic_column(call_node)
           name = string_argument(call_node, 0)
           return nil if name.nil?

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

@@ -3,18 +3,15 @@
 module Rigor
   module Plugin
     class Activerecord < Rigor::Plugin::Base
-      # Parsed `db/schema.rb`. Maps each table name to its column
-      # set; each column carries its declared type. Marshal-clean
-      # by construction so the cache producer can round-trip it
-      # without a custom serialize / deserialize pair.
+      # Parsed `db/schema.rb`. Maps each table name to its column set; each column carries its declared
+      # type. Marshal-clean by construction so the cache producer can round-trip it without a custom
+      # serialize / deserialize pair.
       #
-      # The mapping from Rails column types to Ruby class names is
-      # deliberately conservative — `:string`/`:text` → `String`,
-      # `:integer`/`:bigint` → `Integer`, `:boolean` → `bool`,
-      # `:datetime`/`:timestamp` → `Time`, `:date` → `Date`,
-      # `:decimal`/`:float` → `Float`. Exotic types (json, jsonb,
-      # ltree, hstore, custom) fall back to `Object` so the
-      # plugin stays silent rather than guessing.
+      # The mapping from Rails column types to Ruby class names is deliberately conservative —
+      # `:string`/`:text` → `String`, `:integer`/`:bigint` → `Integer`, `:boolean` → `bool`,
+      # `:datetime`/`:timestamp` → `Time`, `:date` → `Date`, `:decimal`/`:float` → `Float`. Exotic types
+      # (json, jsonb, ltree, hstore, custom) fall back to `Object` so the plugin stays silent rather than
+      # guessing.
       class SchemaTable
         Column = Struct.new(:name, :type, :ruby_type, :array, keyword_init: true) do
           def to_h = { name: name, type: type, ruby_type: ruby_type, array: array }
@@ -40,21 +37,17 @@ module Rigor
           binary: "String",
           json: "Object",
           jsonb: "Object",
-          # PostgreSQL-flavoured string-ish column types Rails
-          # schemas commonly carry. `uuid` / `citext` / `inet`
-          # all behave as `String` for query purposes; mapping
-          # them here keeps the column out of the "unknown type
-          # → dropped column → false unknown-column" path.
+          # PostgreSQL-flavoured string-ish column types Rails schemas commonly carry. `uuid` / `citext` /
+          # `inet` all behave as `String` for query purposes; mapping them here keeps the column out of
+          # the "unknown type → dropped column → false unknown-column" path.
           uuid: "String",
           citext: "String",
           inet: "String"
         }.freeze
 
-        # Implicit columns that every Rails table has unless the
-        # schema explicitly opts out. The plugin assumes these
-        # exist; users who run `create_table id: false` get no
-        # implicit `id` column from the parser, but most apps
-        # never disable it.
+        # Implicit columns that every Rails table has unless the schema explicitly opts out. The plugin
+        # assumes these exist; users who run `create_table id: false` get no implicit `id` column from
+        # the parser, but most apps never disable it.
         IMPLICIT_COLUMNS = [
           Column.new(name: "id", type: :integer, ruby_type: "Integer").freeze
         ].freeze
@@ -86,9 +79,8 @@ module Rigor
 
         def table_names = tables.keys
 
-        # Maps a Rails column type symbol to its Ruby class name.
-        # Returns "Object" for unknown types — the analyzer treats
-        # that as "do not narrow" (silent on unknowns).
+        # Maps a Rails column type symbol to its Ruby class name. Returns "Object" for unknown types —
+        # the analyzer treats that as "do not narrow" (silent on unknowns).
         def self.ruby_type_for(column_type)
           RUBY_TYPE_MAPPING.fetch(column_type.to_sym, "Object")
         end