declare_schema 0.11.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 516d119d979224ddbe841b2dd5117fc5891b5c79e09261443c7df6f3c2335910
-  data.tar.gz: 32621c93b56814f9a8dd30b2d622d2c6a4c536cdc40b2145d078134252e14401
+  metadata.gz: 2bace1c4f410e4766d4b9aa1414a5394414e8294db88ccd3d168d6db5d9802f6
+  data.tar.gz: da2b3467c656b0bad95b85627c341fb4d447872b144a452e3569a85a7369c452
 SHA512:
-  metadata.gz: 912c885f9fea463bae49937b6cb85ba6f7ab8cd4739327e6c662eb7b3cece701e1d42be9f251b97ba4a7b544eddd2a854a99ad8992d4a1fa5563acfd81cff989
-  data.tar.gz: 7429b27a56a0cfc27f8af16216528ee7137e5f9d0f20301f5c6177decc816c09b663bf78e5ea22d955b03ed58a7a103663980ec08ab14bb2d27f6d6ccb581787
+  metadata.gz: cf6eb2e6b67bd3071b9261a5d07eaa56dc019c148b02bbc11e70dd929934855e0b48a0c4c178d348286ec7bba4ed25f90c8041d855150c6b23c1aa81f26af25f
+  data.tar.gz: 3517a656b7b7edda5ed4164495747b0d879329d96bb44294f5b347acacc96a983e3cb6ab99fad8bf6e7b9fe998634ceb7cbd4ad79383164ab05ea6b273974c9f

data/CHANGELOG.md

@@ -4,6 +4,21 @@ 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.1] - 2021-05-10
+### Fixed
+- When an `enum` type field is declared, there is now enforcement that its `limit:` must be an array of 1 or more Symbols,
+  and its `default:`--if given--must be a Symbol or `nil`.
+
+## [0.12.0] - 2021-04-28
+### 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.
+
 ## [0.11.0] - 2021-03-22
 ### Removed
 - Removed `g|m|c` prompt entirely, since it was confusing. Instead, the migration is
@@ -164,6 +179,9 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.12.1]: https://github.com/Invoca/declare_schema/compare/v0.12.0...v0.12.1
+[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
 [0.10.0]: https://github.com/Invoca/declare_schema/compare/v0.9.0...v0.10.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.11.0)
+    declare_schema (0.12.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
@@ -76,12 +76,19 @@ module DeclareSchema
         when :bigint
           @type = :integer
           @options[:limit] = 8
+        when :enum
+          @options[:default].nil? || @options[:default].is_a?(Symbol) or
+            raise ArgumentError, "enum default: must be nil or a Symbol; got #{@options[:default].inspect}"
+          @options[:limit].is_a?(Array) && @options[:limit].size >= 1 && @options[:limit].all? { |value| value.is_a?(Symbol) } or
+            raise ArgumentError, "enum limit: must be an array of 1 or more Symbols; got #{@options[:limit].inspect}"
         end
 
         Column.native_type?(@type) or raise UnknownTypeError, "#{@type.inspect} not found in #{Column.native_types.inspect} for adapter #{ActiveRecord::Base.connection.class.name}"
 
-        if @type.in?([:string, :text, :binary, :varbinary, :integer, :enum])
+        if @type.in?([:string, :text, :binary, :varbinary, :integer])
           @options[:limit] ||= Column.native_types.dig(@type, :limit)
+        elsif @type.in?([:enum])
+          # nothing to do
         else
           @type != :decimal && @options.has_key?(:limit) and warn("unsupported limit: for SQL type #{@type} in field #{model}##{@name}")
           @options.delete(:limit)
@@ -99,8 +106,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/schema_change/column_add.rb

@@ -6,9 +6,9 @@ module DeclareSchema
   module SchemaChange
     class ColumnAdd < Base
       def initialize(table_name, column_name, column_type, **column_options)
-        @table_name = table_name
-        @column_name = column_name
-        @column_type = column_type
+        @table_name = table_name or raise ArgumentError, "must provide table_name"
+        @column_name = column_name or raise ArgumentError, "must provide column_name"
+        @column_type = column_type or raise ArgumentError, "must provide column_type"
         @column_options = column_options
       end
 

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.11.0"
+  VERSION = "0.12.1"
 end

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

@@ -73,8 +73,8 @@ module DeclareSchema
         end ||
         default_migration_name
 
-      @up = indent(up, 4)
-      @down = indent(down, 4)
+      @up = indent(up.strip, 4)
+      @down = indent(down.strip, 4)
       @migration_class_name = final_migration_name.camelize
 
       migration_template('migration.rb.erb', "db/migrate/#{final_migration_name.underscore}.rb")
@@ -100,7 +100,7 @@ module DeclareSchema
     if ActiveSupport::VERSION::MAJOR < 5
       def indent(string, columns)
         whitespace = ' ' * columns
-        string.gsub("\n", "\n#{whitespace}").gsub!(/ +\n/, "\n")
+        string.gsub("\n", "\n#{whitespace}").gsub(/ +\n/, "\n")
       end
     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,16 @@ 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)
+            pk_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 if pk && !pk_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_rename = extract_column_renames!(to_add, to_remove, new_table_name)
 

data/lib/generators/declare_schema/migration/templates/migration.rb.erb

@@ -1,9 +1,9 @@
 class <%= @migration_class_name %> < (ActiveSupport::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[4.2] : ActiveRecord::Migration)
   def self.up
-    <%= @up %>
+    <%= @up.presence or raise "no @up given!" %>
   end
 
   def self.down
-    <%= @down %>
+    <%= @down.presence or raise "no @down given!" %>
   end
 end

data/spec/lib/declare_schema/api_spec.rb

@@ -40,16 +40,14 @@ RSpec.describe 'DeclareSchema API' do
       load_models
 
       if ActiveSupport::VERSION::MAJOR == 5
-        # TODO: get this to work on Travis for Rails 6
         generate_migrations '-n', '-m'
       end
 
       require 'advert'
+      Advert.reset_primary_key
 
       ## The Basics
 
-      # The main feature of DeclareSchema, aside from the migration generator, is the ability to declare rich types for your fields. For example, you can declare that a field is an email address, and the field will be automatically validated for correct email address syntax.
-
       ### Field Types
 
       # Field values are returned as the type you specify.

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
@@ -115,6 +115,48 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
       end
     end
 
+    describe 'enum' do
+      before do
+        allow(::DeclareSchema::Model::Column).to receive(:native_types).and_wrap_original do |m, *_args|
+          result = m.call
+          if result.has_key?(:enum)
+            result
+          else
+            result.merge(enum: { name: "enum" })
+          end
+        end
+      end
+
+      describe 'default' do
+        it 'allows default of nil or a Symbol' do
+          [nil, :first].each do |default|
+            expect do
+              subject = described_class.new(model, :status, :enum, limit: [:first, :second, :third], default: default, null: false, position: 2)
+              expect(subject.default).to eq(default)
+            end.to_not raise_exception
+          end
+        end
+
+        it 'raises ArgumentError if default is not nil or a Symbol' do
+          ["first", 1].each do |default|
+            expect do
+              described_class.new(model, :status, :enum, limit: [:first, :second, :third], default: default, null: false, position: 2)
+            end.to raise_exception(ArgumentError, /enum default: must be nil or a Symbol; got #{Regexp.escape(default.inspect)}/)
+          end
+        end
+      end
+
+      describe 'limit' do
+        it 'raises ArgumentError if any of the limit values are not Symbols' do
+          [['first', 'second', 'third'], [1, 2, 3], nil, []].each do |limit|
+            expect do
+              described_class.new(model, :status, :enum, limit: limit, null: false, position: 2)
+            end.to raise_exception(ArgumentError, /enum limit: must be an array of 1 or more Symbols; got #{Regexp.escape(limit.inspect)}/)
+          end
+        end
+      end
+    end
+
     if defined?(Mysql2)
       describe 'varbinary' do # TODO: :varbinary is an Invoca addition to Rails; make it a configurable option
         it 'is supported' 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.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-22 00:00:00.000000000 Z
+date: 2021-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -128,7 +128,7 @@ homepage: https://github.com/Invoca/declare_schema
 licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -144,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubygems_version: 3.0.3
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Database schema declaration and migration generator for Rails
 test_files: []