declare_schema 3.0.0 → 3.1.0.colin.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9bc6d7a94a1064cdeca883fbd1f40063771b12aff133925c1b83fcb83affebf
-  data.tar.gz: 6cc522f1d5b5bf855451e5985e8f8083ac610489625c71fdb9e1cb9d713ed751
+  metadata.gz: 1c6d94bcff3ece2896188d31c3e5cf4d66474ab4ef5082537037b9c037bfe364
+  data.tar.gz: fea64238065955c2a3b6a16f5d5f3ee1da5b65d09da8a808b5f11c66b575b602
 SHA512:
-  metadata.gz: f66aa50f211b7252ca146b72af859b90b5802025c99f2395379f0bdc7511b32b01918d56ed752edce00fdcfab17c47b2c218816581bd71ed148a026961e8fe54
-  data.tar.gz: d8b7b93ab90a18b3dda1ed6b19083b3f087aa8c35143e901247f9a44b67fac81f1c40be2e4d980fc4b38fcd29605912ee53a868451f3648ac9d210ae879c696f
+  metadata.gz: 675ddf024002056463139774a6cdca78f7b157f8de5e07978b945552858d462e3ba59284a42fe169f4395adb793ce4027207e272d721085c638987c49819a6cd
+  data.tar.gz: 667e85cc287311fa014a0729da207ec763749196b07a0692a746aaa5348e3f48d23fb18860b7ee0ce7a8b50b151a9003f0fb7f460e9b39ce5d14a72838adc0cd

data/CHANGELOG.md

@@ -4,6 +4,10 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.1.0] - Unreleased
+### Added
+- Add HABTM support for arbitrary primary key in the referenced table (rather than just :bigint). 
+
 ## [3.0.0] - 2025-04-08
 ### Changed
 - The `timestamps` DSL method to create `created_at` and `updated_at` columns now defaults to `null: false` for `datetime` columns

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (3.0.0)
+    declare_schema (3.1.0.colin.1)
       rails (>= 6.0)
 
 GEM

data/lib/declare_schema/extensions/active_record/fields_declaration.rb

@@ -3,7 +3,6 @@
 require 'active_record'
 require 'declare_schema/dsl'
 require 'declare_schema/model'
-require 'declare_schema/field_declaration_dsl'
 
 module DeclareSchema
   module Macros

data/lib/declare_schema/model/field_spec.rb

@@ -47,10 +47,6 @@ module DeclareSchema
       end
 
       def initialize(model, name, type, position: 0, **options)
-        _declared_primary_key = model._declared_primary_key
-
-        name.to_s == _declared_primary_key and raise ArgumentError, "you may not provide a field spec for the primary key #{name.inspect}"
-
         @model = model
         @name = name.to_sym
         type.is_a?(Symbol) or raise ArgumentError, "type must be a Symbol; got #{type.inspect}"
@@ -124,6 +120,10 @@ module DeclareSchema
         @sql_options = @options.slice(*SQL_OPTIONS)
       end
 
+      def foreign_key_field_spec(model, name, position: 0, null: nil)
+        self.class.new(model, name, @type, position:, **@options.merge(null.nil? ? {} : { null: }))
+      end
+
       # returns the attributes for schema migrations as a Hash
       # omits name and position since those are meta-data above the schema
       # omits keys with nil values

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -6,22 +6,28 @@ module DeclareSchema
       class << self
         def from_reflection(reflection)
           new(reflection.join_table,
-              [reflection.foreign_key, reflection.association_foreign_key],
-              [reflection.active_record.table_name, reflection.klass.table_name],
+              [
+                [reflection.foreign_key, reflection.active_record],
+                [reflection.association_foreign_key, reflection.klass]
+              ],
               connection: reflection.active_record.connection)
         end
       end
 
-      attr_reader :join_table, :foreign_keys, :parent_table_names, :connection
+      attr_reader :join_table, :foreign_keys, :parent_models, :parent_table_names, :connection
 
-      def initialize(join_table, foreign_keys, parent_table_names, connection:)
-        foreign_keys.is_a?(Array) && foreign_keys.size == 2 or
-          raise ArgumentError, "foreign_keys must be <Array[2]>; got #{foreign_keys.inspect}"
-        parent_table_names.is_a?(Array) && parent_table_names.size == 2 or
-          raise ArgumentError, "parent_table_names must be <Array[2]>; got #{parent_table_names.inspect}"
+      def initialize(join_table, parents, connection:)
         @join_table = join_table
-        @foreign_keys = foreign_keys.sort # Rails requires these be in alphabetical order
-        @parent_table_names = @foreign_keys == foreign_keys ? parent_table_names : parent_table_names.reverse # match the above sort
+
+        parents.is_a?(Array) && parents.size == 2 or
+          raise ArgumentError, "parents must be <Array[2]>; got #{parents.inspect}"
+
+        # Rails requires HABTM foreign keys to be in alphabetical order, so we start by sorting by those
+        parents.sort_by!(&:first)
+        @foreign_keys = parents.map(&:first)
+        @parent_models = parents.map(&:last)
+        @parent_table_names = parent_models.map(&:table_name)
+
         @connection = connection
       end
 
@@ -35,11 +41,12 @@ module DeclareSchema
 
       def field_specs
         foreign_keys.each_with_index.each_with_object({}) do |(foreign_key, i), result|
-          result[foreign_key] = ::DeclareSchema::Model::FieldSpec.new(self, foreign_key, :bigint, position: i, null: false)
+          result[foreign_key] = parent_models[i]._foreign_key_field_spec(self, foreign_key, position: i, null: false)
         end
       end
 
       def primary_key
+        # TODO: ActiveRecord now supports composite primary keys, so we could return that here.
         false # no single-column primary key in database
       end
 

data/lib/declare_schema/model.rb

@@ -100,6 +100,7 @@ module DeclareSchema
         _add_validations_for_field(name, type, args, options)
         _add_index_for_field(name, args, **options)
         _add_scopes_for_field(name, type, **options)
+        name.to_s == _declared_primary_key and raise ArgumentError, "no need to declare a field spec for the primary key #{name.inspect}"
         field_specs[name] = ::DeclareSchema::Model::FieldSpec.new(self, name, type, position: field_specs.size, **options)
         attr_order << name unless attr_order.include?(name)
       end
@@ -201,62 +202,44 @@ module DeclareSchema
         super
 
         reflection = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
-        foreign_key_column = reflection.foreign_key or raise "Couldn't find foreign_key for #{name} in #{reflection.inspect}"
-        foreign_key_column_options = column_options.dup
-
-        # Note: the foreign key limit: should match the primary key limit:. (If there is a foreign key constraint,
-        # those limits _must_ match.) We'd like to call _infer_fk_limit and get the limit right from the PK.
-        # But we can't here, because that will mess up the autoloader to follow every belongs_to association right
-        # when it is declared. So instead we assume :bigint (integer limit: 8) below, while also registering this
-        # pre_migration: callback to double-check that assumption Just In Time--right before we generate a migration.
-        #
-        # The one downside of this approach is that application code that asks the field_spec for the declared
-        # foreign key limit: will always get 8 back even if this is a grandfathered foreign key that points to
-        # a limit: 4 primary key. It seems unlikely that any application code would do this.
-        foreign_key_column_options[:pre_migration] = ->(field_spec) do
-          if (inferred_limit = _infer_fk_limit(foreign_key_column, reflection))
-            field_spec.sql_options[:limit] = inferred_limit
-          end
-        end
+        foreign_key_column_name = reflection.foreign_key or raise "Couldn't find foreign_key for #{name} in #{reflection.inspect}"
 
-        declare_field(foreign_key_column.to_sym, :bigint, **foreign_key_column_options)
+        field_specs[foreign_key_column_name] = _infer_foreign_key_field_spec(foreign_key_column_name, reflection, column_options)
 
         if reflection.options[:polymorphic]
           foreign_type = options[:foreign_type] || "#{name}_type"
           _declare_polymorphic_type_field(foreign_type, column_options)
           if ::DeclareSchema.default_generate_indexing && index_options
-            index([foreign_type, foreign_key_column], **index_options)
+            index([foreign_type, foreign_key_column_name], **index_options)
           end
         else
           if ::DeclareSchema.default_generate_indexing && index_options
-            index([foreign_key_column], **index_options)
+            index([foreign_key_column_name], **index_options)
           end
 
           if ::DeclareSchema.default_generate_foreign_keys && constraint_name != false
-            constraint(foreign_key_column, constraint_name: constraint_name || index_options&.[](:name), parent_class_name: reflection.class_name, dependent: dependent_delete)
+            constraint(foreign_key_column_name,
+                       constraint_name: constraint_name || index_options&.[](:name),
+                       parent_class_name: reflection.class_name,
+                       dependent: dependent_delete)
           end
         end
       end
 
-      def _infer_fk_limit(foreign_key_column, reflection)
+      # Returns a FieldSpec for the foreign key column of a belongs_to association.
+      # If the association is polymorphic, the foreign key column is a bigint, or possibly a 4-byte integer
+      # if the foreign key column is already defined that way in the database.
+      # If the association is not polymorphic, the foreign key column matches the primary key type of the associated model.
+      def _infer_foreign_key_field_spec(foreign_key_column_name, reflection, column_options)
         if reflection.options[:polymorphic]
-          if (foreign_key_column = _column(foreign_key_column)) && foreign_key_column.type == :integer
-            foreign_key_column.limit
+          if (foreign_key_column = _column(foreign_key_column_name)) && foreign_key_column.type == :integer
+            # grandfather foreign key column to match what's in the database
+            column_options = column_options.merge(limit: foreign_key_column.limit)
           end
+          FieldSpec.new(self, foreign_key_column_name, :bigint, position: field_specs.size, **column_options)
         else
           klass = reflection.klass or raise "Couldn't find belongs_to klass for #{name} in #{reflection.inspect}"
-          if (pk_id_type = klass._table_options&.[](:id))
-            if pk_id_type == :integer
-              4
-            end
-          else
-            if klass.table_exists? && (pk_column = klass.columns_hash[klass._declared_primary_key])
-              pk_id_type = pk_column.type
-              if pk_id_type == :integer
-                pk_column.limit
-              end
-            end
-          end
+          klass._foreign_key_field_spec(self, foreign_key_column_name, position: field_specs.size, **column_options)
         end
       end
 
@@ -273,6 +256,25 @@ module DeclareSchema
         end
       end
 
+      # Returns a FieldSpec for a foreign key pointing to the primary key of this model.
+      # Exactly matches the primary key type.
+      def _foreign_key_field_spec(model, foreign_key, position:, null:)
+        _primary_key_field_spec.foreign_key_field_spec(model, foreign_key, position:, null:)
+      end
+
+      def _primary_key_field_spec
+        declared_primary_key = _declared_primary_key
+        field_specs[declared_primary_key] || _primary_key_field_spec_from_table_options(declared_primary_key) or
+          raise "Declared primary key #{declared_primary_key.inspect} not found in field_specs or _table_options #{_table_options.inspect} for #{name}"
+      end
+
+      def _primary_key_field_spec_from_table_options(declared_primary_key)
+        primary_key_options = _table_options[declared_primary_key.to_sym] || _table_options[declared_primary_key]
+        options = primary_key_options.is_a?(Hash) ? primary_key_options.dup : {}
+        type = options.delete(:type) || Rails.application.config.generators.options.dig(:active_record, :primary_key_type) || :bigint
+        FieldSpec.new(self, declared_primary_key, type, **options)
+      end
+
       private
 
       # if this is a derived class, returns the base class's _declared_primary_key

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "3.0.0"
+  VERSION = "3.1.0.colin.1"
 end

data/lib/declare_schema.rb

@@ -65,7 +65,7 @@ module DeclareSchema
       if mysql_version && mysql_version >= SEMVER_8 && charset == 'utf8'
         'utf8mb3'
       else
-        charset
+        charset.downcase
       end
     end
 
@@ -74,7 +74,7 @@ module DeclareSchema
         collation.sub(/\Autf8_/, 'utf8mb3_')
       else
         collation
-      end
+      end.downcase
     end
 
     def default_charset=(charset)
@@ -172,7 +172,6 @@ module DeclareSchema
 end
 
 require 'declare_schema/extensions/active_record/fields_declaration'
-require 'declare_schema/field_declaration_dsl'
 require 'declare_schema/model'
 require 'declare_schema/model/field_spec'
 require 'declare_schema/model/index_definition'

data/lib/generators/declare_schema/migration/migrator.rb

@@ -80,15 +80,13 @@ module Generators
           self.class.native_types
         end
 
-        # list habtm join tables
+        # return habtm reflections keyed by join table name (so that habtm from each side has just one entry)
         def habtm_tables
-          reflections = Hash.new { |h, k| h[k] = [] }
-          ActiveRecord::Base.send(:descendants).map do |c|
+          ActiveRecord::Base.send(:descendants).each_with_object({}) do |c, result|
             c.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|
-              reflections[a.join_table] << a
+              result[a.join_table] ||= a
             end
           end
-          reflections
         end
 
         # Returns an array of model classes and an array of table names
@@ -204,8 +202,8 @@ module Generators
             end
           end
           # generate shims for HABTM models
-          habtm_tables.each do |name, reflections|
-            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(reflections.first)
+          habtm_tables.each do |name, reflection|
+            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(reflection)
           end
           model_table_names = models_by_table_name.keys
 
@@ -376,21 +374,21 @@ module Generators
             ::DeclareSchema::SchemaChange::ColumnRename.new(new_table_name, old_name, new_name)
           end
 
-          to_add.sort_by! { |c| model.field_specs[c]&.position || 0 }
+          to_add.sort_by! { model.field_specs[_1]&.position || 0 }
 
-          adds = to_add.map do |c|
+          adds = to_add.map do |col_name_to_add|
             type, options =
-              if (spec = model.field_specs[c])
-                [spec.type, spec.sql_options.merge(fk_field_options(model, c)).compact]
+              if (spec = model.field_specs[col_name_to_add])
+                [spec.type, spec.sql_options.merge(fk_field_options(model, col_name_to_add)).compact]
               else
                 [:integer, {}]
               end
-            ::DeclareSchema::SchemaChange::ColumnAdd.new(new_table_name, c, type, **options)
+            ::DeclareSchema::SchemaChange::ColumnAdd.new(new_table_name, col_name_to_add, type, **options)
           end
 
-          removes = to_remove.map do |c|
-            old_type, old_options = add_column_back(model, current_table_name, c)
-            ::DeclareSchema::SchemaChange::ColumnRemove.new(new_table_name, c, old_type, **old_options)
+          removes = to_remove.map do |col_name_to_remove|
+            old_type, old_options = add_column_back(model, current_table_name, col_name_to_remove)
+            ::DeclareSchema::SchemaChange::ColumnRemove.new(new_table_name, col_name_to_remove, old_type, **old_options)
           end
 
           old_names = to_rename.invert
@@ -546,11 +544,14 @@ module Generators
           end
         end
 
+        # TODO: switch this to depend on _infer_foreign_key_field_spec instead
         def fk_field_options(model, field_name)
-          if (foreign_key = model.constraint_definitions.find { |fk| field_name == fk.foreign_key_column })
+          # check if the field_name is a foreign key
+          if (foreign_key = model.constraint_definitions.find { field_name == _1.foreign_key_column })
+            # if so, look up the target table's primary key column to get its limit (note: this is looking in the DB, not the spec)
             parent_columns = connection.columns(foreign_key.parent_table_name) rescue []
             pk_limit =
-              if (pk_column = parent_columns.find { |column| column.name.to_s == "id" }) # right now foreign keys assume id is the target
+              if (pk_column = parent_columns.find { _1.name.to_s == "id" }) # right now foreign keys assume id is the target
                 pk_column.limit
               else
                 8

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0.colin.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-08 00:00:00.000000000 Z
+date: 2025-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -66,7 +66,6 @@ files:
 - lib/declare_schema/dsl.rb
 - lib/declare_schema/extensions/active_record/fields_declaration.rb
 - lib/declare_schema/extensions/module.rb
-- lib/declare_schema/field_declaration_dsl.rb
 - lib/declare_schema/model.rb
 - lib/declare_schema/model/column.rb
 - lib/declare_schema/model/field_spec.rb
@@ -108,7 +107,6 @@ files:
 - spec/fixtures/migrations/sqlite3/will_generate_unique_constraint_names_rails_6.txt
 - spec/fixtures/migrations/sqlite3/will_generate_unique_constraint_names_rails_7.txt
 - spec/lib/declare_schema/api_spec.rb
-- spec/lib/declare_schema/field_declaration_dsl_spec.rb
 - spec/lib/declare_schema/field_spec_spec.rb
 - spec/lib/declare_schema/generator_spec.rb
 - spec/lib/declare_schema/interactive_primary_key_spec.rb
@@ -158,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.4.16
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Database schema declaration and migration generator for Rails

data/lib/declare_schema/field_declaration_dsl.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module DeclareSchema
-  class FieldDeclarationDsl < BasicObject # avoid Object because that gets extended by lots of gems
-    include ::Kernel                      # but we need the basic class methods
-
-    instance_methods.each do |m|
-      unless m.to_s.starts_with?('__') || m.in?([:object_id, :instance_eval])
-        undef_method(m)
-      end
-    end
-
-    def initialize(model, **options)
-      @model = model
-      @options = options
-    end
-
-    attr_reader :model
-
-    def timestamps
-      field(:created_at, :datetime, null: true)
-      field(:updated_at, :datetime, null: true)
-    end
-
-    def optimistic_lock
-      field(:lock_version, :integer, default: 1, null: false)
-    end
-
-    def field(name, type, *args, **options)
-      @model.declare_field(name, type, *args, **@options.merge(options))
-    end
-
-    def method_missing(name, *args, **options)
-      field(name, *args, **options)
-    end
-  end
-end

data/spec/lib/declare_schema/field_declaration_dsl_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../lib/declare_schema/field_declaration_dsl'
-
-RSpec.describe DeclareSchema::FieldDeclarationDsl do
-  include_context 'prepare test app'
-
-  let(:model) { TestModel.new }
-  subject { declared_class.new(model) }
-
-  context 'Using declare_schema' do
-    before do
-      class TestModel < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
-        declare_schema do
-          string :name, limit: 127
-
-          timestamps
-        end
-      end
-    end
-
-    it 'has fields' do
-      expect(TestModel.field_specs).to be_kind_of(Hash)
-      expect(TestModel.field_specs.keys).to eq(['name', 'created_at', 'updated_at'])
-      expect(TestModel.field_specs.values.map(&:type)).to eq([:string, :datetime, :datetime])
-    end
-
-    it 'stores limits' do
-      expect(TestModel.field_specs['name'].limit).to eq(127), TestModel.field_specs['name'].inspect
-    end
-  end
-
-  # TODO: fill out remaining tests
-end