declare_schema 1.4.0.colin.8 → 1.4.0.colin.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca0ed75221c664e2a5c59bff495a971495922f7f31ea0fb548fb67f0ad0eb639
-  data.tar.gz: fc76669be291fff9da61353f7f040ba14327e1359f712a963e5865ed948034c8
+  metadata.gz: 7e20de5eeec8ea9436d2fd674f5ff33f20888cfb87e17456fd278a38504bbede
+  data.tar.gz: 259d8dd463292836e40d3fe07261743e714d588440d8a988183daa32f0c8a4d9
 SHA512:
-  metadata.gz: 47b53d7e5306a3b2ada9296494af897738056c1c5e14e35e0b3967daf3176e07cf48c74560e2ccd659d0c1b8bc466e6d29f632f86b25bff568bcc4b6dcf672af
-  data.tar.gz: 9af422633cae00b32e94bf64d0e6e9445aee83849e4898633384af679b61c877a22ce14f1b20c225d17f4a1546ee3c3a1867e0661516f186717895a658d4b2eb
+  metadata.gz: 18dc843b60c81ace18bc692f1e8d76038d50695081ab846b14f0653aa4d6a755666417f4d7190429aa83e9eb9fffba02d61c71b2a5c44ef7dbf69baf401e7e31
+  data.tar.gz: 94bf1af85ecdc252e08f6453018edc6a2f216e65aa6d7fce0ab7399058097d6a0e1a834e02d350789e8e6fb3485050979dde543e2036e048cc914dd6ffb5cdad

data/CHANGELOG.md

@@ -10,7 +10,12 @@ 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.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.9)
       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
         @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

@@ -111,31 +111,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 +187,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/version.rb

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

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)

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 { }

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

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.9
 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-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails