rigortype 0.1.9 → 0.1.11

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # 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.
+      #
+      # `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.
+      class ModelIndex
+        # `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:`
+        #              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.
+        Entry = Struct.new(:class_name, :table_name, :columns, :associations,
+                           :enums, :scopes, :validations, :callbacks, :aliases,
+                           keyword_init: true) do
+          def column(name)
+            columns.find { |c| c.name == name.to_s }
+          end
+
+          def column?(name)
+            !column(name).nil?
+          end
+
+          def column_names = columns.map(&:name)
+
+          def association(name)
+            associations.find { |a| a[:name] == name.to_s }
+          end
+
+          def association?(name)
+            !association(name).nil?
+          end
+
+          def association_names = associations.map { |a| a[:name] }
+
+          # `enums` is `Hash<column_name => Array<value_name>>`.
+          def enum?(name) = enums.key?(name.to_s)
+          def enum_values(name) = enums.fetch(name.to_s, [])
+
+          # `scopes` is `Array<scope_name>`.
+          def scope?(name) = scopes.include?(name.to_s)
+
+          # `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
+
+          # `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.
+          def alias?(name) = aliases.key?(name.to_s)
+          def resolve_alias(name) = aliases[name.to_s]
+        end
+
+        attr_reader :entries
+
+        def initialize(entries)
+          @entries = entries.freeze
+          freeze
+        end
+
+        def find(class_name)
+          entries[class_name.to_s]
+        end
+
+        def model?(class_name) = entries.key?(class_name.to_s)
+        def class_names = entries.keys
+        def empty? = entries.empty?
+
+        def self.build(model_rows:, schema_table:)
+          rows_by_name = model_rows.to_h { |row| [row.fetch(:class_name), row] }
+
+          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]`.
+            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`.
+            acc[class_name] = Entry.new(
+              class_name: class_name,
+              table_name: table_name,
+              columns: columns.freeze,
+              associations: merge_named_rows(chain.flat_map { |r| Array(r[:associations]) }),
+              enums: merge_enums(chain),
+              scopes: chain.flat_map { |r| Array(r[:scopes]) }.uniq.freeze,
+              validations: chain.flat_map { |r| Array(r[:validations]) }.uniq.freeze,
+              callbacks: chain.flat_map { |r| Array(r[:callbacks]) }.map(&:freeze).freeze,
+              aliases: merge_aliases(chain)
+            ).freeze
+          end
+          new(entries.freeze)
+        end
+
+        # 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]
+          return [row] if parent_name.nil? || seen.include?(class_name)
+
+          parent = rows_by_name[parent_name]
+          return [row] if parent.nil?
+
+          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.
+        def self.sti_table_name(chain)
+          chain.reverse_each do |row|
+            override = row[:table_name_override]
+            return override if override
+          end
+          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.
+        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.
+        def self.merge_enums(chain)
+          chain.each_with_object({}) do |row, acc|
+            (row[:enums] || {}).each { |col, values| acc[col] = Array(values).map(&:freeze).freeze }
+          end.freeze
+        end
+
+        # `Hash<alias => target>` merged across the STI chain.
+        def self.merge_aliases(chain)
+          chain.each_with_object({}) do |row, acc|
+            (row[:aliases] || {}).each { |name, target| acc[name.to_s] = target.to_s }
+          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.
+        def self.strip_leading_namespace(name)
+          name.start_with?("::") ? name[2..] : name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # Walks a parsed `db/schema.rb` and produces a {SchemaTable}.
+      # Recognises the `create_table` DSL Rails generates:
+      #
+      #   ActiveRecord::Schema[8.0].define(version: ...) do
+      #     create_table "users", force: :cascade do |t|
+      #       t.string  "name", null: false
+      #       t.integer "age"
+      #       t.datetime "created_at"
+      #     end
+      #
+      #     create_table "posts" do |t|
+      #       t.text "body"
+      #       t.references "user", foreign_key: true   # adds user_id integer
+      #     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.
+      #
+      # 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.
+        NON_COLUMN_METHODS = %i[
+          index check_constraint exclusion_constraint
+          unique_constraint foreign_key primary_keys
+        ].freeze
+
+        # @param source [String] contents of `db/schema.rb`
+        # @return [SchemaTable]
+        def self.parse(source)
+          tree = Prism.parse(source).value
+          new.parse(tree)
+        end
+
+        def parse(node)
+          tables = {}
+          collect_create_table_calls(node) do |call_node|
+            table_name, columns = parse_create_table(call_node)
+            tables[table_name] = columns if table_name
+          end
+          SchemaTable.new(tables.freeze)
+        end
+
+        private
+
+        def collect_create_table_calls(node, &)
+          return if node.nil?
+
+          yield node if node.is_a?(Prism::CallNode) && node.name == :create_table && node.receiver.nil?
+
+          node.compact_child_nodes.each { |child| collect_create_table_calls(child, &) }
+        end
+
+        def parse_create_table(call_node)
+          table_name = string_argument(call_node, 0)
+          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.delete("id") if id_disabled?(call_node)
+
+          if block_node.is_a?(Prism::BlockNode) && block_node.body
+            collect_column_calls(block_node.body) do |column_call|
+              column = parse_column(column_call)
+              if column.is_a?(Array)
+                column.each { |c| columns[c.name] = c }
+              elsif column
+                columns[column.name] = column
+              end
+            end
+          end
+
+          [table_name, columns.freeze]
+        end
+
+        def id_disabled?(call_node)
+          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)
+
+              key = symbol_key(pair.key)
+              return true if key == :id && pair.value.is_a?(Prism::FalseNode)
+            end
+          end
+          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.
+        def collect_column_calls(node, &)
+          return if node.nil?
+
+          if node.is_a?(Prism::CallNode) && node.receiver.is_a?(Prism::LocalVariableReadNode)
+            yield node
+            return
+          end
+
+          node.compact_child_nodes.each { |child| collect_column_calls(child, &) }
+        end
+
+        def parse_column(call_node)
+          method = call_node.name
+          case method
+          when :references, :belongs_to
+            parse_references_column(call_node)
+          when :timestamps
+            parse_timestamps
+          when :column
+            parse_generic_column(call_node)
+          else
+            # 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.
+            parse_typed_column(method, call_node)
+          end
+        end
+
+        def parse_typed_column(type, call_node)
+          name = string_argument(call_node, 0)
+          return nil if name.nil?
+
+          SchemaTable::Column.new(
+            name: name,
+            type: type,
+            ruby_type: SchemaTable.ruby_type_for(type)
+          )
+        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`.
+        def parse_references_column(call_node)
+          name = string_argument(call_node, 0)
+          return nil if name.nil?
+
+          columns = [
+            SchemaTable::Column.new(name: "#{name}_id", type: :integer, ruby_type: "Integer")
+          ]
+          if references_polymorphic?(call_node)
+            columns << SchemaTable::Column.new(name: "#{name}_type", type: :string, ruby_type: "String")
+          end
+          columns
+        end
+
+        def references_polymorphic?(call_node)
+          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) == :polymorphic
+
+              return pair.value.is_a?(Prism::TrueNode)
+            end
+          end
+          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`.
+        def parse_generic_column(call_node)
+          name = string_argument(call_node, 0)
+          return nil if name.nil?
+
+          type = string_argument(call_node, 1)
+          type_sym = type ? type.to_sym : :string
+          SchemaTable::Column.new(
+            name: name,
+            type: type_sym,
+            ruby_type: SchemaTable.ruby_type_for(type_sym)
+          )
+        end
+
+        def parse_timestamps
+          TIMESTAMPS_COLUMNS.map do |name|
+            SchemaTable::Column.new(name: name, type: :datetime, ruby_type: "Time")
+          end
+        end
+
+        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
+        end
+
+        def symbol_key(node)
+          case node
+          when Prism::SymbolNode then node.unescaped.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # 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, keyword_init: true) do
+          def to_h = { name: name, type: type, ruby_type: ruby_type }
+        end
+
+        # Map ActiveRecord column types → Ruby class names.
+        RUBY_TYPE_MAPPING = {
+          string: "String",
+          text: "String",
+          integer: "Integer",
+          bigint: "Integer",
+          float: "Float",
+          decimal: "Float",
+          boolean: "bool",
+          datetime: "Time",
+          timestamp: "Time",
+          date: "Date",
+          time: "Time",
+          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.
+          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 = [
+          Column.new(name: "id", type: :integer, ruby_type: "Integer").freeze
+        ].freeze
+
+        attr_reader :tables
+
+        def initialize(tables)
+          @tables = tables.freeze
+          freeze
+        end
+
+        def column(table_name, column_name)
+          table = tables[table_name.to_s]
+          return nil if table.nil?
+
+          table[column_name.to_s]
+        end
+
+        def columns_for(table_name)
+          table = tables[table_name.to_s]
+          return nil if table.nil?
+
+          table.values
+        end
+
+        def table?(table_name)
+          tables.key?(table_name.to_s)
+        end
+
+        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).
+        def self.ruby_type_for(column_type)
+          RUBY_TYPE_MAPPING.fetch(column_type.to_sym, "Object")
+        end
+      end
+    end
+  end
+end