declare_schema 0.11.1 → 0.13.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 389da0d9f9e0753e62297aeca33c3c73305d95082a3f50baf6288362011e6f52
-  data.tar.gz: 7d20d8ef4a085e37ec13273c020b8c3883e96359e9e4c7d173c3beccf5c73dab
+  metadata.gz: fef97a705f29e37659ade688c2c64b30f0df1eabc76ab47ceb1272f2eec10845
+  data.tar.gz: 3602d932b5bae67c6cfd367750e399d44ab65afa4fd19c4923ff5e447b79ca40
 SHA512:
-  metadata.gz: 0e4eb02bc1d989d648095b952e1feff00af9cbbc4ea3dbb7962f15fdbcafce2fac4bc93c467417d29396e6753993874c3c2faf882a620db0d54f3ea905195cf9
-  data.tar.gz: d504a96bb5f60d7c64b03fd975c9e7c78fe9614f06a0aa73fffe0c0987786a554e3f603a79198f962b13b0b869690b839fb1cd0215196353064360ef81e46e51
+  metadata.gz: 770d10d283e399d3ca37537e7ed4c68d0dde1a6ba28e033148ed7ed86d0e0833256d0b2446688538ef34f39cac9c1fe535914824d4bf7e6de17d11554b876ec2
+  data.tar.gz: 134add2558ab3374d741e04839913257eb48e8b98d4b80a3bc3c35927369032fd9549d9a1dd2768c702386f44b4265c0379475cd01f8097288cad53b479a4ee9

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.13.0] - Unreleased
+### Added
+- Added support for `default_schema =` to apply a default schema to every model, unless disabld for that model with `declare_schema: false`.
+
+## [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.
@@ -168,6 +183,9 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.13.0]: https://github.com/Invoca/declare_schema/compare/v0.12.1...v0.13.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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.11.1)
+    declare_schema (0.13.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
@@ -62,7 +62,7 @@ trigger the `eager_load!` on the `Rails` application and all `Rails::Engine`s lo
 into scope.  If you need to generate migrations for models that aren't automatically loaded by `eager_load!`,
 load them in the `before_generating_migration` block.
 
-**Example Configuration**
+For example:
 
 ```ruby
 DeclareSchema::Migration::Migrator.before_generating_migration do
@@ -70,6 +70,26 @@ DeclareSchema::Migration::Migrator.before_generating_migration do
 end
 ```
 
+### default_schema
+If there are default columns you would like in the schema for every model, you can define them in a block that is registered with
+`DeclareSchema.default_schema =`. For example:
+
+```ruby
+DeclareSchema.default_schema = -> do
+  timestamps
+  optimistic_lock
+end
+```
+This will add these fields to the schema of each model (if not already there).
+If you have a model where you don't want the defaults applied, that can be set with the `default_schema:` boolean option to `declare_schema` (the default value is true). For example:
+```ruby
+class User < ActiveRecord::Base
+  declare_schema default_schema: false do
+    ...
+  end
+end
+```
+
 ### Global Configuration
 Configurations can be set at the global level to customize default declaration for the following values:
 
@@ -187,7 +207,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 +217,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 +237,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.rb

@@ -37,7 +37,7 @@ module DeclareSchema
 
   class << self
     attr_reader :default_charset, :default_collation, :default_text_limit, :default_string_limit, :default_null,
-                :default_generate_foreign_keys, :default_generate_indexing, :db_migrate_command
+                :default_generate_foreign_keys, :default_generate_indexing, :default_schema, :db_migrate_command
 
     def to_class(type)
       case type
@@ -85,6 +85,11 @@ module DeclareSchema
       @default_generate_indexing = generate_indexing
     end
 
+    def default_schema=(default_schema)
+      default_schema.nil? || default_schema.respond_to?(:call) or raise "default_schema must be nil or a block that responds to call"
+      @default_schema = default_schema
+    end
+
     def db_migrate_command=(db_migrate_command)
       db_migrate_command.is_a?(String) or raise ArgumentError, "db_migrate_command must be a string (got #{db_migrate_command.inspect})"
       @db_migrate_command = db_migrate_command

data/lib/declare_schema/dsl.rb

@@ -7,7 +7,7 @@ module DeclareSchema
     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])
+      unless m.to_s.starts_with?('__') || m.in?([:object_id, :instance_eval, :instance_exec])
         undef_method(m)
       end
     end
@@ -32,8 +32,11 @@ module DeclareSchema
       @model.declare_field(name, type, *(args + [@options.merge(options)]))
     end
 
-    def method_missing(type, name, *args)
-      field(name, type, *args)
+    # TODO: make [:required] just another option. Either 'required: true] or 'optional: false'?
+    def method_missing(*args, **options)
+      args.count(&:itself) >= 2 or raise ::ArgumentError, "fields in declare_schema block must be declared as: type name, [:required], options (got #{args.inspect}, #{options.inspect})"
+      type, name, *required = args
+      field(name, type, *required, options)
     end
   end
 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)
@@ -25,20 +27,19 @@ module DeclareSchema
     end
     deprecate :fields, deprecator: ActiveSupport::Deprecation.new('1.0', 'DeclareSchema')
 
-    def declare_schema(table_options = {}, &block)
+    def declare_schema(default_schema: true, **table_options, &block)
       # Any model that calls 'fields' gets DeclareSchema::Model behavior
       DeclareSchema::Model.mix_in(self)
 
       # @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)
-        if block.arity == 1
-          yield dsl
-        else
-          dsl.instance_eval(&block)
+        dsl.instance_eval(&block)
+        if default_schema && DeclareSchema.default_schema
+          dsl.instance_exec(&DeclareSchema.default_schema)
         end
       end
     end

data/lib/declare_schema/model.rb

@@ -34,19 +34,16 @@ module DeclareSchema
           # supported options include :charset and :collation
           inheriting_cattr_reader table_options: HashWithIndifferentAccess.new
 
-          # eval avoids the ruby 1.9.2 "super from singleton method ..." error
-
-          eval <<~EOS
-            def self.inherited(klass)
-              unless klass.field_specs.has_key?(inheritance_column)
-                declare_schema do |f|
-                  f.field(inheritance_column, :string, limit: 255, null: true)
-                end
-                index(inheritance_column)
+          def self.inherited(klass)
+            unless klass.field_specs.has_key?(inheritance_column)
+              ic = inheritance_column
+              declare_schema do
+                field(ic, :string, limit: 255, null: true)
               end
-              super
+              index(ic)
             end
-          EOS
+            super
+          end
         end
       end
     end
@@ -99,7 +96,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 +109,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 +139,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 +168,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 +198,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.1"
+  VERSION = "0.13.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,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/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
@@ -1860,6 +1860,8 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       class SuperFancyAdvert < FancyAdvert
       end
 
+      expect(Generators::DeclareSchema::Migration::Migrator.run.first).to be_present
+
       up, _ = Generators::DeclareSchema::Migration::Migrator.run do |migrations|
         expect(migrations).to(
           migrate_up(<<~EOS.strip)
@@ -2039,7 +2041,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 +2243,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
-            expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_false)
-            expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(true)
+          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
+          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 '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)
+          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
+
+          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
@@ -2370,5 +2493,78 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         end
       end
     end
+
+    context 'default_schema' do
+      let(:default_schema_block) { nil }
+      let(:declare_model) do
+        -> do
+          class Advert < active_record_base_class.constantize
+            declare_schema do
+              integer :price, limit: 8
+            end
+          end
+        end
+      end
+
+      before do
+        DeclareSchema.default_schema = default_schema_block
+      end
+
+      after do
+        DeclareSchema.default_schema = nil
+      end
+
+      context 'when unset' do
+        it 'adds nothing' do
+          declare_model.call
+
+          expect(Advert.field_specs.keys).to eq(['price'])
+        end
+      end
+
+      context 'when set to a block' do
+        let(:default_schema_block) do
+          -> do
+            timestamps
+            field :lock_version, :integer, default: 1
+          end
+        end
+
+        it 'adds the fields in that block' do
+          declare_model.call
+
+          expect(Advert.field_specs.keys).to eq(['price', 'created_at', 'updated_at', 'lock_version'])
+        end
+
+        context 'and the model sets default_schema: false' do
+          before do
+            class Advert < active_record_base_class.constantize
+              declare_schema default_schema: false do
+                integer :price, limit: 8
+              end
+            end
+          end
+
+          it 'does not add the default schema fields' do
+            expect(Advert.field_specs.keys).to eq(['price'])
+          end
+        end
+
+        context 'and the block has redundant fields' do
+          before do
+            class Advert < active_record_base_class.constantize
+              declare_schema do
+                integer :price, limit: 8
+                timestamps
+              end
+            end
+          end
+
+          it 'is a no-op' do
+            expect(Advert.field_specs.keys).to eq(['price', 'created_at', 'updated_at', 'lock_version'])
+          end
+        end
+      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.13.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-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails