declare_schema 1.4.0.colin.8 → 1.4.0.colin.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca0ed75221c664e2a5c59bff495a971495922f7f31ea0fb548fb67f0ad0eb639
-  data.tar.gz: fc76669be291fff9da61353f7f040ba14327e1359f712a963e5865ed948034c8
+  metadata.gz: 13075fb086e36e6be6818fd28620cb9015c257083e994f68c216ca790e463896
+  data.tar.gz: 4668a054c8d87a7612ba739e3937a4faf817b3ac558083c8e0af59668aa1c42a
 SHA512:
-  metadata.gz: 47b53d7e5306a3b2ada9296494af897738056c1c5e14e35e0b3967daf3176e07cf48c74560e2ccd659d0c1b8bc466e6d29f632f86b25bff568bcc4b6dcf672af
-  data.tar.gz: 9af422633cae00b32e94bf64d0e6e9445aee83849e4898633384af679b61c877a22ce14f1b20c225d17f4a1546ee3c3a1867e0661516f186717895a658d4b2eb
+  metadata.gz: 86d9f02bb9cabbb23ecec2eb68098b625b753b04890811858e4a43963d111ac54e5d2e10cd5468dfbdc2c6af39d1cab779002b033dbcbc05e869e4f0bc11f151
+  data.tar.gz: fbc233f25183279a309a23dc9afb395b4c4a47e52a95661126c99d9a9109100c5bd5ac3b200171fca479bd9c569f1a9aa34dbe15c79e8cfe50a95387f683ab7e

data/CHANGELOG.md

@@ -10,7 +10,21 @@ Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0
 ### Changed
 - Deprecate index: 'name' and unique: true|false in favor of index: { name: 'name', unique: true|false }.
 
-## [1.3.3] - 2023-01-17
+## [1.3.6] - 2024-01-22
+### Fixed
+- Add missing commits around connection: and Array check for composite declared primary key.
+
+## [1.3.5] - 2024-01-22
+### Fixed
+- Make `default_charset=` and `default_collation=` lazy so they don't use the database connection to check the
+  MySQL version. Instead, that is checked the first time `default_charset` or `default_collation` is called.
+
+## [1.3.4] - 2024-01-18
+### Fixed
+- Add test for migrating `has_and_belongs_to_many` associations and fix them to properly declare their
+  2 foreign keys as the primary key of the join table, rather than just a unique index.
+
+## [1.3.3] - 2024-01-17
 ### Fixed
 - Fix a MySQL 8 bug where MySQL 8+ renames charset 'utf8' to 'utf8mb3' and collation 'utf8_general_ci' to
   'utf8mb3_unicode_ci'.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (1.4.0.colin.8)
+    declare_schema (1.4.0.colin.11)
       rails (>= 5.0)
 
 GEM

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -4,15 +4,17 @@ module DeclareSchema
   module Model
     class HabtmModelShim
       class << self
-        def from_reflection(refl)
-          new(refl.join_table, [refl.foreign_key, refl.association_foreign_key],
-                               [refl.active_record.table_name, refl.class_name.constantize.table_name])
+        def from_reflection(reflection)
+          new(reflection.join_table,
+              [reflection.foreign_key, reflection.association_foreign_key],
+              [reflection.active_record.table_name, reflection.klass.table_name],
+              connection: reflection.active_record.connection)
         end
       end
 
-      attr_reader :join_table, :foreign_keys, :parent_table_names
+      attr_reader :join_table, :foreign_keys, :parent_table_names, :connection
 
-      def initialize(join_table, foreign_keys, parent_table_names)
+      def initialize(join_table, foreign_keys, parent_table_names, connection:)
         foreign_keys.is_a?(Array) && foreign_keys.size == 2 or
           raise ArgumentError, "foreign_keys must be <Array[2]>; got #{foreign_keys.inspect}"
         parent_table_names.is_a?(Array) && parent_table_names.size == 2 or
@@ -20,6 +22,7 @@ module DeclareSchema
         @join_table = join_table
         @foreign_keys = foreign_keys.sort # Rails requires these be in alphabetical order
         @parent_table_names = @foreign_keys == foreign_keys ? parent_table_names : parent_table_names.reverse # match the above sort
+        @connection = connection
       end
 
       def _table_options
@@ -41,17 +44,21 @@ module DeclareSchema
       end
 
       def _declared_primary_key
-        false # no single-column primary key declared
+        foreign_keys
       end
 
-      def index_definitions_with_primary_key
-        @index_definitions_with_primary_key ||= Set.new([
-          IndexDefinition.new(foreign_keys, name: Model::IndexDefinition::PRIMARY_KEY_NAME, table_name: table_name, unique: true), # creates a primary composite key on both foreign keys
-          IndexDefinition.new(foreign_keys.last,                                            table_name: table_name, unique: false) # index for queries where we only have the last foreign key
-        ])
+      def index_definitions
+        [
+          IndexDefinition.new(foreign_keys.last, table_name: table_name, unique: false) # index for queries where we only have the last foreign key
+        ]
       end
 
-      alias_method :index_definitions, :index_definitions_with_primary_key
+      def index_definitions_with_primary_key
+        [
+          *index_definitions,
+          IndexDefinition.new(foreign_keys, table_name: table_name, name: Model::IndexDefinition::PRIMARY_KEY_NAME, unique: true) # creates a primary composite key on both foreign keys
+        ]
+      end
 
       def ignore_indexes
         @ignore_indexes ||= Set.new

data/lib/declare_schema/model/index_definition.rb

@@ -16,12 +16,9 @@ module DeclareSchema
 
       PRIMARY_KEY_NAME = "PRIMARY"
 
-      # Caller needs to pass either name or table_name. The table_name is not remembered; it is just used to compute the
-      # default name if no name is given.
       def initialize(columns, table_name:, name: nil, allow_equivalent: false, unique: false, where: nil, length: nil)
         @table_name = table_name
-        @name = name || self.class.default_index_name(table_name, columns)
-        @name.to_s == 'index_adverts_on_Advert' and binding.pry
+        @name = (name || self.class.default_index_name(table_name, columns)).to_s
         @columns = Array.wrap(columns).map(&:to_s)
         @explicit_name = @name if !allow_equivalent
         unique.in?([false, true]) or raise ArgumentError, "unique must be true or false: got #{unique.inspect}"
@@ -38,7 +35,7 @@ module DeclareSchema
           @where = where.start_with?('(') ? where : "(#{where})"
         end
 
-        @length = length
+        @length = self.class.normalize_index_length(length, columns: @columns)
       end
 
       class << self
@@ -57,16 +54,7 @@ module DeclareSchema
                 raise "primary key on #{table_name} was not unique on #{primary_key_columns} (was unique=#{index.unique} on #{index.columns})"
               primary_key_found = true
             end
-            length =
-              case lengths = index.lengths
-              when {}
-                nil
-              when Hash
-                lengths.size == 1 ? lengths.values.first : lengths
-              else
-                lengths
-              end
-            new(index.columns, name: index.name, table_name: table_name, unique: index.unique, where: index.where, length: length)
+            new(index.columns, name: index.name, table_name: table_name, unique: index.unique, where: index.where, length: index.lengths)
           end.compact
 
           if !primary_key_found
@@ -86,6 +74,26 @@ module DeclareSchema
                        "Default index name '#{index_name}' exceeds configured limit of #{DeclareSchema.max_index_and_constraint_name_length} characters. Use the `name:` option to give it a shorter name, or adjust DeclareSchema.max_index_and_constraint_name_length if you know your database can accept longer names."
         end
 
+        # This method normalizes the length option to be either nil or a Hash of Symbol column names to lengths,
+        # so that we can safely compare what the user specified with what we get when querying the database schema.
+        # @return [Hash<Symbol, nil>]
+        def normalize_index_length(length, columns:)
+          case length
+          when nil, {}
+            nil
+          when Integer
+            if columns.size == 1
+              { columns.first.to_sym => length }
+            else
+              raise ArgumentError, "Index length of Integer only allowed when exactly one column; got #{length.inspect} for #{columns.inspect}"
+            end
+          when Hash
+            length.transform_keys(&:to_sym)
+          else
+            raise ArgumentError, "Index length must be nil or Integer or a Hash of column names to lengths; got #{length.inspect} for #{columns.inspect}"
+          end
+        end
+
         private
 
         SHA_SUFFIX_LENGTH = 4

data/lib/declare_schema/model.rb

@@ -50,10 +50,23 @@ module DeclareSchema
 
     module ClassMethods
       def index(columns, name: nil, allow_equivalent: false, unique: false, where: nil, length: nil)
-        index_definitions << ::DeclareSchema::Model::IndexDefinition.new(
+        index_definition = ::DeclareSchema::Model::IndexDefinition.new(
           columns,
           name: name, table_name: table_name, allow_equivalent: allow_equivalent, unique: unique, where: where, length: length
         )
+
+        if (equivalent = index_definitions.find { index_definition.equivalent?(_1) }) # differs only by name
+          if equivalent == index_definition
+            # identical is always idempotent
+          else
+            # equivalent is idempotent iff allow_equivalent: true passed
+            allow_equivalent or
+              raise ArgumentError, "equivalent index definition found (pass allow_equivalent: true to ignore):\n" \
+                                   "#{index_definition.inspect}\n#{equivalent.inspect}"
+          end
+        else
+          index_definitions << index_definition
+        end
       end
 
       def primary_key_index(*columns)
@@ -61,11 +74,13 @@ module DeclareSchema
       end
 
       def constraint(foreign_key_column, parent_table_name: nil, constraint_name: nil, parent_class_name: nil, dependent: nil)
-        constraint_definitions << ::DeclareSchema::Model::ForeignKeyDefinition.new(
+        constraint_definition = ::DeclareSchema::Model::ForeignKeyDefinition.new(
           foreign_key_column.to_s,
           constraint_name: constraint_name,
           child_table_name: table_name, parent_table_name: parent_table_name, parent_class_name: parent_class_name, dependent: dependent
         )
+
+        constraint_definitions << constraint_definition # Set<> implements idempotent insert.
       end
 
       # tell the migration generator to ignore the named index. Useful for existing indexes, or for indexes
@@ -111,31 +126,32 @@ module DeclareSchema
         column_options[:default] = options.delete(:default) if options.has_key?(:default)
         if options.has_key?(:limit)
           options.delete(:limit)
-          ActiveSupport::Deprecation.warn("belongs_to limit: is deprecated since it is now inferred")
+          ActiveSupport::Deprecation.warn("belongs_to #{name.inspect}, limit: is deprecated since it is now inferred")
         end
 
         # 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 = {} # truthy iff we want an index
+        if index_value == false # don't create an index
+          options.delete(:unique)
+          options.delete(:allow_equivalent)
+        else
+          index_options = {} # create an index
           case index_value
           when String, Symbol
-            Kernel.warn("belongs_to index: 'name' is deprecated; use index: { name: 'name' } instead (in #{name})")
+            ActiveSupport::Deprecation.warn("belongs_to #{name.inspect}, index: 'name' is deprecated; use index: { name: 'name' } instead (in #{self.name})")
             index_options[:name] = index_value.to_s
-          when false
-            raise ArgumentError, "belongs_to index: false contradicts others options #{options.inspect} (in #{name})"
           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} (in #{name})"
+            raise ArgumentError, "belongs_to #{name.inspect}, index: must be true or false or a Hash; got #{index_value.inspect} (in #{self.name})"
           end
 
           if options.has_key?(:unique)
-            Kernel.warn("belongs_to unique: true|false is deprecated; use index: { unique: true|false } instead (in #{name})")
+            ActiveSupport::Deprecation.warn("belongs_to #{name.inspect}, unique: true|false is deprecated; use index: { unique: true|false } instead (in #{self.name})")
             index_options[:unique] = options.delete(:unique)
           end
 
@@ -186,7 +202,7 @@ module DeclareSchema
           end
 
           if ::DeclareSchema.default_generate_foreign_keys && constraint_name != false
-            constraint(foreign_key_column, constraint_name: constraint_name || index_options&.[](:name), parent_class_name: reflection.klass, dependent: dependent_delete)
+            constraint(foreign_key_column, constraint_name: constraint_name || index_options&.[](:name), parent_class_name: reflection.class_name, dependent: dependent_delete)
           end
         end
       end

data/lib/declare_schema/schema_change/column_add.rb

@@ -6,8 +6,10 @@ module DeclareSchema
   module SchemaChange
     class ColumnAdd < Base
       def initialize(table_name, column_name, column_type, **column_options)
-        @table_name = table_name or raise ArgumentError, "must provide table_name"
-        @column_name = column_name or raise ArgumentError, "must provide column_name"
+        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
         @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 = "1.4.0.colin.8"
+  VERSION = "1.4.0.colin.11"
 end

data/lib/declare_schema.rb

@@ -36,7 +36,7 @@ module DeclareSchema
 
   class << self
     attr_writer :mysql_version
-    attr_reader :default_charset, :default_collation, :default_text_limit, :default_string_limit, :default_null,
+    attr_reader :default_text_limit, :default_string_limit, :default_null,
                 :default_generate_foreign_keys, :default_generate_indexing, :db_migrate_command,
                 :max_index_and_constraint_name_length
 
@@ -81,12 +81,22 @@ module DeclareSchema
 
     def default_charset=(charset)
       charset.is_a?(String) or raise ArgumentError, "charset must be a string (got #{charset.inspect})"
-      @default_charset = normalize_charset(charset)
+      @default_charset_before_normalization = charset
+      @default_charset = nil
+    end
+
+    def default_charset
+      @default_charset ||= normalize_charset(@default_charset_before_normalization)
     end
 
     def default_collation=(collation)
       collation.is_a?(String) or raise ArgumentError, "collation must be a string (got #{collation.inspect})"
-      @default_collation = normalize_collation(collation)
+      @default_collation_before_normalization = collation
+      @default_collation = nil
+    end
+
+    def default_collation
+      @default_collation ||= normalize_collation(@default_collation_before_normalization)
     end
 
     def default_text_limit=(text_limit)

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

@@ -204,8 +204,8 @@ module Generators
             end
           end
           # generate shims for HABTM models
-          habtm_tables.each do |name, refls|
-            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(refls.first)
+          habtm_tables.each do |name, reflections|
+            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(reflections.first)
           end
           model_table_names = models_by_table_name.keys
 
@@ -222,8 +222,8 @@ module Generators
             ::DeclareSchema::SchemaChange::TableRemove.new(t, add_table_back(t))
           end
 
-          creates = to_create.map do |t|
-            model = models_by_table_name[t]
+          creates = to_create.map do |table_name|
+            model = models_by_table_name[table_name]
             disable_auto_increment = model.try(:disable_auto_increment)
 
             primary_key_definition =
@@ -240,10 +240,13 @@ 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(t,
-                                                                    primary_key_definition + field_definitions,
-                                                                    table_options,
-                                                                    sql_options: table_options_definition.settings)
+            table_add = ::DeclareSchema::SchemaChange::TableAdd.new(
+              table_name,
+              primary_key_definition + field_definitions,
+              table_options,
+              sql_options: table_options_definition.settings
+            )
+
             [
               table_add,
               *Array((create_indexes(model)     if ::DeclareSchema.default_generate_indexing)),
@@ -256,9 +259,9 @@ module Generators
           fk_changes                 = []
           table_options_changes      = []
 
-          to_change.each do |t|
-            model = models_by_table_name[t]
-            table = to_rename.key(t) || model.table_name
+          to_change.each do |table_name|
+            model = models_by_table_name[table_name]
+            table = to_rename.key(table_name) || model.table_name
             if table.in?(db_tables)
               change, index_change, fk_change, table_options_change = change_table(model, table)
               changes << change
@@ -312,6 +315,8 @@ 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)
@@ -347,7 +352,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 = db_columns.delete(pk)
+            pk_was_in_db_columns = pk.is_a?(Array) || db_columns.delete(pk)
           end
 
           model_column_names = model.field_specs.keys.map(&:to_s)

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -414,7 +414,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
       # You can specify the index name with index: 'name' [deprecated]
 
-      expect(Kernel).to receive(:warn).with(/belongs_to index: 'name' is deprecated; use index: \{ name: 'name' \} instead/i)
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/belongs_to :category, index: 'name' is deprecated; use index: \{ name: 'name' \} instead/i)
 
       class Category < ActiveRecord::Base; end
       class Advert < ActiveRecord::Base
@@ -487,8 +487,8 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
       # You can add an index to a field definition
 
-      expect(Kernel).to receive(:warn).with(/belongs_to index: 'name' is deprecated; use index: \{ name: 'name' \} instead/i)
-      expect(Kernel).to receive(:warn).with(/belongs_to unique: true\|false is deprecated; use index: \{ unique: true\|false \} instead/i)
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/belongs_to :category, index: 'name' is deprecated; use index: \{ name: 'name' \} instead/i)
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/belongs_to :category, unique: true\|false is deprecated; use index: \{ unique: true\|false \} instead/i)
 
       class Advert < ActiveRecord::Base
         declare_schema do
@@ -572,7 +572,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       expect(Generators::DeclareSchema::Migration::Migrator.run).to(
         migrate_up(<<~EOS.strip)
           add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
-          add_index :adverts, [:title], name: :my_index, length: 10
+          add_index :adverts, [:title], name: :my_index, length: { title: 10 }
         EOS
       )
 
@@ -820,6 +820,8 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       expect(User.field_specs.keys).to eq(['company'])
       expect(User.field_specs['company'].options[:ruby_default]&.call).to eq("BigCorp")
 
+      nuke_model_class(User)
+
       ## validates
 
       # DeclareSchema can accept a validates hash in the field options.
@@ -840,6 +842,44 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       up, _down = Generators::DeclareSchema::Migration::Migrator.run
       ActiveRecord::Migration.class_eval(up)
       expect(Ad.field_specs['company'].options[:validates].inspect).to eq("{:presence=>true, :uniqueness=>{:case_sensitive=>false}}")
+
+      # DeclareSchema supports has_and_belongs_to_many relationships and generates the intersection ("join") table
+      # with appropriate primary key, indexes, and foreign keys.
+
+      class Advertiser < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 250
+        end
+        has_and_belongs_to_many :creatives
+      end
+      class Creative < ActiveRecord::Base
+        declare_schema do
+          string :url, limit: 500
+        end
+        has_and_belongs_to_many :advertisers
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          create_table :advertisers, id: :bigint#{create_table_charset_and_collation} do |t|
+            t.string :name, limit: 250, null: false#{charset_and_collation}
+          end
+          create_table :advertisers_creatives, primary_key: [:advertiser_id, :creative_id]#{create_table_charset_and_collation} do |t|
+            t.integer :advertiser_id, limit: 8, null: false
+            t.integer :creative_id, limit: 8, null: false
+          end
+          create_table :creatives, id: :bigint#{create_table_charset_and_collation} do |t|
+            t.string :url, limit: 500, null: false#{charset_and_collation}
+          end
+          add_index :advertisers_creatives, [:creative_id], name: :index_advertisers_creatives_on_creative_id
+          add_foreign_key :advertisers_creatives, :advertisers, column: :advertiser_id, name: :advertisers_creatives_FK1
+          add_foreign_key :advertisers_creatives, :creatives, column: :creative_id, name: :advertisers_creatives_FK2
+      EOS
+      )
+
+      nuke_model_class(Ad)
+      nuke_model_class(Advertiser)
+      nuke_model_class(Creative)
     end
 
     context 'models with the same parent foreign key relation' do
@@ -863,7 +903,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         end
       end
 
-      it 'will genereate unique constraint names' do
+      it 'will generate unique constraint names' do
         expect(Generators::DeclareSchema::Migration::Migrator.run).to(
           migrate_up(<<~EOS.strip)
             create_table :categories, id: :bigint, options: "CHARACTER SET utf8mb4 COLLATE utf8mb4_bin" do |t|
@@ -1160,7 +1200,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
           end
 
           it 'deprecates limit:' do
-            expect(ActiveSupport::Deprecation).to receive(:warn).with("belongs_to limit: is deprecated since it is now inferred")
+            expect(ActiveSupport::Deprecation).to receive(:warn).with("belongs_to :ad_category, limit: is deprecated since it is now inferred")
             eval <<~EOS
               class UsingLimit < ActiveRecord::Base
                 declare_schema { }
@@ -1397,5 +1437,53 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         end
       end
     end
+
+    context 'index' do
+      before do
+        class Advert < active_record_base_class.constantize
+          declare_schema { }
+          belongs_to :ad_category
+        end
+      end
+
+      it "is idempotent and doesn't raise" do
+        expect do
+          Advert.index [:ad_category_id], name: :index_adverts_on_ad_category_id
+        end.to_not change { Advert.index_definitions.size }
+      end
+
+      it "when equivalent but not marked to allow, it raises" do
+        expect do
+          Advert.index [:ad_category_id], name: :on_ad_category_id
+        end.to raise_exception(ArgumentError, /equivalent index definition found/i)
+      end
+
+      it "when equivalent and marked to allow, it is idempotent and doesn't raise" do
+        expect do
+          Advert.index [:ad_category_id], name: :on_ad_category_id, allow_equivalent: true
+        end.to_not change { Advert.index_definitions.size }
+      end
+
+      context 'constraint' do
+        before do
+          class Advert < active_record_base_class.constantize
+            declare_schema { }
+            belongs_to :ad_category
+          end
+        end
+
+        it "when exactly equal, it is idempotent and doesn't raise" do
+          expect do
+            Advert.constraint :ad_category_id, parent_table_name: 'ad_categories', constraint_name: :index_adverts_on_ad_category_id, parent_class_name: 'AdCategory'
+          end.to_not change { Advert.index_definitions.size }
+        end
+
+        it "when equivalent, it is idempotent and doesn't raise" do
+          expect do
+            Advert.constraint :ad_category_id, parent_table_name: 'ad_categories', constraint_name: :constraint_1, parent_class_name: 'AdCategory'
+          end.to_not change { Advert.index_definitions.size }
+        end
+      end
+    end
   end
 end

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

@@ -11,6 +11,7 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
   let(:join_table) { "customers_users" }
   let(:foreign_keys) { ["user_id", "customer_id"] }
   let(:parent_table_names) { ["users", "customers"] }
+  let(:connection) { instance_double(ActiveRecord::Base.connection.class, "connection") }
 
   before do
     load File.expand_path('../prepare_testapp.rb', __dir__)
@@ -30,8 +31,11 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
                                               foreign_key: foreign_keys.first,
                                               association_foreign_key: foreign_keys.last,
                                               active_record: User,
-                                              class_name: 'Customer') }
+                                              class_name: 'Customer',
+                                              klass: Customer) }
       it 'returns a new object' do
+        expect(User).to receive(:connection).and_return(connection)
+
         result = described_class.from_reflection(reflection)
 
         expect(result).to be_a(described_class)
@@ -42,9 +46,7 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
   end
 
   describe 'instance methods' do
-    let(:connection) { instance_double(ActiveRecord::Base.connection.class, "connection") }
-
-    subject { described_class.new(join_table, foreign_keys, parent_table_names) }
+    subject { described_class.new(join_table, foreign_keys, parent_table_names, connection: connection) }
 
     describe '#initialize' do
       it 'stores initialization attributes' do
@@ -53,6 +55,12 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       end
     end
 
+    describe '#connection' do
+      it 'returns the connection' do
+        expect(subject.connection).to be(connection)
+      end
+    end
+
     describe '#table_options' do
       it 'returns empty hash' do
         expect(subject._table_options).to eq({})
@@ -85,14 +93,14 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
     end
 
     describe '#primary_key' do
-      it 'returns false' do
-        expect(subject._declared_primary_key).to eq(false)
+      it 'returns false because there is no single-column PK for ActiveRecord to use' do
+        expect(subject.primary_key).to eq(false)
       end
     end
 
     describe '#_declared_primary_key' do
-      it 'returns false' do
-        expect(subject._declared_primary_key).to eq(false)
+      it 'returns the foreign key pair that are used as the primary key in the database' do
+        expect(subject._declared_primary_key).to eq(["customer_id", "user_id"])
       end
     end
 
@@ -101,10 +109,10 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
         index_definitions = subject.index_definitions_with_primary_key
         expect(index_definitions.size).to eq(2), index_definitions.inspect
 
-        expect(index_definitions.first).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(index_definitions.first.name).to eq('PRIMARY')
-        expect(index_definitions.first.fields).to eq(foreign_keys.reverse)
-        expect(index_definitions.first.unique).to be_truthy
+        expect(index_definitions.last).to be_a(::DeclareSchema::Model::IndexDefinition)
+        expect(index_definitions.last.name).to eq('PRIMARY')
+        expect(index_definitions.last.fields).to eq(foreign_keys.reverse)
+        expect(index_definitions.last.unique).to be_truthy
       end
     end
 
@@ -127,21 +135,38 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       it 'returns two index definitions and does not raise a IndexNameTooLongError' do
         indexes = subject.index_definitions_with_primary_key.to_a
         expect(indexes.size).to eq(2), indexes.inspect
-        expect(indexes.first).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(indexes.first.name).to eq('PRIMARY')
-        expect(indexes.first.fields).to eq(foreign_keys)
-        expect(indexes.first.unique).to be_truthy
         expect(indexes.last).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(indexes.last.name).to eq('index_advertiser_campaigns_tracking_pixels_on_campaign_id')
-        expect(indexes.last.fields).to eq([foreign_keys.last])
-        expect(indexes.last.unique).to be_falsey
+        expect(indexes.last.name).to eq('PRIMARY')
+        expect(indexes.last.fields).to eq(foreign_keys)
+        expect(indexes.last.unique).to be_truthy
+        expect(indexes.first).to be_a(::DeclareSchema::Model::IndexDefinition)
+        expect(indexes.first.name).to eq('index_advertiser_campaigns_tracking_pixels_on_campaign_id')
+        expect(indexes.first.fields).to eq([foreign_keys.last])
+        expect(indexes.first.unique).to be_falsey
       end
     end
 
     describe '#index_definitions' do
-      it 'returns index_definitions_with_primary_key' do
+      it 'returns index_definitions' do
         indexes = subject.index_definitions
+        expect(indexes.size).to eq(1), indexes.inspect
+        expect(indexes.first.columns).to eq(["user_id"])
+        options = [:name, :unique, :where].map { |k| [k, indexes.first.send(k)] }.to_h
+        expect(options).to eq(name: "index_customers_users_on_user_id",
+                              unique: false,
+                              where: nil)
+      end
+    end
+
+    describe '#index_definitions_with_primary_key' do
+      it 'returns index_definitions_with_primary_key' do
+        indexes = subject.index_definitions_with_primary_key
         expect(indexes.size).to eq(2), indexes.inspect
+        expect(indexes.last.columns).to eq(["customer_id", "user_id"])
+        options = [:name, :unique, :where].map { |k| [k, indexes.last.send(k)] }.to_h
+        expect(options).to eq(name: "PRIMARY",
+                              unique: true,
+                              where: nil)
       end
     end
 

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

@@ -77,13 +77,14 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
           let(:options) { { table_name: table_name, length: length } }
 
           context 'with integer length' do
+            let(:fields) { ['last_name'] }
             let(:length) { 2 }
 
-            it { is_expected.to eq(length) }
+            it { is_expected.to eq(last_name: 2) }
           end
 
           context 'with Hash length' do
-            let(:length) { { name: 2 } }
+            let(:length) { { first_name: 2 } }
 
             it { is_expected.to eq(length) }
           end
@@ -91,7 +92,7 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
 
         describe '#options' do
           subject { instance.options }
-          let(:options) { { name: 'my_index', table_name: table_name, unique: false, where: "(name like 'a%')", length: 10 } }
+          let(:options) { { name: 'my_index', table_name: table_name, unique: false, where: "(last_name like 'a%')", length: { last_name: 10, first_name: 5 } } }
 
           it { is_expected.to eq(options.except(:table_name)) }
         end
@@ -163,7 +164,7 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
           it 'returns the indexes for the model' do
             expect(subject.map(&:to_key)).to eq([
               ["index_definition_test_models_on_name", ["name"], { unique: true, where: nil, length: nil }],
-              (["index_definition_test_models_on_name_partial", ["name"], { unique: false, where: nil, length: 10 }] if defined?(Mysql2)),
+              (["index_definition_test_models_on_name_partial", ["name"], { unique: false, where: nil, length: { name: 10 } }] if defined?(Mysql2)),
               ["PRIMARY", ["id"], { unique: true, where: nil, length: nil }]
             ].compact)
           end
@@ -184,7 +185,7 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
 
           it 'skips the ignored index' do
             expect(subject.map(&:to_key)).to eq([
-              (["index_definition_test_models_on_name_partial", ["name"], { unique: false, where: nil, length: 10 }] if defined?(Mysql2)),
+              (["index_definition_test_models_on_name_partial", ["name"], { unique: false, where: nil, length: { name: 10 } }] if defined?(Mysql2)),
               ["PRIMARY", ["id"], { length: nil, unique: true, where: nil }]
             ].compact)
           end
@@ -259,6 +260,69 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         end
       end
     end
+
+    describe '.normalize_index_length' do
+      let(:columns) { [:last_name] }
+      subject { described_class.normalize_index_length(length, columns: columns) }
+
+      context 'with nil length' do
+        let(:length) { nil }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'when Integer' do
+        let(:length) { 10 }
+
+        it { is_expected.to eq(last_name: length) }
+
+        context 'with multiple columns' do
+          let(:columns) { ["last_name", "first_name"] }
+
+          it { expect { subject }.to raise_exception(ArgumentError, /Index length of Integer only allowed when exactly one column; got 10 for \["last_name", "first_name"]/i) }
+        end
+      end
+
+      context 'when empty Hash' do
+        let(:length) { {} }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'when Hash' do
+        let(:length) { { last_name: 10 } }
+
+        it { is_expected.to eq(length) }
+      end
+
+      context 'when Hash with String key' do
+        let(:length) { { "last_name" => 10 } }
+
+        it { is_expected.to eq(last_name: 10) }
+      end
+
+      context 'with multiple columns' do
+        let(:columns) { [:last_name, :first_name] }
+
+        context 'when Hash with String keys' do
+          let(:length) { { "last_name" => 10, "first_name" => 5 } }
+
+          it { is_expected.to eq(last_name: 10, first_name: 5) }
+        end
+      end
+
+      context 'with nil length' do
+        let(:length) { nil }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'with an invalid length' do
+        let(:length) { 10.5 }
+
+        it { expect { subject }.to raise_exception(ArgumentError, /length must be nil or Integer or a Hash of column names to lengths; got 10\.5 for \[:last_name]/i) }
+      end
+    end
   end
   # TODO: fill out remaining tests
 end

data/spec/lib/declare_schema_spec.rb

@@ -37,6 +37,26 @@ RSpec.describe DeclareSchema do
         it     { is_expected.to eq("utf8mb3") }
       end
     end
+
+    context 'when MySQL version not known yet' do
+      before { described_class.remove_instance_variable('@mysql_version') rescue nil }
+      after { described_class.remove_instance_variable('@mysql_version') rescue nil }
+
+      context 'when set' do
+        let(:connection) { double("connection", select_value: "8.0.21") }
+
+        it "is lazy, so it doesn't use the database connection until read" do
+          expect(ActiveRecord::Base).to receive(:connection) do
+            @connection_called = true
+            connection
+          end
+          described_class.default_charset = "utf8"
+          expect(@connection_called).to be_falsey
+          described_class.default_charset
+          expect(@connection_called).to be_truthy
+        end
+      end
+    end
   end
 
   describe '#default_collation' do
@@ -81,6 +101,26 @@ RSpec.describe DeclareSchema do
         it     { is_expected.to eq("utf8mb3_general_ci") }
       end
     end
+
+    context 'when MySQL version not known yet' do
+      before { described_class.remove_instance_variable('@mysql_version') rescue nil }
+      after { described_class.remove_instance_variable('@mysql_version') rescue nil }
+
+      context 'when set' do
+        let(:connection) { double("connection", select_value: "8.0.21") }
+
+        it "is lazy, so it doesn't use the database connection until read" do
+          expect(ActiveRecord::Base).to receive(:connection) do
+            @connection_called = true
+            connection
+          end
+          described_class.default_collation = "utf8_general_ci"
+          expect(@connection_called).to be_falsey
+          described_class.default_collation
+          expect(@connection_called).to be_truthy
+        end
+      end
+    end
   end
 
   describe '#default_text_limit' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 1.4.0.colin.8
+  version: 1.4.0.colin.11
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-18 00:00:00.000000000 Z
+date: 2024-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails