rigortype 0.2.7 → 0.2.9

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
@@ -101,22 +88,20 @@ module Rigor
         def class_names = entries.keys
         def empty? = entries.empty?
 
-        def self.build(model_rows:, schema_table:)
+        def self.build(model_rows:, schema_table:, type_override_columns: nil)
           rows_by_name = model_rows.to_h { |row| [row.fetch(:class_name), row] }
+          overrides = type_override_columns || []
 
           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) || []
+            columns = apply_type_overrides(schema_table.columns_for(table_name) || [], overrides)
 
-            # 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 +117,25 @@ module Rigor
           new(entries.freeze)
         end
 
-        # The STI ancestry chain for a row, ordered root → self.
-        # Walks `sti_parent` pointers, guarding against a cycle.
+        # Remaps every type-overridden column's `ruby_type` to `"Object"` so instance-side column narrowing
+        # declines to narrow it (the `"Object"` case in `ruby_type_to_type`). A `serialize` / `mount_uploader`
+        # / custom-`attribute` column reads as a rich object at runtime, not its SQL scalar, so narrowing it
+        # to e.g. `String` false-positives on the object's methods (`note.position.diff_refs`). The column
+        # stays in the set, so `where(col: ...)` existence validation is unaffected — only its value type.
+        def self.apply_type_overrides(columns, overrides)
+          return columns if overrides.empty?
+
+          columns.map do |column|
+            next column unless overrides.include?(column.name)
+
+            SchemaTable::Column.new(
+              name: column.name, type: column.type, ruby_type: "Object", array: column.array
+            )
+          end
+        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]
@@ -145,9 +147,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 +157,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 +180,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

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "schema_table"
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # Parses a PostgreSQL `db/structure.sql` (the `schema_format = :sql` schema dump) into the same
+      # {SchemaTable} the Ruby-DSL {SchemaParser} produces, so a project that commits `structure.sql`
+      # instead of `schema.rb` is no longer inert (GitLab-class apps use `structure.sql`; without this the
+      # plugin skips every AR call check and — worse — degrades ordinary relation chains to `Array`,
+      # cascading false diagnostics).
+      #
+      # The dump is regular enough to read line-by-line without a SQL parser. `pg_dump` emits, per table:
+      #
+      #   CREATE TABLE namespaces (
+      #       id bigint NOT NULL,
+      #       name character varying NOT NULL,
+      #       visibility_level integer DEFAULT 20 NOT NULL,
+      #       tag_ids bigint[],
+      #       created_at timestamp without time zone
+      #   );
+      #
+      # Load-bearing regularities this relies on: column names / types are lowercase, column modifiers
+      # (`NOT NULL`, `DEFAULT …`, `GENERATED …`, `COLLATE …`) are UPPERCASE, one column per line, the body
+      # closes on a line starting with `)`. So the type is the run of tokens before the first
+      # uppercase-initial token, and a table-level constraint line (`CONSTRAINT …`, `PRIMARY KEY …`) is
+      # recognised by its uppercase leading keyword and skipped. Anything it cannot map (custom enum,
+      # `tsvector`, `ltree`) degrades to `Object` via {SchemaTable.ruby_type_for} — never a dropped column,
+      # which would turn every query on it into a false `unknown-column`.
+      class StructureSqlParser
+        # Normalised PostgreSQL type (lowercased, length/precision + `[]` stripped) → the Rails column-type
+        # symbol {SchemaTable.ruby_type_for} already understands. Unmapped types fall through to their own
+        # symbol, which `ruby_type_for` maps to `Object` (the safe "do not narrow" default).
+        PG_TYPE_TO_RAILS = {
+          "bigint" => :bigint, "int8" => :bigint, "bigserial" => :bigint,
+          "integer" => :integer, "int" => :integer, "int4" => :integer, "serial" => :integer,
+          "smallint" => :integer, "int2" => :integer, "smallserial" => :integer,
+          "boolean" => :boolean, "bool" => :boolean,
+          "text" => :text,
+          "character varying" => :string, "varchar" => :string,
+          "character" => :string, "char" => :string, "name" => :string, "citext" => :citext,
+          "timestamp without time zone" => :datetime, "timestamp with time zone" => :datetime,
+          "timestamp" => :datetime, "timestamptz" => :datetime,
+          "date" => :date,
+          "time without time zone" => :time, "time with time zone" => :time, "time" => :time,
+          "numeric" => :decimal, "decimal" => :decimal, "money" => :decimal,
+          "double precision" => :float, "real" => :float, "float8" => :float, "float4" => :float,
+          "bytea" => :binary,
+          "json" => :json, "jsonb" => :jsonb,
+          "uuid" => :uuid, "inet" => :inet, "cidr" => :string, "macaddr" => :string
+        }.freeze
+
+        # Uppercase leading keywords that mark a table-level constraint line rather than a column.
+        CONSTRAINT_KEYWORDS = %w[CONSTRAINT PRIMARY UNIQUE CHECK FOREIGN EXCLUDE LIKE PARTITION].freeze
+
+        # @param source [String] contents of `db/structure.sql`
+        # @return [SchemaTable]
+        def self.parse(source)
+          new.parse(source)
+        end
+
+        def parse(source)
+          tables = {}
+          each_create_table(source.to_s) do |table_name, body_lines|
+            columns = parse_columns(body_lines)
+            tables[table_name] = columns unless columns.empty?
+          end
+          SchemaTable.new(tables.freeze)
+        end
+
+        private
+
+        # Yields `[table_name, body_lines]` for every `CREATE TABLE … (` … `)` block. Body lines are the raw
+        # lines between the opening `(` line and the closing `)` line.
+        def each_create_table(source)
+          lines = source.lines
+          index = 0
+          while index < lines.length
+            match = lines[index].match(/\ACREATE (?:UNLOGGED |TEMPORARY )?TABLE (?:IF NOT EXISTS )?(\S+)\s*\(/)
+            unless match
+              index += 1
+              next
+            end
+
+            table_name = normalize_table_name(match[1])
+            index += 1
+            body = []
+            while index < lines.length && lines[index] !~ /\A\s*\)/
+              body << lines[index]
+              index += 1
+            end
+            yield(table_name, body) if table_name
+            index += 1 # step past the closing `)` line
+          end
+        end
+
+        # Strips quotes and a leading schema qualifier. Only the default `public` schema (or an unqualified
+        # name) is accepted; other schemas (`gitlab_partitions_dynamic.*`, etc.) are partitions of a base
+        # table already emitted unqualified, so returning nil skips them without losing a real table.
+        def normalize_table_name(raw)
+          name = raw.delete('"')
+          if name.include?(".")
+            schema, table = name.split(".", 2)
+            return nil unless schema == "public"
+
+            name = table
+          end
+          name.empty? ? nil : name
+        end
+
+        def parse_columns(body_lines)
+          columns = {}
+          # A column's `DEFAULT` may carry a multi-line single-quoted string (a serialized YAML default,
+          # `DEFAULT '--- []\n'::character varying`). The column name + type sit before the `DEFAULT`, so
+          # the first physical line still parses correctly; the continuation lines must be skipped or they
+          # read as bogus columns (`'::character varying`). A line with an ODD count of single quotes opens
+          # (or closes) such a string — PG doubles a literal quote (`''`), so escapes stay even and only a
+          # genuinely unterminated string toggles the state.
+          in_string = false
+          body_lines.each do |raw|
+            if in_string
+              in_string = false if raw.count("'").odd?
+              next
+            end
+            in_string = true if raw.count("'").odd?
+
+            line = raw.strip.chomp(",")
+            next if line.empty?
+
+            name, rest = line.split(/\s+/, 2)
+            next if name.nil? || rest.nil?
+            next if CONSTRAINT_KEYWORDS.include?(name) # a table-level constraint, not a column
+
+            column = build_column(name.delete('"'), rest)
+            columns[column.name] = column if column
+          end
+          columns.freeze
+        end
+
+        def build_column(name, rest)
+          type_str, array = extract_type(rest)
+          return nil if type_str.empty?
+
+          rails_type = PG_TYPE_TO_RAILS.fetch(type_str, type_str.to_sym)
+          SchemaTable::Column.new(
+            name: name,
+            type: rails_type,
+            ruby_type: SchemaTable.ruby_type_for(rails_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?]`.
+        def extract_type(rest)
+          type_tokens = []
+          rest.split(/\s+/).each do |token|
+            break if token.match?(/\A[A-Z]/)
+
+            type_tokens << token
+          end
+          type_str = type_tokens.join(" ")
+          array = type_str.include?("[]")
+          type_str = type_str.gsub("[]", "").gsub(/\([0-9,\s]*\)/, "").strip.downcase
+          [type_str, array]
+        end
+      end
+    end
+  end
+end