declare_schema 0.10.0 → 0.12.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e993cfd0cf72aa7610f32743ce838d6c7e6ec07370cd3427649ab80cce7e9ac2
-  data.tar.gz: 273de3135fa09049b57a598342a36c283dc956498016dbc98297910233b1b5bb
+  metadata.gz: e55426213e7d15730b0531d3dba4036a4b18f3967b73a7619e60f27d15fc5b55
+  data.tar.gz: 294eef4ce49c912df24403ab59998e61641c681ea1e98fa6c9fa00d66a4c4502
 SHA512:
-  metadata.gz: 1f28b92b3614dc61323b386eeb67c681873c983acd66869b705e6c920c906c9429f26030135e916726fa0b068c6b68e5cce57902f64c230c0a5cf289fdec9645
-  data.tar.gz: 2d23d69ffedf63881a3d33bbde3f2bcc62ed9e12938e981bb7388400a3f4dec28aa3ade8714a3c352c93b743496e70777f6a54e710d91d7e6adb2ca66fc23954
+  metadata.gz: 3a3ebaa029176ff322a396baf65aaca878f631ae3ac0acad2a2290fc73275c56c312a00e1423219a30055f39ca17f1873a55f0d8be8a4dfeb38f821718c57128
+  data.tar.gz: 25d48b29e96b5508b52c07ca869221d506f05370a38af76994a33bbfcb67153f379b9605a60e9169876bebb63e6db5bf9acbf1f09aab900d03fc05be404cd643

data/CHANGELOG.md

@@ -4,9 +4,35 @@ 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.
+
+## [0.11.0] - 2021-03-22
+### Removed
+- Removed `g|m|c` prompt entirely, since it was confusing. Instead, the migration is
+ always generated; the user may press ^C at the filename prompt to cancel.
+ The migration will be run if `--migrate` is passed; otherwise, the migrate command will be displayed to be run later.
+### Added
+- Added the new configuration option `DeclareSchema.@db_migrate_command =`.
+### Fixed 
+- Fixed bug where foreign key constraint names are not globally unique
+
+## [0.10.1] - 2021-03-18
+### Fixed
+- Migration steps are now generated in a defined dependency order, so that--for example--indexes that depend
+ on columns are deleted first, before the columns themselves are deleted (since the latter implicitly does the former, which would break the migration when run).
+- Related to the above, down migration steps are now always generated in exactly the reverse order of the up migration steps.
+
 ## [0.10.0] - 2021-03-17
 ### Deprecated
-- The `fields` dsl method is being deprecated.
+- Deprecated the `fields` DSL method in favor of `declare_schema`.
 
 ### Added
 - Added the `declare_schema` method to replace `fields`. We now expect a column's type to come before the name
@@ -148,6 +174,10 @@ 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
 [0.10.0]: https://github.com/Invoca/declare_schema/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/Invoca/declare_schema/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/Invoca/declare_schema/compare/v0.7.1...v0.8.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.10.0)
+    declare_schema (0.12.0.pre.2)
       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
@@ -57,7 +57,7 @@ during the initialization of your Rails application.
 
 ### before_generating_migration callback
 
-During the initializtion process for generating migrations, `DeclareSchema` will
+During the initialization process for generating migrations, `DeclareSchema` will
 trigger the `eager_load!` on the `Rails` application and all `Rails::Engine`s loaded
 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.
@@ -163,6 +163,16 @@ turn all tables into `utf8mb4` supporting tables:
 DeclareSchema.default_charset   = "utf8mb4"
 DeclareSchema.default_collation = "utf8mb4_bin"
 ```
+#### db:migrate Command
+`declare_schema` can run the migration once it is generated, if the `--migrate` option is passed.
+If not, it will display the command to run later. By default this command is
+```
+bundle exec rails db:migrate
+```
+If your repo has a different command to run for migrations, you can configure it like this:
+```ruby
+`DeclareSchema.db_migrate_command = "bundle exec rails db:migrate_immediate"`
+```
 
 ## Declaring Character Set and Collation
 _Note: This feature currently only works for MySQL database configurations._
@@ -177,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:
@@ -187,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
@@ -207,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.rb

@@ -28,10 +28,16 @@ module DeclareSchema
   @default_null                  = false
   @default_generate_foreign_keys = true
   @default_generate_indexing     = true
+  @db_migrate_command            =
+    if ActiveSupport::VERSION::MAJOR < 5
+      "bundle exec rake db:migrate"
+    else
+      "bundle exec rails db:migrate"
+    end
 
   class << self
     attr_reader :default_charset, :default_collation, :default_text_limit, :default_string_limit, :default_null,
-                :default_generate_foreign_keys, :default_generate_indexing
+                :default_generate_foreign_keys, :default_generate_indexing, :db_migrate_command
 
     def to_class(type)
       case type
@@ -78,6 +84,11 @@ module DeclareSchema
       generate_indexing.in?([true, false]) or raise ArgumentError, "generate_indexing must be either true or false (got #{generate_indexing.inspect})"
       @default_generate_indexing = generate_indexing
     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
+    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)
@@ -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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rails'
-
 require 'declare_schema/extensions/module'
 
 module DeclareSchema
@@ -101,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 = {}
 
@@ -111,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)
@@ -130,7 +134,7 @@ module DeclareSchema
 
         fk_options[:dependent] = options.delete(:far_end_dependent) if options.has_key?(:far_end_dependent)
 
-        if Rails::VERSION::MAJOR >= 5
+        if ActiveSupport::VERSION::MAJOR >= 5
           super
         else
           super(name, scope, options.except(:optional))
@@ -138,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)
@@ -149,7 +171,29 @@ module DeclareSchema
         end
       end
 
-      if ::Rails::VERSION::MAJOR < 5
+      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'
         end
@@ -157,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"
@@ -227,7 +271,7 @@ module DeclareSchema
                   ActiveRecord::Coders::JSON
                 elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
                   class_name_or_coder
-                elsif Rails::VERSION::MAJOR >= 5
+                elsif ActiveSupport::VERSION::MAJOR >= 5
                   ActiveRecord::Coders::YAMLColumn.new(attr_name, class_name_or_coder)
                 else
                   ActiveRecord::Coders::YAMLColumn.new(class_name_or_coder)

data/lib/declare_schema/model/column.rb

@@ -53,13 +53,13 @@ module DeclareSchema
         def deserialize_default_value(column, type, default_value)
           type or raise ArgumentError, "must pass type; got #{type.inspect}"
 
-          case Rails::VERSION::MAJOR
+          case ActiveSupport::VERSION::MAJOR
           when 4
             # TODO: Delete this Rails 4 support ASAP! This could be wrong, since it's using the type of the old column...which
             # 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/foreign_key_definition.rb

@@ -7,20 +7,20 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :options, :on_delete_cascade
+      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :parent_table_name, :child_table_name, :options, :on_delete_cascade
+
 
       def initialize(model, foreign_key, options = {})
         @model = model
         @foreign_key = foreign_key.to_s.presence
         @options = options
 
-        @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
+        @child_table_name = model.table_name # unless a table rename, which would happen when a class is renamed??
         @parent_table_name = options[:parent_table]&.to_s
         @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
 
-        @constraint_name = options[:constraint_name]&.to_s ||
-                             options[:index_name]&.to_s ||
-                             IndexDefinition.index_name(@foreign_key_name)
+        @constraint_name = options[:constraint_name]&.to_s.presence ||
+                             model.connection.index_name(model.table_name, column: @foreign_key_name)
         @on_delete_cascade = options[:dependent] == :delete
       end
 
@@ -61,11 +61,6 @@ module DeclareSchema
             foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
       end
 
-      def to_add_statement
-        "add_foreign_key(#{@child_table.inspect}, #{parent_table_name.inspect}, " +
-          "column: #{@foreign_key_name.inspect}, name: #{@constraint_name.inspect})"
-      end
-
       def <=>(rhs)
         key <=> rhs.send(:key)
       end
@@ -75,7 +70,7 @@ module DeclareSchema
       private
 
       def key
-        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
+        @key ||= [@child_table_name, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
       end
 
       def hash

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,8 +67,8 @@ 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)
-          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) || Rails::VERSION::MAJOR < 5 or return nil
+        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
 
@@ -93,25 +95,6 @@ module DeclareSchema
         name == PRIMARY_KEY_NAME
       end
 
-      def to_add_statement(new_table_name, existing_primary_key = nil)
-        if primary_key? && !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
-          to_add_primary_key_statement(new_table_name, existing_primary_key)
-        else
-          # Note: + below keeps that interpolated string from being frozen, so we can << into it.
-          r = +"add_index #{new_table_name.to_sym.inspect}, #{fields.map(&:to_sym).inspect}"
-          r << ", unique: true"      if unique
-          r << ", where: '#{where}'" if where.present?
-          r << ", name: '#{name}'"
-          r
-        end
-      end
-
-      def to_add_primary_key_statement(new_table_name, existing_primary_key)
-        drop = "DROP PRIMARY KEY, " if existing_primary_key
-        statement = "ALTER TABLE #{new_table_name} #{drop}ADD PRIMARY KEY (#{fields.join(', ')})"
-        "execute #{statement.inspect}"
-      end
-
       def to_key
         @key ||= [table, fields, name, unique, where].map(&:to_s)
       end