rigortype 0.4.7 → 0.4.8

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/view_assigns.rb

@@ -22,7 +22,7 @@ module Rigor
       # `last!`, `new`, `create`, `create!`. A seeded type is a claim the engine acts on, and a wrong one
       # is worse than none: seeding `@user` from `find_by` (which returns nil at runtime) would hand the
       # flow rules a non-nil nominal and license folds that draw diagnostics on correct templates — the
-      # trap `Actionpack::STRONG_PARAMS_CHAIN_METHODS` documents at length for `Parameters#[]`. Anything
+      # trap `Actionpack::PARAMS_ONLY_CHAIN_METHODS` documents at length for `Parameters#[]`. Anything
       # else assigns nothing, the ivar stays unseeded, and the template reads it as `Dynamic`, which
       # taints honestly (ADR-5). A call on that list that returns, or may return, SEVERAL records —
       # `find(a, b)`, `find([1, 2])`, `create([{…}, {…}])` — is excluded by the same rule; see
@@ -228,7 +228,7 @@ module Rigor
           # `case`, a `rescue`, a loop, or a block that may not run — does not contribute, because a seed
           # is a claim about what the template will FIND, and `@user = User.find(1) if params[:pick]`
           # leaves `@user` nil on the other path. A non-nil nominal standing in for a runtime nil is the
-          # `Parameters#[]` trap (`Actionpack::STRONG_PARAMS_CHAIN_METHODS`): the flow rules act on it and
+          # `Parameters#[]` trap (`Actionpack::PARAMS_ONLY_CHAIN_METHODS`): the flow rules act on it and
           # report live branches, which is exactly what a reader of a template would see with
           # `view_type_checks:` on. The unseeded ivar reads `Dynamic` instead and taints honestly (ADR-5).
           #

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

@@ -473,21 +473,21 @@ module Rigor
       # `ActionController::Parameters` (above), but the chained `params.require(:user).permit(:name)` /
       # `params.permit(...)` calls returned `Dynamic` at the first hop (Parameters ships no bundled RBS,
       # so a call on it resolves lenient-to-Dynamic), leaking every downstream site (`.permit`, `.to_h`,
-      # `.each`) to unprotected. These methods return another `Parameters`, so gate on a
-      # `Parameters` receiver and re-type the result as the same lenient nominal — the chain stays a
-      # concrete receiver end-to-end and `coverage --protection` counts the sites as protected.
-      #
-      # `require` may return a scalar for a flat key at runtime (`params.require(:id) → String`), but
-      # typing it as the RBS-less `Parameters` is FP-safe by the same argument as the readers: every
-      # method on a Parameters value stays engine-lenient (no `undefined-method`), and this types the
-      # container only, never a caller's argument (ADR-5). The GitLab strong-params survey (108 leaked
-      # `.permit` sites) is the demand.
-      # Issue #534 — `expect` (Rails 8's require+permit) and `slice` joined 2026-09-01, from the corpus
-      # sweep's pair counts (63 and 38 sites on mastodon). Both share `require`'s safety shape: they
-      # never return nil (`expect` raises like `require`; `slice` always returns a Parameters), so the
-      # non-nil lenient nominal cannot fold a flow rule wrong.
-      #
-      # ## The admission rule for this table
+      # `.each`) to unprotected. The methods that return another `Parameters` (`PARAMS_ONLY_CHAIN_METHODS`)
+      # gate on a `Parameters` receiver and re-type the result as the same
+      # lenient nominal — the sites after them stay concrete receivers and `coverage --protection` counts
+      # them as protected. `require` / `expect` are the exception below: the receiver of the call right
+      # after one is the carrier, which is not a concrete receiver.
+      #
+      # `require` and `expect` may return a scalar at runtime (`params.require(:id) → String`), so the
+      # earlier "RBS-less nominal is FP-safe" reading of them (2026-07, #534) is withdrawn by #2947: it held
+      # only while Parameters shipped no RBS. Once the collection's declaration is loaded, a nominal answer
+      # reports a scalar's method as `call.undefined-method`. They answer the gradual carrier
+      # `Dynamic[Parameters]` (`SCALAR_CAPABLE_CHAIN_METHODS`), which keeps the chain resolvable and is quiet
+      # with or without the RBS. The GitLab strong-params survey (108 leaked `.permit` sites) is the demand.
+      # Issue #534 — `expect` and `slice` joined 2026-09-01 (63 and 38 sites on mastodon).
+      #
+      # ## The admission rule for the nominal table (`PARAMS_ONLY_CHAIN_METHODS`)
       #
       # A method belongs here **iff its Rails implementation returns an `ActionController::Parameters`
       # on every path** — either a fresh `new_instance_with_inherited_permitted_status(...)` or `self`.
@@ -564,27 +564,56 @@ module Rigor
       # hazard ever returns — and they now carry a positive assertion that `params[:k]` types
       # `Dynamic[ActionController::Parameters?]` (#2430), so a silent regression to bare `Dynamic[top]`
       # or to the non-nil nominal fails them too.
-      STRONG_PARAMS_CHAIN_METHODS = %i[
-        require permit permit! expect slice
+      # The links that return an `ActionController::Parameters` on every path (checked against Rails 8.x
+      # `strong_parameters.rb`). Only these may be typed as the nominal.
+      PARAMS_ONLY_CHAIN_METHODS = %i[
+        permit permit! slice
         except without extract! slice!
         merge merge! reverse_merge reverse_merge! with_defaults with_defaults!
         compact compact_blank deep_dup
       ].freeze
 
-      dynamic_return receivers: [REQUEST_CONTEXT_READER_TYPES[:params]], methods: STRONG_PARAMS_CHAIN_METHODS do |call_node, _scope|
+      # Issue #2947 — `require` and `expect` are NOT in the nominal table above. Rails returns the value itself:
+      # `require` is `self[key]` (a scalar, or an Array for an Array of keys) and `expect` is `values.first`
+      # for one key, else an Array. The "RBS-less nominal is lenient" argument holds only while Parameters
+      # ships no RBS; with the collection's declaration loaded, a nominal answer reports `.to_sym` on a
+      # scalar as `call.undefined-method`. They answer the gradual carrier `Dynamic[Parameters]` instead:
+      # quiet at every boundary, and the chain keeps resolving through the carrier-gated rule.
+      SCALAR_CAPABLE_CHAIN_METHODS = %i[require expect].freeze
+
+      STRONG_PARAMS_CHAIN_METHODS = (PARAMS_ONLY_CHAIN_METHODS + SCALAR_CAPABLE_CHAIN_METHODS).freeze
+
+      dynamic_return receivers: [REQUEST_CONTEXT_READER_TYPES[:params]], methods: PARAMS_ONLY_CHAIN_METHODS do |call_node, _scope|
         next nil unless call_node.is_a?(Prism::CallNode)
 
         Rigor::Type::Combinator.nominal_of(REQUEST_CONTEXT_READER_TYPES[:params])
       end
 
-      # Issue #2430 — the chain on a `params[...]` carrier (`params[:user].permit(:name)`). The result stays
-      # a `Dynamic` of the same nominal, so it crosses a declared boundary as the carrier does.
+      dynamic_return receivers: [REQUEST_CONTEXT_READER_TYPES[:params]], methods: SCALAR_CAPABLE_CHAIN_METHODS do |call_node, _scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+
+        Rigor::Type::Combinator.dynamic(Rigor::Type::Combinator.nominal_of(REQUEST_CONTEXT_READER_TYPES[:params]))
+      end
+
+      # Issue #2430 / #2947 — the chain on a carrier receiver (`params[:user].permit(:name)`,
+      # `params.require(:user).permit(:name)`). A carrier often holds an Array or a String at runtime, and
+      # those define many of the chain names with other returns (`compact`, `slice`, `without`, `deep_dup`,
+      # `extract!`, ...), so only `permit` / `permit!` — which no core or ActiveSupport class defines — can
+      # answer the plain nominal there: such a call raises NoMethodError or returns a real Parameters, and
+      # the plain nominal keeps the sites after it concrete receivers for `coverage --protection`. Every
+      # other chain method stays the gradual carrier.
+      CARRIER_NOMINAL_CHAIN_METHODS = %i[permit permit!].freeze
+
       dynamic_return methods: STRONG_PARAMS_CHAIN_METHODS do |call_node, scope|
-        next nil unless call_node.is_a?(Prism::CallNode) && call_node.receiver
+        next nil unless call_node.is_a?(Prism::CallNode)
+
+        receiver = call_node.receiver
+        next nil unless receiver
         next nil unless controller_scope?(scope)
-        next nil unless params_carrier_facet?(scope.type_of(call_node.receiver))
+        next nil unless params_carrier_facet?(scope.type_of(receiver))
 
-        Rigor::Type::Combinator.dynamic(Rigor::Type::Combinator.nominal_of(REQUEST_CONTEXT_READER_TYPES[:params]))
+        nominal = Rigor::Type::Combinator.nominal_of(REQUEST_CONTEXT_READER_TYPES[:params])
+        CARRIER_NOMINAL_CHAIN_METHODS.include?(call_node.name) ? nominal : Rigor::Type::Combinator.dynamic(nominal)
       end
 
       # Issue #534 item 1, reopened by #574. `#[]` is the single largest named-receiver pair on both survey
@@ -620,9 +649,12 @@ module Rigor
       # receiver. These two rules gate on the carrier's facet instead, and only inside a controller: a
       # carrier is minted by the `params` reader, which is controller-only, so no other scope can hold one.
       dynamic_return methods: %i[[]] do |call_node, scope|
-        next nil unless call_node.is_a?(Prism::CallNode) && call_node.receiver
+        next nil unless call_node.is_a?(Prism::CallNode)
+
+        receiver = call_node.receiver
+        next nil unless receiver
         next nil unless controller_scope?(scope)
-        next nil unless params_carrier_facet?(scope.type_of(call_node.receiver))
+        next nil unless params_carrier_facet?(scope.type_of(receiver))
 
         params_read_type
       end

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers.rb

@@ -161,9 +161,8 @@ module Rigor
       end
 
       def project_defines_object?(serializer_name, scope)
-        return false unless scope.respond_to?(:user_def_through_ancestors)
-
-        !scope.user_def_through_ancestors(serializer_name, :object).first.nil?
+        Rigor::Reflection.project_method_defined(serializer_name, :object, kind: :instance, source: :def,
+                                                                           scope: scope).yes?
       end
 
       # The model a serializer serializes, or nil where nothing corroborates it. Memoised per serializer
@@ -237,13 +236,11 @@ module Rigor
       # the check would decline nearly every real serializer. On the serializer side it is a base
       # serializer's own rendering method, which is not a read of the resource at all.
       def project_defines?(class_name, method_name, scope)
-        return false unless scope.respond_to?(:user_def_through_ancestors)
-
         # A name no Symbol can hold cannot be a method the project defines (#1831): decline, do not raise.
         method = Rigor::Source::SymbolName.of(method_name.to_s)
         return false if method.nil?
 
-        !scope.user_def_through_ancestors(class_name, method).first.nil?
+        Rigor::Reflection.project_method_defined(class_name, method, kind: :instance, source: :def, scope: scope).yes?
       end
 
       # `REST::AccountSerializer` offers two readings — the namespaced `REST::Account` and the

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

@@ -55,8 +55,24 @@ module Rigor
           )
         end
 
+        # Ruby binds a trailing `k: v` / `**opts` group to keyword parameters, never to positional ones, so
+        # when `#perform` takes keywords the group is not counted (the message's "got N" is then the
+        # positional count too). A job without keyword parameters keeps counting the group as one positional
+        # argument — `NoArgsJob.perform_later(name: 1)` raises at runtime. A `Hash` literal / local stays
+        # positional either way (Ruby 3 does not convert it).
+        #
+        # The call is declined (no report) when its shape is unknown: a `*splat` or `...` argument may supply
+        # any number of positionals (or a trailing keyword group), and a keyword group made only of `**opts`
+        # arguments sent to a job without keywords may be empty — declined only when the verdict differs
+        # between "empty" and "one positional hash" (`NoArgsJob.perform_later(**opts)`).
         def arity_violation(call_node, entry)
-          actual = (call_node.arguments&.arguments || []).size
+          args = call_node.arguments&.arguments || []
+          return nil if args.any? { |arg| arg.is_a?(Prism::SplatNode) || arg.is_a?(Prism::ForwardingArgumentsNode) }
+
+          keyword_group = args.last.is_a?(Prism::KeywordHashNode) ? args.last : nil
+          return nil if keyword_group && !entry.accepts_keywords && empty_group_decides?(args, keyword_group, entry)
+
+          actual = entry.accepts_keywords && keyword_group ? args.size - 1 : args.size
           return nil if entry.accepts?(actual)
 
           Violation.new(
@@ -66,6 +82,14 @@ module Rigor
           )
         end
 
+        # True when the group is only `**splat` arguments (so it may be empty) AND the entry's verdict changes
+        # between counting it and not counting it.
+        def empty_group_decides?(args, keyword_group, entry)
+          return false unless keyword_group.elements.all?(Prism::AssocSplatNode)
+
+          entry.accepts?(args.size - 1) != entry.accepts?(args.size)
+        end
+
         # Renders a constant-path receiver as a String. Mirrors the helpers in rigor-activerecord /
         # rigor-rails-routes for parity.
         def constant_receiver_name(node)

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

@@ -76,7 +76,8 @@ module Rigor
           base.with(
             min_arity: [base.min_arity, addition.min_arity].min,
             max_arity: [base.max_arity, addition.max_arity].max,
-            keyword_required: base.keyword_required & addition.keyword_required
+            keyword_required: base.keyword_required & addition.keyword_required,
+            accepts_keywords: base.accepts_keywords || addition.accepts_keywords
           )
         end
 
@@ -187,7 +188,7 @@ module Rigor
           if perform_def.nil?
             return JobIndex::Entry.new(
               class_name: class_name, min_arity: 0,
-              max_arity: Float::INFINITY, keyword_required: []
+              max_arity: Float::INFINITY, keyword_required: [], accepts_keywords: true
             )
           end
 
@@ -195,22 +196,31 @@ module Rigor
           if parameters.nil?
             return JobIndex::Entry.new(
               class_name: class_name, min_arity: 0,
-              max_arity: 0, keyword_required: []
+              max_arity: 0, keyword_required: [], accepts_keywords: false
             )
           end
 
-          required_count = (parameters.requireds || []).size
+          # Parameters after an optional or rest one (`def perform(a, b = 1, c)`) are required too.
+          required_count = (parameters.requireds || []).size + (parameters.posts || []).size
           optional_count = (parameters.optionals || []).size
           rest_present = !parameters.rest.nil?
           keyword_required = (parameters.keywords || []).filter_map do |kw|
             kw.name if kw.is_a?(Prism::RequiredKeywordParameterNode)
           end
 
+          keyword_rest = parameters.keyword_rest
+          # `...` lives in `keyword_rest` and forwards every argument, so it widens the envelope; `**nil`
+          # also lives there but declares that NO keywords are taken (ActiveJob then hands them over as a
+          # positional hash, exactly like a method with no keyword parameters).
+          forwards_all = keyword_rest.is_a?(Prism::ForwardingParameterNode)
+          takes_keywords = !(parameters.keywords || []).empty? || keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+
           JobIndex::Entry.new(
             class_name: class_name,
             min_arity: required_count,
-            max_arity: rest_present ? Float::INFINITY : required_count + optional_count,
-            keyword_required: keyword_required.map(&:to_sym)
+            max_arity: rest_present || forwards_all ? Float::INFINITY : required_count + optional_count,
+            keyword_required: keyword_required.map(&:to_sym),
+            accepts_keywords: takes_keywords || forwards_all
           )
         end
       end

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

@@ -10,9 +10,11 @@ module Rigor
       # `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).
+      # only (keyword name validation is deferred). `accepts_keywords` records whether `#perform` binds
+      # keywords at all (`k:`, `k: 1` or `**opts`), so the analyzer can keep a call's keyword arguments out
+      # of the positional count.
       class JobIndex
-        Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required) do
+        Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required, :accepts_keywords) do
           # 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

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

@@ -110,7 +110,8 @@ module Rigor
         # The predicate `Activerecord#finder_return_type` declines on, so the note and the type agree in a
         # CLI run. In an editor run this scope lacks the file's own methods (#1329).
         def own_find?(entry)
-          @scope.discovered_method_through_ancestors?(entry.class_name, :find, :singleton)
+          !Rigor::Reflection.project_method_defined(entry.class_name, :find, kind: :singleton, source: :discovered,
+                                                                             scope: @scope).no?
         end
 
         def validate_column_hash_call(node, entry)

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

@@ -31,10 +31,17 @@ module Rigor
       # `Object` per `SchemaTable.ruby_type_for` rather than being dropped. Only the structural calls in
       # {NON_COLUMN_METHODS} (indexes, constraints, foreign keys) are skipped.
       #
+      # `create_table "x", primary_key: "name"` adds that column, typed from the `id:` option when the call is
+      # read completely and untyped otherwise. `record.id` reads the primary key column's value, so the `id`
+      # column takes the same type; a composite or unreadable `primary_key:` leaves it untyped. `id: false` or
+      # `id: nil` removes it and adds neither.
+      #
       # 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
+        DEFAULT_PRIMARY_KEY_TYPE = :bigint
+        UNKNOWN_PRIMARY_KEY_TYPE = :unknown
 
         # 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
@@ -75,8 +82,10 @@ module Rigor
           return [nil, nil] if table_name.nil?
 
           block_node = call_node.block
-          columns = { "id" => SchemaTable::Column.new(name: "id", type: :integer, ruby_type: "Integer") }
+          columns = { "id" => implicit_id_column(call_node) }
           columns.delete("id") if id_disabled?(call_node)
+          primary_key = named_primary_key_column(call_node)
+          columns[primary_key.name] = primary_key if primary_key
 
           if block_node.is_a?(Prism::BlockNode) && block_node.body
             collect_column_calls(block_node.body) do |column_call|
@@ -92,20 +101,129 @@ module Rigor
           [table_name, columns.freeze]
         end
 
+        # `record.id` reads the primary key column's value, so the `id` reader takes the key's type — the
+        # same shape the `id:` option gives the column `primary_key:` names or the implicit `id` column.
+        # A composite `primary_key:` makes `id` an Array this parser does not type, and a `primary_key:`
+        # it cannot read leaves `id` untyped as well.
+        def implicit_id_column(call_node)
+          unless single_primary_key?(call_node)
+            return SchemaTable::Column.new(name: "id", type: UNKNOWN_PRIMARY_KEY_TYPE, ruby_type: "Object")
+          end
+
+          SchemaTable::Column.new(name: "id", **primary_key_shape(call_node))
+        end
+
+        # `primary_key:` names one key column when it is a String or Symbol literal; `nil` or `false` falls
+        # back to the default `id` column the way `primary_key || ...` does in Rails.
+        def single_primary_key?(call_node)
+          primary_key = keyword_value(call_node, :primary_key)
+          primary_key.nil? || primary_key.is_a?(Prism::NilNode) || primary_key.is_a?(Prism::FalseNode) ||
+            !literal_name(primary_key).nil?
+        end
+
         def id_disabled?(call_node)
-          return false if call_node.arguments.nil?
+          id = keyword_value(call_node, :id)
+          (id.is_a?(Prism::FalseNode) || id.is_a?(Prism::NilNode)) && keywords_read?(call_keywords(call_node))
+        end
+
+        # `create_table "settings", primary_key: "name", id: { type: :string }` creates the column `name`
+        # without the block declaring it, so the option is the only place the schema names it.
+        def named_primary_key_column(call_node)
+          return nil if id_disabled?(call_node)
+
+          name = literal_name(keyword_value(call_node, :primary_key))
+          return nil if name.nil?
+
+          SchemaTable::Column.new(name: name, **primary_key_shape(call_node))
+        end
+
+        # The `id:` option describes the primary key column's type whether the key column is `id` itself or
+        # the column `primary_key:` names. An unreadable call still yields a shape — the column stays
+        # queryable, just untyped.
+        def primary_key_shape(call_node)
+          id = keyword_value(call_node, :id)
+          options = id.is_a?(Prism::HashNode) ? id.elements : []
+          array = keyword_in(options, :array).is_a?(Prism::TrueNode)
+          unless primary_key_type_stated?(call_node, options)
+            return { type: UNKNOWN_PRIMARY_KEY_TYPE, ruby_type: "Object", array: array }
+          end
+
+          type = primary_key_type(id, options)
+          { type: type, ruby_type: primary_key_ruby_type(type), array: array }
+        end
+
+        # `id: :string` or `id: { type: :string, ... }`. `id: true` asks for the default key, as does an
+        # `id:` hash that names no `type:`. A type this parser cannot read as a literal is left unknown
+        # rather than assumed to be bigint.
+        def primary_key_type(id, options)
+          return DEFAULT_PRIMARY_KEY_TYPE if id.is_a?(Prism::TrueNode)
+
+          declared = id.is_a?(Prism::HashNode) ? keyword_in(options, :type) : id
+          return DEFAULT_PRIMARY_KEY_TYPE if declared.nil?
+
+          literal_name(declared)&.to_sym || UNKNOWN_PRIMARY_KEY_TYPE
+        end
+
+        # The key is typed only from a call this parser reads completely. `as:` is excluded because the query
+        # may define the column, and a non-literal `array:` because it decides the reader's shape.
+        def primary_key_type_stated?(call_node, options)
+          array = keyword_in(options, :array)
+          keywords_read?(call_keywords(call_node)) && keywords_read?(options) &&
+            keyword_value(call_node, :as).nil? &&
+            (array.nil? || array.is_a?(Prism::TrueNode) || array.is_a?(Prism::FalseNode))
+        end
+
+        def call_keywords(call_node)
+          call_node.arguments.arguments.grep(Prism::KeywordHashNode).flat_map(&:elements)
+        end
+
+        # Every element has a static Symbol key and no key repeats, so `keyword_in` sees what Ruby would pass.
+        def keywords_read?(elements)
+          keys = elements.map { |element| symbol_key(element.key) if element.is_a?(Prism::AssocNode) }
+          keys.none?(&:nil?) && keys.uniq.size == keys.size
+        end
+
+        # A decimal key stays untyped, because its class depends on the scale: `Type::DecimalWithoutScale`
+        # at scale 0, `Type::Decimal` otherwise.
+        def primary_key_ruby_type(type)
+          type == :decimal ? "Object" : SchemaTable.ruby_type_for(type)
+        end
+
+        # A `decimal` column's class follows its literal `scale:`. Any other type takes its SchemaTable mapping.
+        # A call this parser does not read completely may still hold a different scale, so it reads untyped.
+        def column_ruby_type(type, call_node)
+          return SchemaTable.ruby_type_for(type) unless type == :decimal
+          return "Object" unless keywords_read?(call_keywords(call_node))
+
+          scale = keyword_value(call_node, :scale)
+          SchemaTable.decimal_ruby_type(scale.is_a?(Prism::IntegerNode) ? scale.value : nil)
+        end
+
+        def literal_name(node)
+          case node
+          when Prism::StringNode, Prism::SymbolNode then node.unescaped
+          end
+        end
+
+        def keyword_value(call_node, name)
+          return nil if call_node.arguments.nil?
 
           call_node.arguments.arguments.each do |arg|
             next unless arg.is_a?(Prism::KeywordHashNode)
 
-            arg.elements.each do |pair|
-              next unless pair.is_a?(Prism::AssocNode)
+            value = keyword_in(arg.elements, name)
+            return value if value
+          end
+          nil
+        end
 
-              key = symbol_key(pair.key)
-              return true if key == :id && pair.value.is_a?(Prism::FalseNode)
-            end
+        def keyword_in(elements, name)
+          elements.each do |pair|
+            next unless pair.is_a?(Prism::AssocNode)
+
+            return pair.value if symbol_key(pair.key) == name
           end
-          false
+          nil
         end
 
         # Walks the block body collecting `t.<method>(...)` calls. It descends through nested constructs
@@ -147,7 +265,7 @@ module Rigor
           SchemaTable::Column.new(
             name: name,
             type: type,
-            ruby_type: SchemaTable.ruby_type_for(type),
+            ruby_type: column_ruby_type(type, call_node),
             array: keyword_true?(call_node, :array)
           )
         end
@@ -176,19 +294,7 @@ module Rigor
         # 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?
-
-          call_node.arguments.arguments.each do |arg|
-            next unless arg.is_a?(Prism::KeywordHashNode)
-
-            arg.elements.each do |pair|
-              next unless pair.is_a?(Prism::AssocNode)
-              next unless symbol_key(pair.key) == name
-
-              return pair.value.is_a?(Prism::TrueNode)
-            end
-          end
-          false
+          keyword_value(call_node, name).is_a?(Prism::TrueNode)
         end
 
         # `t.column "name", "type"` / `t.column "name", :type` — the explicit generic column form. The
@@ -202,7 +308,7 @@ module Rigor
           SchemaTable::Column.new(
             name: name,
             type: type_sym,
-            ruby_type: SchemaTable.ruby_type_for(type_sym),
+            ruby_type: column_ruby_type(type_sym, call_node),
             array: keyword_true?(call_node, :array)
           )
         end
@@ -216,13 +322,7 @@ module Rigor
         def string_argument(call_node, index)
           return nil if call_node.arguments.nil?
 
-          arg = call_node.arguments.arguments[index]
-          return nil if arg.nil?
-
-          case arg
-          when Prism::StringNode then arg.unescaped
-          when Prism::SymbolNode then arg.unescaped
-          end
+          literal_name(call_node.arguments.arguments[index])
         end
 
         def symbol_key(node)

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

@@ -9,9 +9,10 @@ module Rigor
       #
       # 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.
+      # `:datetime`/`:timestamp` → `Time`, `:date` → `Date`, `:float` → `Float`. A `:decimal` column's class
+      # follows its scale, so it is typed by {.decimal_ruby_type} from the parser that reads the scale, and
+      # reads `Object` here. 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 }
@@ -26,8 +27,11 @@ module Rigor
           text: "String",
           integer: "Integer",
           bigint: "Integer",
+          # PostgreSQL's dumper writes `id: :serial` / `t.serial` for a sequence-backed integer column.
+          serial: "Integer",
+          bigserial: "Integer",
           float: "Float",
-          decimal: "Float",
+          decimal: "Object",
           boolean: "bool",
           datetime: "Time",
           timestamp: "Time",
@@ -45,7 +49,7 @@ module Rigor
         }.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
+        # assumes these exist; users who run `create_table id: false` or `id: nil` 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
@@ -83,6 +87,17 @@ module Rigor
         def self.ruby_type_for(column_type)
           RUBY_TYPE_MAPPING.fetch(column_type.to_sym, "Object")
         end
+
+        # Maps a `decimal` column's scale to its Ruby class. Rails registers `Type::DecimalWithoutScale`
+        # (an Integer) at scale 0 and `Type::Decimal` (a BigDecimal) at any other scale. An absent or
+        # non-literal scale (`nil`) is left to the adapter, which decides it, so it reads as `Object`.
+        def self.decimal_ruby_type(scale)
+          case scale
+          when 0 then "Integer"
+          when Integer then "BigDecimal"
+          else "Object"
+          end
+        end
       end
     end
   end

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

@@ -138,21 +138,23 @@ module Rigor
         end
 
         def build_column(name, rest)
-          type_str, array = extract_type(rest)
+          type_str, array, scale = extract_type(rest)
           return nil if type_str.empty?
 
           rails_type = PG_TYPE_TO_RAILS.fetch(type_str, type_str.to_sym)
+          ruby_type = rails_type == :decimal ? SchemaTable.decimal_ruby_type(scale) : SchemaTable.ruby_type_for(rails_type)
           SchemaTable::Column.new(
             name: name,
             type: rails_type,
-            ruby_type: SchemaTable.ruby_type_for(rails_type),
+            ruby_type: ruby_type,
             array: array
           )
         end
 
         # The type is every token before the first uppercase-initial token (a column modifier such as
         # `NOT`, `NULL`, `DEFAULT`, `GENERATED`, `COLLATE`). A trailing `[]` marks a Postgres array column;
-        # a `(length[,scale])` specifier is dropped. Returns `[normalized_type, array?]`.
+        # a `(length[,scale])` specifier is dropped. Returns `[normalized_type, array?, scale]`, where `scale` is
+        # the literal second number of a `(precision, scale)` specifier, or nil when there is none.
         def extract_type(rest)
           type_tokens = []
           rest.split(/\s+/).each do |token|
@@ -162,8 +164,9 @@ module Rigor
           end
           type_str = type_tokens.join(" ")
           array = type_str.include?("[]")
+          scale = type_str[/\(\s*\d+\s*,\s*(\d+)\s*\)/, 1]&.to_i
           type_str = type_str.gsub("[]", "").gsub(/\([0-9,\s]*\)/, "").strip.downcase
-          [type_str, array]
+          [type_str, array, scale]
         end
       end
     end