declare_schema 0.11.1 → 0.12.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 389da0d9f9e0753e62297aeca33c3c73305d95082a3f50baf6288362011e6f52
-  data.tar.gz: 7d20d8ef4a085e37ec13273c020b8c3883e96359e9e4c7d173c3beccf5c73dab
+  metadata.gz: e1353d236bb050d93155e56eab2bf5e5d31da06338970b13278c07ed86ac3180
+  data.tar.gz: f70054b7f56fd18264abe2e719167a2d83ebaa143279dc784dfcaf16b4cb4514
 SHA512:
-  metadata.gz: 0e4eb02bc1d989d648095b952e1feff00af9cbbc4ea3dbb7962f15fdbcafce2fac4bc93c467417d29396e6753993874c3c2faf882a620db0d54f3ea905195cf9
-  data.tar.gz: d504a96bb5f60d7c64b03fd975c9e7c78fe9614f06a0aa73fffe0c0987786a554e3f603a79198f962b13b0b869690b839fb1cd0215196353064360ef81e46e51
+  metadata.gz: 7e541c39b62bf7228842f20830ae52d1b49dca66a6a834f38478cc3320aa65dea1c7b85becbcc75edf7382470e7bdf0bc9949a3665e72ff778a26aaae65ae15a
+  data.tar.gz: f3bdcaad7b1aa8341d168c5d10461737b54e7781dfadce2da26e289f2ca3192b6dd9775bdb8c99a040b17ba415be2725fcbd3451c518c96e901227f2572cf95c

data/CHANGELOG.md

@@ -4,6 +4,12 @@ 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).
 
+## [0.12.0] - Unreleased
+### Added
+- `belongs_to` now always infers the `limit:` of the foreign key to match that of the primary key it points to.
+ Note: this isn't possible for polymorphic foreign keys, so it assumes `limit: 8` there...unless the schema
+ was migrated in the past with `limit: 4`.
+
 ## [0.11.1] - 2021-03-26
 ### Fixed
 - Fixed a bug where up and down in generated migration would be empty in Rails 4.
@@ -168,6 +174,7 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.12.0]: https://github.com/Invoca/declare_schema/compare/v0.11.1...v0.12.0
 [0.11.1]: https://github.com/Invoca/declare_schema/compare/v0.11.0...v0.11.1
 [0.11.0]: https://github.com/Invoca/declare_schema/compare/v0.10.1...v0.11.0
 [0.10.1]: https://github.com/Invoca/declare_schema/compare/v0.10.0...v0.10.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.11.1)
+    declare_schema (0.12.0.pre.1)
       rails (>= 4.2)
 
 GEM

data/README.md

@@ -4,10 +4,10 @@ Declare your Rails/active_record model schemas and have database migrations gene
 
 ## Example
 
-Make a model and declare your schema within a `fields do ... end` block:
+Make a model and declare your schema within a `declare_schema do ... end` block:
 ```ruby
 class Company < ActiveRecord::Base
-  fields do
+  declare_schema do
     company_name :string, limit: 100
     ticker_symbol :string, limit: 4, null: true, index: true, unique: true
     employee_count :integer
@@ -187,7 +187,7 @@ at three separate levels
 
 ### Table Configuration
 In order to configure a table's default character set and collation, the `charset` and
-`collation` arguments can be added to the `fields` block.
+`collation` arguments can be added to the `declare_schema` block.
 
 For example, if you have a comments model that needs `utf8mb4` support, it would look
 like the following:
@@ -197,7 +197,7 @@ like the following:
 # frozen_string_literal: true
 
 class Comment < ActiveRecord::Base
-  fields charset: "utf8mb4", collation: "utf8mb4_bin" do
+  declare_schema charset: "utf8mb4", collation: "utf8mb4_bin" do
     subject :string, limit: 255
     content :text,   limit: 0xffff_ffff
   end
@@ -217,7 +217,7 @@ look like the following:
 # frozen_string_literal: true
 
 class Comment < ActiveRecord::Base
-  fields do
+  declare_schema do
     subject :string, limit: 255
     context :text,   limit: 0xffff_ffff, charset: "utf8mb4", collation: "utf8mb4_bin"
   end

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

@@ -7,12 +7,14 @@ require 'declare_schema/field_declaration_dsl'
 
 module DeclareSchema
   module Macros
+    attr_reader :_table_options
+
     def fields(table_options = {}, &block)
       # Any model that calls 'fields' gets DeclareSchema::Model behavior
       DeclareSchema::Model.mix_in(self)
 
       @include_in_migration = true
-      @table_options        = table_options
+      @_table_options        = table_options
 
       if block
         dsl = DeclareSchema::FieldDeclarationDsl.new(self)
@@ -31,7 +33,7 @@ module DeclareSchema
 
       # @include_in_migration = false #||= options.fetch(:include_in_migration, true); options.delete(:include_in_migration)
       @include_in_migration = true # TODO: Add back or delete the include_in_migration feature
-      @table_options        = table_options
+      @_table_options        = table_options
 
       if block
         dsl = DeclareSchema::Dsl.new(self, null: false)

data/lib/declare_schema/model.rb

@@ -99,7 +99,10 @@ module DeclareSchema
         end
       end
 
-      # Extend belongs_to so that it creates a FieldSpec for the foreign key
+      # Extend belongs_to so that it
+      # 1. creates a FieldSpec for the foreign key
+      # 2. declares an index on the foreign key
+      # 3. declares a foreign_key constraint
       def belongs_to(name, scope = nil, **options)
         column_options = {}
 
@@ -109,7 +112,10 @@ module DeclareSchema
                                   options[:optional] # infer :null from :optional
                                 end || false
         column_options[:default] = options.delete(:default) if options.has_key?(:default)
-        column_options[:limit] = options.delete(:limit) if options.has_key?(:limit)
+        if options.has_key?(:limit)
+          options.delete(:limit)
+          ActiveSupport::Deprecation.warn("belongs_to limit: is deprecated since it is now inferred")
+        end
 
         index_options = {}
         index_options[:name]   = options.delete(:index) if options.has_key?(:index)
@@ -136,7 +142,25 @@ module DeclareSchema
 
         refl = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
         fkey = refl.foreign_key or raise "Couldn't find foreign_key for #{name} in #{refl.inspect}"
-        declare_field(fkey.to_sym, :integer, column_options)
+        fkey_id_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.
+        fkey_id_column_options[:pre_migration] = ->(field_spec) do
+          if (inferred_limit = _infer_fk_limit(fkey, refl))
+            field_spec.sql_options[:limit] = inferred_limit
+          end
+        end
+
+        declare_field(fkey.to_sym, :bigint, fkey_id_column_options)
+
         if refl.options[:polymorphic]
           foreign_type = options[:foreign_type] || "#{name}_type"
           _declare_polymorphic_type_field(foreign_type, column_options)
@@ -147,6 +171,28 @@ module DeclareSchema
         end
       end
 
+      def _infer_fk_limit(fkey, refl)
+        if refl.options[:polymorphic]
+          if (fkey_column = columns_hash[fkey.to_s]) && fkey_column.type == :integer
+            fkey_column.limit
+          end
+        else
+          klass = refl.klass or raise "Couldn't find belongs_to klass for #{name} in #{refl.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
+        end
+      end
+
       if ::ActiveSupport::VERSION::MAJOR < 5
         def primary_key
           super || 'id'
@@ -155,27 +201,27 @@ module DeclareSchema
 
       # returns the primary key (String) as declared with primary_key =
       # unlike the `primary_key` method, DOES NOT query the database to find the actual primary key in use right now
-      # if no explicit primary key set, returns the default_defined_primary_key
-      def _defined_primary_key
+      # if no explicit primary key set, returns the _default_declared_primary_key
+      def _declared_primary_key
         if defined?(@primary_key)
           @primary_key&.to_s
-        end || _default_defined_primary_key
+        end || _default_declared_primary_key
       end
 
       private
 
-      # if this is a derived class, returns the base class's _defined_primary_key
+      # if this is a derived class, returns the base class's _declared_primary_key
       # otherwise, returns 'id'
-      def _default_defined_primary_key
+      def _default_declared_primary_key
         if self == base_class
           'id'
         else
-          base_class._defined_primary_key
+          base_class._declared_primary_key
         end
       end
 
       def _rails_default_primary_key
-        ::DeclareSchema::Model::IndexDefinition.new(self, [_defined_primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
+        ::DeclareSchema::Model::IndexDefinition.new(self, [_declared_primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
       # Declares the "foo_type" field that accompanies the "foo_id"

data/lib/declare_schema/model/column.rb

@@ -59,7 +59,7 @@ module DeclareSchema
             # might be getting migrated to a new type. We should be using just type as below. -Colin
             column.type_cast_from_database(default_value)
           else
-            cast_type = ActiveRecord::Base.connection.send(:lookup_cast_type, type) or
+            cast_type = ActiveRecord::Base.connection.send(:lookup_cast_type, type.to_s) or
               raise "cast_type not found for #{type}"
             cast_type.deserialize(default_value)
           end

data/lib/declare_schema/model/field_spec.rb

@@ -47,9 +47,9 @@ module DeclareSchema
       end
 
       def initialize(model, name, type, position: 0, **options)
-        _defined_primary_key = model._defined_primary_key
+        _declared_primary_key = model._declared_primary_key
 
-        name.to_s == _defined_primary_key and raise ArgumentError, "you may not provide a field spec for the primary key #{name.inspect}"
+        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
@@ -99,8 +99,8 @@ module DeclareSchema
 
         if @type.in?([:text, :string])
           if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-            @options[:charset]   ||= model.table_options[:charset]   || ::DeclareSchema.default_charset
-            @options[:collation] ||= model.table_options[:collation] || ::DeclareSchema.default_collation
+            @options[:charset]   ||= model._table_options&.[](:charset)   || ::DeclareSchema.default_charset
+            @options[:collation] ||= model._table_options&.[](:collation) || ::DeclareSchema.default_collation
           else
             @options.delete(:charset)
             @options.delete(:collation)

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -29,7 +29,7 @@ module DeclareSchema
         @connection = connection
       end
 
-      def table_options
+      def _table_options
         {}
       end
 
@@ -47,7 +47,7 @@ module DeclareSchema
         false # no single-column primary key in database
       end
 
-      def _defined_primary_key
+      def _declared_primary_key
         false # no single-column primary key declared
       end
 

data/lib/declare_schema/model/index_definition.rb

@@ -37,7 +37,7 @@ module DeclareSchema
         def for_model(model, old_table_name = nil)
           t = old_table_name || model.table_name
 
-          primary_key_columns = Array(model.connection.primary_key(t)).presence || sqlite_compound_primary_key(model, t) or
+          primary_key_columns = Array(model.connection.primary_key(t)).presence || fallback_find_primary_key(model, t) or
             raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
 
           primary_key_found = false
@@ -67,7 +67,7 @@ module DeclareSchema
         private
 
         # This is the old approach which is still needed for MySQL in Rails 4 and SQLite
-        def sqlite_compound_primary_key(model, table)
+        def fallback_find_primary_key(model, table)
           ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) || ActiveSupport::VERSION::MAJOR < 5 or return nil
 
           connection = model.connection.dup
@@ -83,9 +83,11 @@ module DeclareSchema
             end
           end
 
-          pk_index = connection.indexes(table).find { |index| index.name.to_s == PRIMARY_KEY_NAME } or return nil
-
-          Array(pk_index.columns)
+          if (pk_index = connection.indexes(table).find { |index| index.name.to_s == PRIMARY_KEY_NAME })
+            Array(pk_index.columns)
+          elsif model.connection.columns(table).any? { |col| col.name == 'id' }
+            ['id']
+          end
         end
       end
 

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.11.1"
+  VERSION = "0.12.0.pre.1"
 end

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

@@ -187,6 +187,12 @@ module Generators
           models, db_tables = models_and_tables
           models_by_table_name = {}
           models.each do |m|
+            m.try(:field_specs)&.each do |_name, field_spec|
+              if (pre_migration = field_spec.options.delete(:pre_migration))
+                pre_migration.call(field_spec)
+              end
+            end
+
             if !models_by_table_name.has_key?(m.table_name)
               models_by_table_name[m.table_name] = m
             elsif m.superclass == models_by_table_name[m.table_name].superclass.superclass
@@ -203,8 +209,8 @@ module Generators
 
           to_create = model_table_names - db_tables
           to_drop = db_tables - model_table_names - self.class.always_ignore_tables
-          to_change = model_table_names
           to_rename = extract_table_renames!(to_create, to_drop)
+          to_change = model_table_names
 
           renames = to_rename.map do |old_name, new_name|
             ::DeclareSchema::SchemaChange::TableRename.new(old_name, new_name)
@@ -297,14 +303,14 @@ module Generators
         end
 
         def create_table_options(model, disable_auto_increment)
-          primary_key = model._defined_primary_key
+          primary_key = model._declared_primary_key
           if primary_key.blank? || disable_auto_increment
             { id: false }
           elsif primary_key == "id"
             { id: :bigint }
           else
             { primary_key: primary_key.to_sym }
-          end
+          end.merge(model._table_options)
         end
 
         def table_options_for_model(model)
@@ -312,8 +318,8 @@ module Generators
             {}
           else
             {
-              charset:   model.table_options[:charset] || ::DeclareSchema.default_charset,
-              collation: model.table_options[:collation] || ::DeclareSchema.default_collation
+              charset:   model._table_options&.[](:charset) || ::DeclareSchema.default_charset,
+              collation: model._table_options&.[](:collation) || ::DeclareSchema.default_collation
             }
           end
         end
@@ -336,18 +342,17 @@ module Generators
           new_table_name = model.table_name
 
           db_columns = model.connection.columns(current_table_name).index_by(&:name)
-          key_missing = db_columns[model._defined_primary_key].nil? && model._defined_primary_key.present?
-          if model._defined_primary_key.present?
-            db_columns.delete(model._defined_primary_key)
+          if (pk = model._declared_primary_key.presence)
+            key_was_in_db_columns = db_columns.delete(pk)
           end
 
           model_column_names = model.field_specs.keys.map(&:to_s)
           db_column_names = db_columns.keys.map(&:to_s)
 
           to_add = model_column_names - db_column_names
-          to_add += [model._defined_primary_key] if key_missing && model._defined_primary_key.present?
+          to_add += [pk] unless key_was_in_db_columns
           to_remove = db_column_names - model_column_names
-          to_remove -= [model._defined_primary_key.to_sym] if model._defined_primary_key.present?
+          to_remove -= [pk.to_sym] if pk    # TODO: The .to_sym here means this code is always a no-op, right? -Colin
 
           to_rename = extract_column_renames!(to_add, to_remove, new_table_name)
 

data/spec/lib/declare_schema/api_spec.rb

@@ -41,10 +41,12 @@ RSpec.describe 'DeclareSchema API' do
 
       if ActiveSupport::VERSION::MAJOR == 5
         # TODO: get this to work on Travis for Rails 6
+        # TODO: uncomment since we're not on Travis any more? -Colin
         generate_migrations '-n', '-m'
       end
 
       require 'advert'
+      Advert.reset_primary_key
 
       ## The Basics
 

data/spec/lib/declare_schema/field_spec_spec.rb

@@ -6,7 +6,7 @@ rescue LoadError
 end
 
 RSpec.describe DeclareSchema::Model::FieldSpec do
-  let(:model) { double('model', table_options: {}, _defined_primary_key: 'id') }
+  let(:model) { double('model', _table_options: {}, _declared_primary_key: 'id') }
   let(:col_spec) { double('col_spec', type: :string) }
 
   before do

data/spec/lib/declare_schema/interactive_primary_key_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
       end
 
       generate_migrations '-n', '-m'
-      expect(Foo._defined_primary_key).to eq('foo_id')
+      expect(Foo._declared_primary_key).to eq('foo_id')
 
       ### migrate from
       # rename from custom primary_key
@@ -31,7 +31,7 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
 
       allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'id' }
       generate_migrations '-n', '-m'
-      expect(Foo._defined_primary_key).to eq('id')
+      expect(Foo._declared_primary_key).to eq('id')
 
       nuke_model_class(Foo)
 
@@ -72,7 +72,7 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
 
         allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'drop id' }
         generate_migrations '-n', '-m'
-        expect(Foo._defined_primary_key).to eq('foo_id')
+        expect(Foo._declared_primary_key).to eq('foo_id')
       end
     end
   end
@@ -80,8 +80,7 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
   context 'Using declare_schema' do
     it "allows alternate primary keys" do
       class Foo < ActiveRecord::Base
-        declare_schema do
-        end
+        declare_schema { }
         self.primary_key = "foo_id"
       end
 
@@ -91,15 +90,14 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
       ### migrate from
       # rename from custom primary_key
       class Foo < ActiveRecord::Base
-        declare_schema do
-        end
+        declare_schema { }
         self.primary_key = "id"
       end
 
       puts "\n\e[45m Please enter 'id' (no quotes) at the next prompt \e[0m"
       allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'id' }
       generate_migrations '-n', '-m'
-      expect(Foo.primary_key).to eq('id')
+      expect(Foo._declared_primary_key).to eq('id')
 
       nuke_model_class(Foo)
 

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -441,10 +441,10 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       Advert.field_specs.delete(:category_id)
       Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
-      ### Timestamps and Optimimistic Locking
+      ### Timestamps and Optimistic Locking
 
       # `updated_at` and `created_at` can be declared with the shorthand `timestamps`.
-      # Similarly, `lock_version` can be declared with the "shorthand" `optimimistic_lock`.
+      # Similarly, `lock_version` can be declared with the "shorthand" `optimistic_lock`.
 
       class Advert < ActiveRecord::Base
         fields do
@@ -2039,7 +2039,6 @@ RSpec.describe 'DeclareSchema Migration Generator' do
           add_foreign_key :affiliates, :categories, column: :category_id, name: :index_affiliates_on_category_id
         EOS
         )
-        binding.pry
         migrate
 
         nuke_model_class(Advertiser)
@@ -2242,80 +2241,202 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       let(:optional_flag) { { false => optional_false, true => optional_true } }
 
       describe 'belongs_to' do
-        before do
-          unless defined?(AdCategory)
-            class AdCategory < ActiveRecord::Base
-              declare_schema { }
+        context 'with AdCategory and Advert in DB' do
+          before do
+            unless defined?(AdCategory)
+              class AdCategory < ActiveRecord::Base
+                declare_schema { }
+              end
             end
-          end
 
-          class Advert < ActiveRecord::Base
-            declare_schema do
-              string :name, limit: 250, null: true
-              integer :category_id, limit: 8
-              integer :nullable_category_id, limit: 8, null: true
+            class Advert < ActiveRecord::Base
+              declare_schema do
+                string :name, limit: 250, null: true
+                integer :category_id, limit: 8
+                integer :nullable_category_id, limit: 8, null: true
+              end
             end
+            up = Generators::DeclareSchema::Migration::Migrator.run.first
+            ActiveRecord::Migration.class_eval(up)
           end
-          up = Generators::DeclareSchema::Migration::Migrator.run.first
-          ActiveRecord::Migration.class_eval(up)
-        end
-
-        it 'passes through optional: when given' do
-          class AdvertBelongsTo < ActiveRecord::Base
-            self.table_name = 'adverts'
-            declare_schema { }
-            reset_column_information
-            belongs_to :ad_category, optional: true
-          end
-          expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_true)
-        end
 
-        describe 'contradictory settings' do # contradictory settings are ok--for example, during migration
-          it 'passes through optional: true, null: false' do
+          it 'passes through optional: when given' do
             class AdvertBelongsTo < ActiveRecord::Base
               self.table_name = 'adverts'
               declare_schema { }
               reset_column_information
-              belongs_to :ad_category, optional: true, null: false
+              belongs_to :ad_category, optional: true
             end
             expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_true)
-            expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(false)
           end
 
-          it 'passes through optional: false, null: true' do
-            class AdvertBelongsTo < ActiveRecord::Base
-              self.table_name = 'adverts'
-              declare_schema { }
-              reset_column_information
-              belongs_to :ad_category, optional: false, null: true
+          describe 'contradictory settings' do # contradictory settings are ok--for example, during migration
+            it 'passes through optional: true, null: false' do
+              class AdvertBelongsTo < ActiveRecord::Base
+                self.table_name = 'adverts'
+                declare_schema { }
+                reset_column_information
+                belongs_to :ad_category, optional: true, null: false
+              end
+              expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_true)
+              expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(false)
+            end
+
+            it 'passes through optional: false, null: true' do
+              class AdvertBelongsTo < ActiveRecord::Base
+                self.table_name = 'adverts'
+                declare_schema { }
+                reset_column_information
+                belongs_to :ad_category, optional: false, null: true
+              end
+              expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_false)
+              expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(true)
+            end
+          end
+
+          [false, true].each do |nullable|
+            context "nullable=#{nullable}" do
+              it 'infers optional: from null:' do
+                eval <<~EOS
+                  class AdvertBelongsTo < ActiveRecord::Base
+                    declare_schema { }
+                    belongs_to :ad_category, null: #{nullable}
+                  end
+                EOS
+                expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_flag[nullable])
+                expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(nullable)
+              end
+
+              it 'infers null: from optional:' do
+                eval <<~EOS
+                  class AdvertBelongsTo < ActiveRecord::Base
+                    declare_schema { }
+                    belongs_to :ad_category, optional: #{nullable}
+                  end
+                EOS
+                expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_flag[nullable])
+                expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(nullable)
+              end
             end
-            expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_false)
-            expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(true)
+          end
+
+          it 'deprecates limit:' do
+            expect(ActiveSupport::Deprecation).to receive(:warn).with("belongs_to limit: is deprecated since it is now inferred")
+            eval <<~EOS
+              class UsingLimit < ActiveRecord::Base
+                declare_schema { }
+                belongs_to :ad_category, limit: 4
+              end
+            EOS
           end
         end
 
-        [false, true].each do |nullable|
-          context "nullable=#{nullable}" do
-            it 'infers optional: from null:' do
-              eval <<~EOS
-                class AdvertBelongsTo < ActiveRecord::Base
-                  declare_schema { }
-                  belongs_to :ad_category, null: #{nullable}
-                end
-              EOS
-              expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_flag[nullable])
-              expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(nullable)
+        context 'when parent object PKs have different limits' do
+          before do
+            class IdDefault < ActiveRecord::Base
+              declare_schema { }
+            end
+            class Id4 < ActiveRecord::Base
+              declare_schema id: :integer do
+              end
+            end
+            class Id8 < ActiveRecord::Base
+              declare_schema id: :bigint do
+              end
+            end
+            class Fk < ActiveRecord::Base
+              declare_schema { }
+              belongs_to :id_default, (ActiveSupport::VERSION::MAJOR < 5 ? { constraint: false } : {})
+              belongs_to :id4, (ActiveSupport::VERSION::MAJOR < 5 ? { constraint: false } : {})
+              belongs_to :id8, (ActiveSupport::VERSION::MAJOR < 5 ? { constraint: false } : {})
+            end
+          end
+
+          it 'creates the proper PKs' do
+            up = Generators::DeclareSchema::Migration::Migrator.run.first
+
+            create_id4_defaults = up.split("\n").grep(/create_table :id_defaults/).first
+            expect(create_id4_defaults).to be, up
+            expect(create_id4_defaults).to match(/, id: :bigint/)
+
+            create_id4s = up.split("\n").grep(/create_table :id4s/).first
+            expect(create_id4s).to be, up
+            expect(create_id4s).to match(/, id: :integer/)
+
+            create_id8s = up.split("\n").grep(/create_table :id8s/).first
+            expect(create_id8s).to be, up
+            expect(create_id8s).to match(/, id: :bigint/)
+          end
+
+          it 'infers the correct FK type from the create_table id: type' do
+            up = Generators::DeclareSchema::Migration::Migrator.run.first
+
+            create_fks = up.split("\n").grep(/t\.integer /).map { |command| command.gsub(', null: false', '').gsub(/^ +/, '') }
+            if defined?(SQLite3)
+              create_fks.map! { |command| command.gsub(/limit: [a-z0-9]+/, 'limit: X') }
+              expect(create_fks).to eq([
+                                         't.integer :id_default_id, limit: X',
+                                         't.integer :id4_id, limit: X',
+                                         't.integer :id8_id, limit: X'
+                                       ]), up
+            else
+              expect(create_fks).to eq([
+                                         't.integer :id_default_id, limit: 8',
+                                         't.integer :id4_id, limit: 4',
+                                         't.integer :id8_id, limit: 8'
+                                       ]), up
             end
+          end
 
-            it 'infers null: from optional:' do
-              eval <<~EOS
-                class AdvertBelongsTo < ActiveRecord::Base
-                  declare_schema { }
-                  belongs_to :ad_category, optional: #{nullable}
-                end
-              EOS
-              expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_flag[nullable])
-              expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(nullable)
+          context "when parent objects were migrated before and later definitions don't have explicit id:" do
+            before do
+              up = Generators::DeclareSchema::Migration::Migrator.run.first
+              ActiveRecord::Migration.class_eval up
+              nuke_model_class(IdDefault)
+              nuke_model_class(Id4)
+              nuke_model_class(Id8)
+              nuke_model_class(Fk)
+              ActiveRecord::Base.connection.schema_cache.clear!
+
+
+              class NewIdDefault < ActiveRecord::Base
+                self.table_name = 'id_defaults'
+                declare_schema { }
+              end
+              class NewId4 < ActiveRecord::Base
+                self.table_name = 'id4s'
+                declare_schema { }
+              end
+              class NewId8 < ActiveRecord::Base
+                self.table_name = 'id8s'
+                declare_schema { }
+              end
+              class NewFk < ActiveRecord::Base
+                declare_schema { }
+                belongs_to :new_id_default
+                belongs_to :new_id4
+                belongs_to :new_id8
+              end
+            end
+
+            it 'infers the correct FK :integer limit: ' do
+              up = Generators::DeclareSchema::Migration::Migrator.run.first
+
+              create_fks = up.split("\n").grep(/t\.integer /).map { |command| command.gsub(', null: false', '').gsub(/^ +/, '') }
+              if defined?(SQLite3)
+                create_fks.map! { |command| command.gsub(/limit: [a-z0-9]+/, 'limit: X') }
+                expect(create_fks).to eq([
+                                           't.integer :new_id_default_id, limit: X',
+                                           't.integer :new_id4_id, limit: X',
+                                           't.integer :new_id8_id, limit: X'
+                                         ]), up
+              else
+                expect(create_fks).to eq([
+                                           't.integer :new_id_default_id, limit: 8',
+                                           't.integer :new_id4_id, limit: 4',
+                                           't.integer :new_id8_id, limit: 8'
+                                         ]), up
+              end
             end
           end
         end

data/spec/lib/declare_schema/model/habtm_model_shim_spec.rb

@@ -55,7 +55,7 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     describe '#table_options' do
       it 'returns empty hash' do
-        expect(subject.table_options).to eq({})
+        expect(subject._table_options).to eq({})
       end
     end
 
@@ -86,13 +86,13 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     describe '#primary_key' do
       it 'returns false' do
-        expect(subject._defined_primary_key).to eq(false)
+        expect(subject._declared_primary_key).to eq(false)
       end
     end
 
-    describe '#_defined_primary_key' do
+    describe '#_declared_primary_key' do
       it 'returns false' do
-        expect(subject._defined_primary_key).to eq(false)
+        expect(subject._declared_primary_key).to eq(false)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0.pre.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-26 00:00:00.000000000 Z
+date: 2021-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails