declare_schema 1.3.6 → 1.4.0.colin.1

data/lib/declare_schema/model.rb

@@ -49,34 +49,22 @@ module DeclareSchema
     end
 
     module ClassMethods
-      def index(columns, name: nil, allow_equivalent: false, unique: false, where: nil)
-        index_definition =
-          ::DeclareSchema::Model::IndexDefinition.new(
-            columns,
-            name: name, table_name: table_name, allow_equivalent: allow_equivalent, unique: unique, where: where
-          )
-
-        # add idempotently
-        unless index_definitions.any? { |index_def| index_def.equivalent?(index_definition) }
-          index_definitions << index_definition
+      def index(fields, **options)
+        # make index idempotent
+        index_fields_s = Array.wrap(fields).map(&:to_s)
+        unless index_definitions.any? { |index_spec| index_spec.fields == index_fields_s }
+          index_definitions << ::DeclareSchema::Model::IndexDefinition.new(self, fields, **options)
         end
       end
 
-      def primary_key_index(*columns)
-        index(columns.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
+      def primary_key_index(*fields)
+        index(fields.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
-      def constraint(foreign_key_column, parent_table: nil, constraint_name: nil, class_name: nil, dependent: nil)
-        foreign_key_column = foreign_key_column.to_s
-        constraint_definition =
-          ::DeclareSchema::Model::ForeignKeyDefinition.new(
-            foreign_key_column,
-            constraint_name: constraint_name,
-            child_table: table_name, parent_table: parent_table, class_name: class_name, dependent: dependent
-          )
-
-        unless constraint_specs.any? { |constraint_def| constraint_def.equivalent?(constraint_definition) }
-          constraint_specs << constraint_definition
+      def constraint(fkey, **options)
+        fkey_s = fkey.to_s
+        unless constraint_specs.any? { |constraint_spec| constraint_spec.foreign_key == fkey_s }
+          constraint_specs << DeclareSchema::Model::ForeignKeyDefinition.new(self, fkey, **options)
         end
       end
 
@@ -110,8 +98,8 @@ module DeclareSchema
 
       # Extend belongs_to so that it
       # 1. creates a FieldSpec for the foreign key
-      # 2. declares an index on the foreign key (optional)
-      # 3. declares a foreign_key constraint (optional)
+      # 2. declares an index on the foreign key
+      # 3. declares a foreign_key constraint
       def belongs_to(name, scope = nil, **options)
         column_options = {}
 
@@ -126,26 +114,50 @@ module DeclareSchema
           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)
-        index_options[:unique] = options.delete(:unique) if options.has_key?(:unique)
-        index_options[:allow_equivalent] = options.delete(:allow_equivalent) if options.has_key?(:allow_equivalent)
+        # index: true means create an index on the foreign key
+        # index: false means do not create an index on the foreign key
+        # index: { ... } means create an index on the foreign key with the given options
+        index_value = options.delete(:index)
+        if index_value != false || options.has_key?(:unique) || options.has_key?(:allow_equivalent)
+          index_options = {}
+          case index_value
+          when String
+            Kernel.warn("belongs_to index: 'name' is deprecated; use index: { name: 'name' } instead")
+            index_options[:name] = index_value
+          # when false -- impossible since we checked that above
+          when true
+          when nil
+          when Hash
+            index_options = index_value
+          else
+            raise ArgumentError, "belongs_to index: must be true or false or a Hash; got #{index_value.inspect}"
+          end
 
-        constraint_name = options.delete(:constraint)
-        index_name = index_options[:name]
+          if options.has_key?(:unique)
+            Kernel.warn("belongs_to unique: true|false is deprecated; use index: { unique: true|false } instead")
+            index_options[:unique] = options.delete(:unique)
+          end
 
-        dependent_delete = :delete if options.delete(:far_end_dependent) == :delete
+          index_options[:allow_equivalent] = options.delete(:allow_equivalent) if options.has_key?(:allow_equivalent)
+        end
+
+        fk_options = options.dup
+        fk_options[:constraint_name] = options.delete(:constraint) if options.has_key?(:constraint)
+        fk_options[:index_name] = index_options&.[](:name)
+
+        fk = options[:foreign_key]&.to_s || "#{name}_id"
 
-        # infer :optional from :null
         if !options.has_key?(:optional)
-          options[:optional] = column_options[:null]
+          options[:optional] = column_options[:null] # infer :optional from :null
         end
 
+        fk_options[:dependent] = options.delete(:far_end_dependent) if options.has_key?(:far_end_dependent)
+
         super
 
         refl = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
-        foreign_key_column = refl.foreign_key or raise "Couldn't find foreign_key for #{name} in #{refl.inspect}"
-        foreign_key_column_options = column_options.dup
+        fkey = refl.foreign_key or raise "Couldn't find foreign_key for #{name} in #{refl.inspect}"
+        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.
@@ -156,34 +168,27 @@ module DeclareSchema
         # The one downside of this approach is that application code that asks the field_spec for the declared
         # foreign key limit: will always get 8 back even if this is a grandfathered foreign key that points to
         # a limit: 4 primary key. It seems unlikely that any application code would do this.
-        foreign_key_column_options[:pre_migration] = ->(field_spec) do
-          if (inferred_limit = _infer_fk_limit(foreign_key_column, refl))
+        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(foreign_key_column.to_sym, :bigint, **foreign_key_column_options)
+        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)
-          if ::DeclareSchema.default_generate_indexing && index_name != false
-            index([foreign_type, foreign_key_column], **index_options)
-          end
+          index([foreign_type, fkey], **index_options) if index_options
         else
-          if ::DeclareSchema.default_generate_indexing && index_name != false
-            index(foreign_key_column, **index_options)
-          end
-
-          if ::DeclareSchema.default_generate_foreign_keys && constraint_name != false
-            constraint(foreign_key_column, parent_table: nil, constraint_name: constraint_name || index_name, class_name: refl.klass, dependent: dependent_delete)
-          end
+          index(fkey, **index_options) if index_options
+          constraint(fkey, **fk_options) if fk_options[:constraint_name] != false
         end
       end
 
-      def _infer_fk_limit(foreign_key_column, refl)
+      def _infer_fk_limit(fkey, refl)
         if refl.options[:polymorphic]
-          if (fkey_column = columns_hash[foreign_key_column.to_s]) && fkey_column.type == :integer
+          if (fkey_column = columns_hash[fkey.to_s]) && fkey_column.type == :integer
             fkey_column.limit
           end
         else
@@ -225,7 +230,7 @@ module DeclareSchema
       end
 
       def _rails_default_primary_key
-        ::DeclareSchema::Model::IndexDefinition.new([_declared_primary_key], name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME, unique: true)
+        ::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"
@@ -296,14 +301,15 @@ module DeclareSchema
         end
       end
 
-      def _add_index_for_field(column_name, args, options)
-        if (index_name = options.delete(:index))
-          if index_name == true
-            index_name = nil # index: true means generate default name
-          end
-          unique = args.include?(:unique) || options.delete(:unique) || false
-
-          index([column_name], unique: unique, name: index_name)
+      def _add_index_for_field(name, args, options)
+        if (to_name = options.delete(:index))
+          index_opts =
+            {
+              unique: args.include?(:unique) || options.delete(:unique)
+            }
+          # support index: true declaration
+          index_opts[:name] = to_name unless to_name == true
+          index(name, **index_opts)
         end
       end
 

data/lib/declare_schema/schema_change/column_add.rb

@@ -6,10 +6,8 @@ module DeclareSchema
   module SchemaChange
     class ColumnAdd < Base
       def initialize(table_name, column_name, column_type, **column_options)
-        table_name.is_a?(String) || table_name.is_a?(Symbol) or raise ArgumentError, "must provide String|Symbol table_name; got #{table_name.inspect}"
-        column_name.is_a?(String) || column_name.is_a?(Symbol) or raise ArgumentError, "must provide String|Symbol column_name; got #{column_name.inspect}"
-        @table_name = table_name
-        @column_name = column_name
+        @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/schema_change/index_add.rb

@@ -5,12 +5,13 @@ require_relative 'base'
 module DeclareSchema
   module SchemaChange
     class IndexAdd < Base
-      def initialize(table_name, column_names, name:, unique:, where: nil)
+      def initialize(table_name, column_names, name:, unique:, where: nil, limit: nil)
         @table_name = table_name
         @column_names = column_names
         @name = name
         @unique = unique
         @where = where.presence
+        @limit = limit.presence
       end
 
       def up_command
@@ -19,6 +20,7 @@ module DeclareSchema
         }
         options[:unique] = true if @unique
         options[:where] = @where if @where
+        options[:limit] = @limit if @limit
 
         "add_index #{[@table_name.to_sym.inspect,
                       @column_names.map(&:to_sym).inspect,

data/lib/declare_schema/version.rb

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

data/lib/declare_schema.rb

@@ -3,7 +3,6 @@
 require 'active_support'
 require 'active_support/all'
 require_relative 'declare_schema/version'
-require 'rubygems/version'
 
 ActiveSupport::Dependencies.autoload_paths |= [__dir__]
 
@@ -22,8 +21,6 @@ module DeclareSchema
     text:     String
   }.freeze
 
-  SEMVER_8 = Gem::Version.new('8.0.0').freeze
-
   @default_charset               = "utf8mb4"
   @default_collation             = "utf8mb4_bin"
   @default_text_limit            = 0xffff_ffff
@@ -35,8 +32,7 @@ module DeclareSchema
   @max_index_and_constraint_name_length = 64  # limit for MySQL
 
   class << self
-    attr_writer :mysql_version
-    attr_reader :default_text_limit, :default_string_limit, :default_null,
+    attr_reader :default_charset, :default_collation, :default_text_limit, :default_string_limit, :default_null,
                 :default_generate_foreign_keys, :default_generate_indexing, :db_migrate_command,
                 :max_index_and_constraint_name_length
 
@@ -51,52 +47,14 @@ module DeclareSchema
       end
     end
 
-    def mysql_version
-      if defined?(@mysql_version)
-        @mysql_version
-      else
-        @mysql_version =
-          if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-            version_string = ActiveRecord::Base.connection.select_value('SELECT VERSION()')
-            Gem::Version.new(version_string)
-          end
-      end
-    end
-
-    def normalize_charset(charset)
-      if mysql_version && mysql_version >= SEMVER_8 && charset == 'utf8'
-        'utf8mb3'
-      else
-        charset
-      end
-    end
-
-    def normalize_collation(collation)
-      if mysql_version && mysql_version >= SEMVER_8
-        collation.sub(/\Autf8_/, 'utf8mb3_')
-      else
-        collation
-      end
-    end
-
     def default_charset=(charset)
       charset.is_a?(String) or raise ArgumentError, "charset must be a string (got #{charset.inspect})"
-      @default_charset_before_normalization = charset
-      @default_charset = nil
-    end
-
-    def default_charset
-      @default_charset ||= normalize_charset(@default_charset_before_normalization)
+      @default_charset = charset
     end
 
     def default_collation=(collation)
       collation.is_a?(String) or raise ArgumentError, "collation must be a string (got #{collation.inspect})"
-      @default_collation_before_normalization = collation
-      @default_collation = nil
-    end
-
-    def default_collation
-      @default_collation ||= normalize_collation(@default_collation_before_normalization)
+      @default_collation = collation
     end
 
     def default_text_limit=(text_limit)

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

@@ -3,7 +3,6 @@
 require 'active_record'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'declare_schema/schema_change/all'
-require_relative '../../../declare_schema/model/habtm_model_shim'
 
 module Generators
   module DeclareSchema
@@ -204,8 +203,8 @@ module Generators
             end
           end
           # generate shims for HABTM models
-          habtm_tables.each do |name, reflections|
-            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(reflections.first)
+          habtm_tables.each do |name, refls|
+            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(refls.first)
           end
           model_table_names = models_by_table_name.keys
 
@@ -222,8 +221,8 @@ module Generators
             ::DeclareSchema::SchemaChange::TableRemove.new(t, add_table_back(t))
           end
 
-          creates = to_create.map do |table_name|
-            model = models_by_table_name[table_name]
+          creates = to_create.map do |t|
+            model = models_by_table_name[t]
             disable_auto_increment = model.try(:disable_auto_increment)
 
             primary_key_definition =
@@ -240,13 +239,10 @@ module Generators
             table_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, **table_options_for_model(model))
             table_options = create_table_options(model, disable_auto_increment)
 
-            table_add = ::DeclareSchema::SchemaChange::TableAdd.new(
-              table_name,
-              primary_key_definition + field_definitions,
-              table_options,
-              sql_options: table_options_definition.settings
-            )
-
+            table_add = ::DeclareSchema::SchemaChange::TableAdd.new(t,
+                                                                    primary_key_definition + field_definitions,
+                                                                    table_options,
+                                                                    sql_options: table_options_definition.settings)
             [
               table_add,
               *Array((create_indexes(model)     if ::DeclareSchema.default_generate_indexing)),
@@ -259,9 +255,9 @@ module Generators
           fk_changes                 = []
           table_options_changes      = []
 
-          to_change.each do |table_name|
-            model = models_by_table_name[table_name]
-            table = to_rename.key(table_name) || model.table_name
+          to_change.each do |t|
+            model = models_by_table_name[t]
+            table = to_rename.key(t) || model.table_name
             if table.in?(db_tables)
               change, index_change, fk_change, table_options_change = change_table(model, table)
               changes << change
@@ -315,8 +311,6 @@ module Generators
             { id: false }
           elsif primary_key == "id"
             { id: :bigint }
-          elsif primary_key.is_a?(Array)
-            { primary_key: primary_key.map(&:to_sym) }
           else
             { primary_key: primary_key.to_sym }
           end.merge(model._table_options)
@@ -336,14 +330,14 @@ module Generators
         # TODO: TECH-5338: optimize that index doesn't need to be dropped on undo since entire table will be dropped
         def create_indexes(model)
           model.index_definitions.map do |i|
-            ::DeclareSchema::SchemaChange::IndexAdd.new(model.table_name, i.columns, unique: i.unique, where: i.where, name: i.name)
+            ::DeclareSchema::SchemaChange::IndexAdd.new(model.table_name, i.columns, **i.options)
           end
         end
 
         def create_constraints(model)
           model.constraint_specs.map do |fk|
             ::DeclareSchema::SchemaChange::ForeignKeyAdd.new(fk.child_table_name, fk.parent_table_name,
-                                                             column_name: fk.foreign_key_column, name: fk.constraint_name)
+                                                             column_name: fk.foreign_key_name, name: fk.constraint_name)
           end
         end
 
@@ -352,7 +346,7 @@ module Generators
 
           db_columns = model.connection.columns(current_table_name).index_by(&:name)
           if (pk = model._declared_primary_key.presence)
-            pk_was_in_db_columns = pk.is_a?(Array) || db_columns.delete(pk)
+            pk_was_in_db_columns = db_columns.delete(pk)
           end
 
           model_column_names = model.field_specs.keys.map(&:to_s)
@@ -431,7 +425,7 @@ module Generators
           ::DeclareSchema.default_generate_indexing or return []
 
           new_table_name = model.table_name
-          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_table(old_table_name || new_table_name, model.ignore_indexes, model.connection)
+          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
           model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
@@ -491,11 +485,7 @@ module Generators
           ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) and raise ArgumentError, 'SQLite does not support foreign keys'
           ::DeclareSchema.default_generate_foreign_keys or return []
 
-          if model.is_a?(::DeclareSchema::Model::HabtmModelShim)
-            force_dependent_delete = :delete
-          end
-
-          existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_table(old_table_name || model.table_name, model.connection, dependent: force_dependent_delete)
+          existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
           model_fks = model.constraint_specs
 
           fks_to_drop = existing_fks - model_fks
@@ -505,13 +495,13 @@ module Generators
 
           drop_fks = (fks_to_drop - renamed_fks_to_drop).map do |fk|
             ::DeclareSchema::SchemaChange::ForeignKeyRemove.new(fk.child_table_name, fk.parent_table_name,
-                                                                column_name: fk.foreign_key_column, name: fk.constraint_name)
+                                                                column_name: fk.foreign_key_name, name: fk.constraint_name)
           end
 
           add_fks = (fks_to_add - renamed_fks_to_add).map do |fk|
             # next if fk.parent.constantize.abstract_class || fk.parent == fk.model.class_name
             ::DeclareSchema::SchemaChange::ForeignKeyAdd.new(fk.child_table_name, fk.parent_table_name,
-                                                             column_name: fk.foreign_key_column, name: fk.constraint_name)
+                                                             column_name: fk.foreign_key_name, name: fk.constraint_name)
           end
 
           [drop_fks + add_fks]
@@ -533,7 +523,7 @@ module Generators
         end
 
         def fk_field_options(model, field_name)
-          foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key_column }
+          foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key.to_s }
           if foreign_key && (parent_table = foreign_key.parent_table_name)
             parent_columns = connection.columns(parent_table) rescue []
             pk_limit =

data/spec/lib/declare_schema/field_spec_spec.rb

@@ -5,11 +5,6 @@ begin
 rescue LoadError
 end
 
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-
 RSpec.describe DeclareSchema::Model::FieldSpec do
   let(:model) { double('model', _table_options: {}, _declared_primary_key: 'id') }
   let(:col_spec) { double('col_spec', type: :string) }
@@ -63,23 +58,8 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
         end
       end
 
-      if defined?(Mysql2)
-        context 'when running on MySQL 8.0' do
-          around do |spec|
-            DeclareSchema.mysql_version = Gem::Version.new('8.0.21')
-            spec.run
-          ensure
-            DeclareSchema.remove_instance_variable('@mysql_version') rescue nil
-          end
-
-          it 'normalizes charset and collation' do
-            subject = described_class.new(model, :title, :string, limit: 100, null: true, charset: 'utf8', collation: 'utf8_general', position: 0)
-
-            expect(subject.schema_attributes(col_spec)).to eq(type: :string, limit: 100, null: true, charset: 'utf8mb3', collation: 'utf8mb3_general')
-          end
-        end
-
-        it 'raises error when default_string_limit option is nil when not explicitly set in field spec' do
+      it 'raises error when default_string_limit option is nil when not explicitly set in field spec' do
+        if defined?(Mysql2)
           expect(::DeclareSchema).to receive(:default_string_limit) { nil }
           expect do
             described_class.new(model, :title, :string, null: true, charset: 'utf8mb4', position: 0)