declare_schema 1.3.3 → 1.3.4.colin.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 001426fc94493c347f28b363268e9dc192f12f87060db6af5f30c71eb94f0207
-  data.tar.gz: b5a611da740dec158aea306327533df561bc7a7851ad2586c016fbfaeeba4c64
+  metadata.gz: 67383598f5b2515ce62994cc33931e14b5f7736f84f142cdba28da87a3765698
+  data.tar.gz: 1f11e932b6222419aac070f17878108a05072080469195a5b299bdfe604c26c8
 SHA512:
-  metadata.gz: 41376d3bb2313f9939107bd5d111b2628619d3b93784733dd0b51aaf37cbe92cd53e392110830590109e35a1c9385d04d1db7026b11c454604cf483b2bcdb77a
-  data.tar.gz: a68fcdaa6132bf1e055c17f7cf805e686fe75544bbd10720d7fd2cea662aac26b2b5bca5892c7e13efa0e5392ee361329666f95be1b6d93ef61356d6ba385210
+  metadata.gz: e7547cfc57e2c5a06ba8c45923a8aa6bd4631637757a081868081e9d0b63641c9ec24d07eb9bb0eab43e136638e95f4058b01a3b8fa18ee1159d42c6e67f40d9
+  data.tar.gz: a09ca6210c25cb97171622d6c04e19213a8c9b8afc3c131926697533ffbc92dff7290aa61025373aff2367846a8bca2394efd20a77fe2e63e1c27675794b9d77

data/CHANGELOG.md

@@ -4,7 +4,12 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [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.3.3)
+    declare_schema (1.3.4.colin.1)
       rails (>= 5.0)
 
 GEM

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -7,46 +7,53 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :parent_table_name, :child_table_name, :options, :on_delete_cascade
-
-
-      def initialize(model, foreign_key, **options)
-        @model = model
-        @foreign_key = foreign_key.to_s.presence or raise ArgumentError "Foreign key must not be empty: #{foreign_key.inspect}"
-        @options = options
-
-        @child_table_name = model.table_name # unless a table rename, which would happen when a class is renamed??
-        @parent_table_name = options[:parent_table]&.to_s
-        @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
-
-        @constraint_name = options[:constraint_name]&.to_s.presence ||
-                             model.connection.index_name(model.table_name, column: @foreign_key_name)
-        @on_delete_cascade = options[:dependent] == :delete
+      attr_reader :foreign_key_column, :constraint_name, :child_table_name, :parent_table_name, :dependent
+
+      # Caller needs to pass either constraint_name or child_table. The child_table is remembered, but it is not part of the key;
+      # it is just used to compute the default constraint_name if no constraint_name is given.
+      def initialize(foreign_key_column, constraint_name: nil, child_table: nil, parent_table: nil, class_name: nil, dependent: nil)
+        @foreign_key_column = foreign_key_column&.to_s or raise ArgumentError "foreign key must not be empty: #{foreign_key_column.inspect}"
+        @constraint_name = constraint_name&.to_s.presence || ::DeclareSchema::Model::IndexDefinition.default_index_name(child_table, [@foreign_key_column])
+        @child_table_name = child_table&.to_s or raise ArgumentError, "child_table must not be nil"
+        @parent_table_name = parent_table&.to_s || infer_parent_table_name_from_class(class_name) || infer_parent_table_name_from_foreign_key_column(@foreign_key_column)
+        dependent.in?([nil, :delete]) or raise ArgumentError, "dependent: must be nil or :delete"
+        @dependent = dependent
       end
 
       class << self
-        def for_model(model, old_table_name)
-          show_create_table = model.connection.select_rows("show create table #{model.connection.quote_table_name(old_table_name)}").first.last
+        def for_table(table_name, connection, dependent: nil)
+          show_create_table = connection.select_rows("show create table #{connection.quote_table_name(table_name)}").first.last
           constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
 
           constraints.map do |fkc|
-            name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
-            options = {
-              constraint_name: name,
-              parent_table:    parent_table,
-              foreign_key:     foreign_key
-            }
-            options[:dependent] = :delete if fkc['ON DELETE CASCADE'] || model.is_a?(DeclareSchema::Model::HabtmModelShim)
-
-            new(model, foreign_key, **options)
+            constraint_name, foreign_key_column, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
+            dependent_value = :delete if dependent || fkc['ON DELETE CASCADE']
+
+            new(foreign_key_column, constraint_name: constraint_name, child_table: table_name, parent_table: parent_table, dependent: dependent_value)
           end
         end
       end
 
+      def key
+        @key ||= [@parent_table_name, @foreign_key_column, @dependent].freeze
+      end
+
+      def <=>(rhs)
+        key <=> rhs.key
+      end
+
+      alias eql? ==
+
+      def equivalent?(rhs)
+        self == rhs
+      end
+
+      private
+
       # returns the parent class as a Class object
-      # or nil if no :class_name option given
-      def parent_class
-        if (class_name = options[:class_name])
+      # or nil if no @class_name option given
+      def parent_class(class_name)
+        if class_name
           if class_name.is_a?(Class)
             class_name
           else
@@ -55,22 +62,12 @@ module DeclareSchema
         end
       end
 
-      def parent_table_name
-        @parent_table_name ||=
-          parent_class&.try(:table_name) ||
-            foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
-      end
-
-      def <=>(rhs)
-        key <=> rhs.send(:key)
+      def infer_parent_table_name_from_class(class_name)
+        parent_class(class_name)&.try(:table_name)
       end
 
-      alias eql? ==
-
-      private
-
-      def key
-        @key ||= [@child_table_name, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
+      def infer_parent_table_name_from_foreign_key_column(foreign_key_column)
+        foreign_key_column.sub(/_id\z/, '').camelize.constantize.table_name
       end
 
       def hash

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -5,28 +5,21 @@ module DeclareSchema
     class HabtmModelShim
       class << self
         def from_reflection(refl)
-          join_table = refl.join_table
-          foreign_keys_and_classes = [
-            [refl.foreign_key.to_s, refl.active_record],
-            [refl.association_foreign_key.to_s, refl.class_name.constantize]
-          ].sort { |a, b| a.first <=> b.first }
-          foreign_keys = foreign_keys_and_classes.map(&:first)
-          foreign_key_classes = foreign_keys_and_classes.map(&:last)
-          # this may fail in weird ways if HABTM is running across two DB connections (assuming that's even supported)
-          # figure that anybody who sets THAT up can deal with their own migrations...
-          connection = refl.active_record.connection
-
-          new(join_table, foreign_keys, foreign_key_classes, connection)
+          new(refl.join_table, [refl.foreign_key, refl.association_foreign_key],
+                               [refl.active_record.table_name, refl.class_name.constantize.table_name])
         end
       end
 
-      attr_reader :join_table, :foreign_keys, :foreign_key_classes, :connection
+      attr_reader :join_table, :foreign_keys, :parent_table_names
 
-      def initialize(join_table, foreign_keys, foreign_key_classes, connection)
+      def initialize(join_table, foreign_keys, parent_table_names)
+        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
+          raise ArgumentError, "parent_table_names must be <Array[2]>; got #{parent_table_names.inspect}"
         @join_table = join_table
-        @foreign_keys = foreign_keys
-        @foreign_key_classes = foreign_key_classes
-        @connection = connection
+        @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
       end
 
       def _table_options
@@ -38,8 +31,8 @@ module DeclareSchema
       end
 
       def field_specs
-        foreign_keys.each_with_index.each_with_object({}) do |(v, position), result|
-          result[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :bigint, position: position, null: false)
+        foreign_keys.each_with_index.each_with_object({}) do |(foreign_key, i), result|
+          result[foreign_key] = ::DeclareSchema::Model::FieldSpec.new(self, foreign_key, :bigint, position: i, null: false)
         end
       end
 
@@ -48,17 +41,21 @@ module DeclareSchema
       end
 
       def _declared_primary_key
-        false # no single-column primary key declared
+        foreign_keys
       end
 
-      def index_definitions_with_primary_key
+      def index_definitions
         [
-          IndexDefinition.new(self, foreign_keys, unique: true, name: Model::IndexDefinition::PRIMARY_KEY_NAME), # creates a primary composite key on both foreign keys
-          IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
+          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, name: Model::IndexDefinition::PRIMARY_KEY_NAME, unique: true) # creates a primary composite key on both foreign keys
+        ]
+      end
 
       def ignore_indexes
         []
@@ -66,8 +63,8 @@ module DeclareSchema
 
       def constraint_specs
         [
-          ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
-          ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
+          ForeignKeyDefinition.new(foreign_keys.first, child_table: @join_table, parent_table: parent_table_names.first, constraint_name: "#{join_table}_FK1", dependent: :delete),
+          ForeignKeyDefinition.new(foreign_keys.last, child_table: @join_table, parent_table: parent_table_names.last, constraint_name: "#{join_table}_FK2", dependent: :delete)
         ]
       end
     end

data/lib/declare_schema/model/index_definition.rb

@@ -7,27 +7,30 @@ module DeclareSchema
     class IndexDefinition
       include Comparable
 
-      # TODO: replace `fields` with `columns` and remove alias. -Colin
-      attr_reader :table, :fields, :explicit_name, :name, :unique, :where
-      alias columns fields
+      attr_reader :columns, :explicit_name, :name, :unique, :where
+      alias fields columns # TODO: change callers to use columns. -Colin
 
       class IndexNameTooLongError < RuntimeError; end
 
       PRIMARY_KEY_NAME = "PRIMARY"
 
-      def initialize(model, fields, **options)
-        @model = model
-        @table = options.delete(:table_name) || model.table_name
-        @fields = Array.wrap(fields).map(&:to_s)
-        @explicit_name = options[:name] unless options.delete(:allow_equivalent)
-        @name = options.delete(:name) || self.class.default_index_name(@table, @fields)
-        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
+      # 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, name: nil, table_name: nil, allow_equivalent: false, unique: false, where: nil)
+        @name = name || self.class.default_index_name(table_name, columns)
+        @columns = Array.wrap(columns).map(&:to_s)
+        @explicit_name = @name unless allow_equivalent
+        unique.in?([false, true]) or raise ArgumentError, "unique must be true or false: got #{unique.inspect}"
+        if @name == PRIMARY_KEY_NAME
+          unique or raise ArgumentError, "primary key index must be unique"
+        end
+        @unique = unique
 
         if DeclareSchema.max_index_and_constraint_name_length && @name.length > DeclareSchema.max_index_and_constraint_name_length
           raise IndexNameTooLongError, "Index '#{@name}' exceeds configured limit of #{DeclareSchema.max_index_and_constraint_name_length} characters. Give it a shorter name, or adjust DeclareSchema.max_index_and_constraint_name_length if you know your database can accept longer names."
         end
 
-        if (where = options[:where])
+        if where
           @where = where.start_with?('(') ? where : "(#{where})"
         end
       end
@@ -35,33 +38,32 @@ module DeclareSchema
       class << self
         # extract IndexSpecs from an existing table
         # includes the PRIMARY KEY index
-        def for_model(model, old_table_name = nil)
-          t = old_table_name || model.table_name
-
-          primary_key_columns = Array(model.connection.primary_key(t)).presence
-          primary_key_columns or raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
+        def for_table(table_name, ignore_indexes, connection)
+          primary_key_columns = Array(connection.primary_key(table_name))
+          primary_key_columns.present? or raise "could not find primary key for table #{table_name} in #{connection.columns(table_name).inspect}"
 
           primary_key_found = false
-          index_definitions = model.connection.indexes(t).map do |i|
-            model.ignore_indexes.include?(i.name) and next
-            if i.name == PRIMARY_KEY_NAME
-              i.columns == primary_key_columns && i.unique or
-                raise "primary key on #{t} was not unique on #{primary_key_columns} (was unique=#{i.unique} on #{i.columns})"
+          index_definitions = connection.indexes(table_name).map do |index|
+            next if ignore_indexes.include?(index.name)
+
+            if index.name == PRIMARY_KEY_NAME
+              index.columns == primary_key_columns && index.unique or
+                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
-            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name)
+            new(index.columns, name: index.name, unique: index.unique, where: index.where)
           end.compact
 
           if !primary_key_found
-            index_definitions << new(model, primary_key_columns, name: PRIMARY_KEY_NAME, unique: true, where: nil, table_name: old_table_name)
+            index_definitions << new(primary_key_columns, name: PRIMARY_KEY_NAME, unique: true)
           end
           index_definitions
         end
 
-        def default_index_name(table, fields)
+        def default_index_name(table_name, columns)
           index_name = nil
           [:long_index_name, :short_index_name].find do |method_name|
-            index_name = send(method_name, table, fields)
+            index_name = send(method_name, table_name, columns)
             if DeclareSchema.max_index_and_constraint_name_length.nil? || index_name.length <= DeclareSchema.max_index_and_constraint_name_length
               break index_name
             end
@@ -103,11 +105,11 @@ module DeclareSchema
       end
 
       def to_key
-        @key ||= [table, fields, name, unique, where].map(&:to_s)
+        @to_key ||= [name, *settings].freeze
       end
 
       def settings
-        @settings ||= [table, fields, unique].map(&:to_s)
+        @settings ||= [columns, unique, where].freeze
       end
 
       def hash
@@ -123,7 +125,7 @@ module DeclareSchema
       end
 
       def with_name(new_name)
-        self.class.new(@model, @fields, table_name: @table_name, index_name: @index_name, unique: @unique, name: new_name)
+        self.class.new(@columns, name: new_name, unique: @unique, allow_equivalent: @explicit_name.nil?, where: @where)
       end
 
       alias eql? ==

data/lib/declare_schema/model.rb

@@ -49,22 +49,34 @@ module DeclareSchema
     end
 
     module ClassMethods
-      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)
+      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
         end
       end
 
-      def primary_key_index(*fields)
-        index(fields.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
+      def primary_key_index(*columns)
+        index(columns.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
-      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)
+      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
         end
       end
 
@@ -98,8 +110,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
-      # 3. declares a foreign_key constraint
+      # 2. declares an index on the foreign key (optional)
+      # 3. declares a foreign_key constraint (optional)
       def belongs_to(name, scope = nil, **options)
         column_options = {}
 
@@ -119,23 +131,21 @@ module DeclareSchema
         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)
 
-        fk_options = options.dup
-        fk_options[:constraint_name] = options.delete(:constraint) if options.has_key?(:constraint)
-        fk_options[:index_name] = index_options[:name]
+        constraint_name = options.delete(:constraint)
+        index_name = index_options[:name]
 
-        fk = options[:foreign_key]&.to_s || "#{name}_id"
+        dependent_delete = :delete if options.delete(:far_end_dependent) == :delete
 
+        # infer :optional from :null
         if !options.has_key?(:optional)
-          options[:optional] = column_options[:null] # infer :optional from :null
+          options[:optional] = column_options[: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}"
-        fkey = refl.foreign_key or raise "Couldn't find foreign_key for #{name} in #{refl.inspect}"
-        fkey_id_column_options = column_options.dup
+        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
 
         # 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.
@@ -146,27 +156,34 @@ 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.
-        fkey_id_column_options[:pre_migration] = ->(field_spec) do
-          if (inferred_limit = _infer_fk_limit(fkey, refl))
+        foreign_key_column_options[:pre_migration] = ->(field_spec) do
+          if (inferred_limit = _infer_fk_limit(foreign_key_column, refl))
             field_spec.sql_options[:limit] = inferred_limit
           end
         end
 
-        declare_field(fkey.to_sym, :bigint, **fkey_id_column_options)
+        declare_field(foreign_key_column.to_sym, :bigint, **foreign_key_column_options)
 
         if refl.options[:polymorphic]
           foreign_type = options[:foreign_type] || "#{name}_type"
           _declare_polymorphic_type_field(foreign_type, column_options)
-          index([foreign_type, fkey], **index_options) if index_options[:name] != false
+          if ::DeclareSchema.default_generate_indexing && index_name != false
+            index([foreign_type, foreign_key_column], **index_options)
+          end
         else
-          index(fkey, **index_options) if index_options[:name] != false
-          constraint(fkey, **fk_options) if fk_options[:constraint_name] != false
+          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
         end
       end
 
-      def _infer_fk_limit(fkey, refl)
+      def _infer_fk_limit(foreign_key_column, refl)
         if refl.options[:polymorphic]
-          if (fkey_column = columns_hash[fkey.to_s]) && fkey_column.type == :integer
+          if (fkey_column = columns_hash[foreign_key_column.to_s]) && fkey_column.type == :integer
             fkey_column.limit
           end
         else
@@ -208,7 +225,7 @@ module DeclareSchema
       end
 
       def _rails_default_primary_key
-        ::DeclareSchema::Model::IndexDefinition.new(self, [_declared_primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
+        ::DeclareSchema::Model::IndexDefinition.new([_declared_primary_key], name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME, unique: true)
       end
 
       # Declares the "foo_type" field that accompanies the "foo_id"
@@ -279,15 +296,14 @@ module DeclareSchema
         end
       end
 
-      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)
+      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)
         end
       end
 

data/lib/declare_schema/version.rb

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

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

@@ -3,6 +3,7 @@
 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
@@ -221,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 =
@@ -239,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)),
@@ -255,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
@@ -311,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)
@@ -337,7 +343,7 @@ module Generators
         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_name, name: fk.constraint_name)
+                                                             column_name: fk.foreign_key_column, name: fk.constraint_name)
           end
         end
 
@@ -425,7 +431,7 @@ module Generators
           ::DeclareSchema.default_generate_indexing or return []
 
           new_table_name = model.table_name
-          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
+          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_table(old_table_name || new_table_name, model.ignore_indexes, model.connection)
           model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
@@ -485,7 +491,11 @@ 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 []
 
-          existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
+          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)
           model_fks = model.constraint_specs
 
           fks_to_drop = existing_fks - model_fks
@@ -495,13 +505,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_name, name: fk.constraint_name)
+                                                                column_name: fk.foreign_key_column, 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_name, name: fk.constraint_name)
+                                                             column_name: fk.foreign_key_column, name: fk.constraint_name)
           end
 
           [drop_fks + add_fks]
@@ -523,7 +533,7 @@ module Generators
         end
 
         def fk_field_options(model, field_name)
-          foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key.to_s }
+          foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key_column }
           if foreign_key && (parent_table = foreign_key.parent_table_name)
             parent_columns = connection.columns(parent_table) rescue []
             pk_limit =

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -809,6 +809,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.
@@ -829,6 +831,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
@@ -852,7 +892,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|

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

@@ -21,9 +21,9 @@ RSpec.describe DeclareSchema::Model::ForeignKeyDefinition do
     describe 'instance methods' do
       let(:connection) { instance_double(ActiveRecord::Base.connection.class) }
       let(:model) { instance_double('Model', table_name: 'models', connection: connection) }
-      let(:foreign_key) { :network_id }
-      let(:options) { {} }
-      subject { described_class.new(model, foreign_key, **options)}
+      let(:foreign_key_column) { :network_id }
+      let(:options) { { child_table: 'networks' } }
+      subject { described_class.new(foreign_key_column, **options)}
 
       before do
         allow(model.connection).to receive(:index_name).with(any_args) { 'index_on_network_id' }
@@ -31,45 +31,44 @@ RSpec.describe DeclareSchema::Model::ForeignKeyDefinition do
 
       describe '#initialize' do
         it 'normalizes symbols to strings' do
-          expect(subject.foreign_key).to eq('network_id')
+          expect(subject.foreign_key_column).to eq('network_id')
           expect(subject.parent_table_name).to eq('networks')
         end
 
         context 'when most options passed' do
-          let(:options) { { parent_table: :networks, foreign_key: :the_network_id } }
+          let(:options) { { child_table: 'networks', parent_table: :networks } }
 
           it 'normalizes symbols to strings' do
-            expect(subject.foreign_key).to eq('network_id')
-            expect(subject.foreign_key_name).to eq('the_network_id')
+            expect(subject.foreign_key_column).to eq('network_id')
             expect(subject.parent_table_name).to eq('networks')
-            expect(subject.foreign_key).to eq('network_id')
-            expect(subject.constraint_name).to eq('index_on_network_id')
-            expect(subject.on_delete_cascade).to be_falsey
+            expect(subject.foreign_key_column).to eq('network_id')
+            expect(subject.constraint_name).to eq('index_networks_on_network_id')
+            expect(subject.dependent).to be_nil
           end
         end
 
         context 'when all options passed' do
-          let(:options) { { parent_table: :networks, foreign_key: :the_network_id, constraint_name: :constraint_1, dependent: :delete } }
+          let(:options) { { child_table: 'networks', parent_table: :networks, constraint_name: :constraint_1, dependent: :delete } }
 
           it 'normalizes symbols to strings' do
-            expect(subject.foreign_key).to eq('network_id')
-            expect(subject.foreign_key_name).to eq('the_network_id')
+            expect(subject.foreign_key_column).to eq('network_id')
             expect(subject.parent_table_name).to eq('networks')
             expect(subject.constraint_name).to eq('constraint_1')
-            expect(subject.on_delete_cascade).to be_truthy
+            expect(subject.dependent).to eq(:delete)
           end
         end
 
         context 'when constraint name passed as empty string' do
-          let(:options) { { constraint_name: "" } }
+          let(:options) { { child_table: 'networks', constraint_name: "" } }
+
           it 'defaults to rails constraint name' do
-            expect(subject.constraint_name).to eq("index_on_network_id")
+            expect(subject.constraint_name).to eq("index_networks_on_network_id")
           end
         end
 
         context 'when no constraint name passed' do
           it 'defaults to rails constraint name' do
-            expect(subject.constraint_name).to eq("index_on_network_id")
+            expect(subject.constraint_name).to eq("index_networks_on_network_id")
           end
         end
       end
@@ -85,13 +84,13 @@ RSpec.describe DeclareSchema::Model::ForeignKeyDefinition do
         allow(connection).to receive(:index_name).with('models', column: 'network_id') { }
       end
 
-      describe '.for_model' do
-        subject { described_class.for_model(model, old_table_name) }
+      describe '.for_table' do
+        subject { described_class.for_table(old_table_name, model.connection) }
 
-        it 'returns new object' do
-          expect(subject.size).to eq(1), subject.inspect
-          expect(subject.first).to be_kind_of(described_class)
-          expect(subject.first.foreign_key).to eq('network_id')
+        it 'returns definitions' do
+          expect(subject.map(&:key)).to eq([
+            ["networks", "network_id", nil]
+          ])
         end
       end
     end

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

@@ -8,19 +8,19 @@ end
 require_relative '../../../../lib/declare_schema/model/habtm_model_shim'
 
 RSpec.describe DeclareSchema::Model::HabtmModelShim do
-  let(:join_table) { "parent_1_parent_2" }
-  let(:foreign_keys) { ["parent_1_id", "parent_2_id"] }
-  let(:foreign_key_classes) { [Parent1, Parent2] }
+  let(:join_table) { "customers_users" }
+  let(:foreign_keys) { ["user_id", "customer_id"] }
+  let(:parent_table_names) { ["users", "customers"] }
 
   before do
     load File.expand_path('../prepare_testapp.rb', __dir__)
 
-    class Parent1 < ActiveRecord::Base
-      self.table_name = "parent_1s"
+    class User < ActiveRecord::Base
+      self.table_name = "users"
     end
 
-    class Parent2 < ActiveRecord::Base
-      self.table_name = "parent_2s"
+    class Customer < ActiveRecord::Base
+      self.table_name = "customers"
     end
   end
 
@@ -29,12 +29,14 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       let(:reflection) { double("reflection", join_table: join_table,
                                               foreign_key: foreign_keys.first,
                                               association_foreign_key: foreign_keys.last,
-                                              active_record: foreign_key_classes.first,
-                                              class_name: 'Parent1') }
+                                              active_record: User,
+                                              class_name: 'Customer') }
       it 'returns a new object' do
         result = described_class.from_reflection(reflection)
 
         expect(result).to be_a(described_class)
+        expect(result.foreign_keys).to eq(foreign_keys.reverse)
+        expect(result.parent_table_names).to eq(parent_table_names.reverse)
       end
     end
   end
@@ -42,14 +44,12 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
   describe 'instance methods' do
     let(:connection) { instance_double(ActiveRecord::Base.connection.class, "connection") }
 
-    subject { described_class.new(join_table, foreign_keys, foreign_key_classes, connection) }
+    subject { described_class.new(join_table, foreign_keys, parent_table_names) }
 
     describe '#initialize' do
       it 'stores initialization attributes' do
         expect(subject.join_table).to eq(join_table)
-        expect(subject.foreign_keys).to eq(foreign_keys)
-        expect(subject.foreign_key_classes).to be(foreign_key_classes)
-        expect(subject.connection).to be(connection)
+        expect(subject.foreign_keys).to eq(foreign_keys.reverse)
       end
     end
 
@@ -67,51 +67,52 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     describe '#field_specs' do
       it 'returns 2 field specs' do
-        result = subject.field_specs
-        expect(result.size).to eq(2), result.inspect
-
-        expect(result[foreign_keys.first]).to be_a(::DeclareSchema::Model::FieldSpec)
-        expect(result[foreign_keys.first].model).to eq(subject)
-        expect(result[foreign_keys.first].name.to_s).to eq(foreign_keys.first)
-        expect(result[foreign_keys.first].type).to eq(:integer)
-        expect(result[foreign_keys.first].position).to eq(0)
-
-        expect(result[foreign_keys.last]).to be_a(::DeclareSchema::Model::FieldSpec)
-        expect(result[foreign_keys.last].model).to eq(subject)
-        expect(result[foreign_keys.last].name.to_s).to eq(foreign_keys.last)
-        expect(result[foreign_keys.last].type).to eq(:integer)
-        expect(result[foreign_keys.last].position).to eq(1)
+        field_specs = subject.field_specs
+        expect(field_specs.size).to eq(2), field_specs.inspect
+
+        expect(field_specs[foreign_keys.first]).to be_a(::DeclareSchema::Model::FieldSpec)
+        expect(field_specs[foreign_keys.first].model).to eq(subject)
+        expect(field_specs[foreign_keys.first].name.to_s).to eq(foreign_keys.first)
+        expect(field_specs[foreign_keys.first].type).to eq(:integer)
+        expect(field_specs[foreign_keys.first].position).to eq(1)
+
+        expect(field_specs[foreign_keys.last]).to be_a(::DeclareSchema::Model::FieldSpec)
+        expect(field_specs[foreign_keys.last].model).to eq(subject)
+        expect(field_specs[foreign_keys.last].name.to_s).to eq(foreign_keys.last)
+        expect(field_specs[foreign_keys.last].type).to eq(:integer)
+        expect(field_specs[foreign_keys.last].position).to eq(0)
       end
     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
 
     describe '#index_definitions_with_primary_key' do
       it 'returns 2 index definitions' do
-        result = subject.index_definitions_with_primary_key
-        expect(result.size).to eq(2), result.inspect
+        index_definitions = subject.index_definitions_with_primary_key
+        expect(index_definitions.size).to eq(2), index_definitions.inspect
 
-        expect(result.first).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(result.first.name).to eq('PRIMARY')
-        expect(result.first.fields).to eq(['parent_1_id', 'parent_2_id'])
-        expect(result.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
 
     context 'when table and foreign key names are long' do
       let(:join_table) { "advertiser_campaigns_tracking_pixels" }
-      let(:foreign_keys) { ['advertiser_campaign', 'tracking_pixel'] }
-      let(:foreign_key_classes) { [Table1, Table2] }
+      let(:foreign_keys_and_table_names) { [["advertiser_id", "advertisers"], ["campaign_id", "campaigns"]] }
+      let(:foreign_keys) { foreign_keys_and_table_names.map(&:first) }
+      let(:parent_table_names) { foreign_keys_and_table_names.map(&:last) }
 
       before do
         class Table1 < ActiveRecord::Base
@@ -124,19 +125,40 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       end
 
       it 'returns two index definitions and does not raise a IndexNameTooLongError' do
-        result = subject.index_definitions_with_primary_key
-        expect(result.size).to eq(2), result.inspect
-        expect(result.first).to be_a(::DeclareSchema::Model::IndexDefinition)
-        expect(result.first.name).to eq('PRIMARY')
-        expect(result.first.fields).to eq(['advertiser_campaign', 'tracking_pixel'])
-        expect(result.first.unique).to be_truthy
+        indexes = subject.index_definitions_with_primary_key
+        expect(indexes.size).to eq(2), indexes.inspect
+        expect(indexes.last).to be_a(::DeclareSchema::Model::IndexDefinition)
+        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' 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
-        result = subject.index_definitions
-        expect(result.size).to eq(2), result.inspect
+        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
 
@@ -148,18 +170,11 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     describe '#constraint_specs' do
       it 'returns 2 foreign keys' do
-        result = subject.constraint_specs
-        expect(result.size).to eq(2), result.inspect
-
-        expect(result.first).to be_a(::DeclareSchema::Model::ForeignKeyDefinition)
-        expect(result.first.foreign_key).to eq(foreign_keys.first)
-        expect(result.first.parent_table_name).to be(Parent1.table_name)
-        expect(result.first.on_delete_cascade).to be_truthy
-
-        expect(result.last).to be_a(::DeclareSchema::Model::ForeignKeyDefinition)
-        expect(result.last.foreign_key).to eq(foreign_keys.last)
-        expect(result.last.parent_table_name).to be(Parent2.table_name)
-        expect(result.last.on_delete_cascade).to be_truthy
+        constraints = subject.constraint_specs
+        expect(constraints.map(&:key)).to eq([
+          ["customers", "customer_id", :delete],
+          ["users", "user_id", :delete]
+        ])
       end
     end
   end

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

@@ -11,6 +11,7 @@ require_relative '../../../../lib/declare_schema/model/index_definition'
 
 RSpec.describe DeclareSchema::Model::IndexDefinition do
   let(:model_class) { IndexDefinitionTestModel }
+  let(:table_name) { model_class.table_name }
 
   context 'Using declare_schema' do
     before do
@@ -34,28 +35,27 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
       end
     end
 
-    describe 'instance methods' do
-      let(:model) { model_class.new }
-      subject { declared_class.new(model_class) }
+    # TODO: create model_spec.rb and move the Model specs below into it. -Colin
+    context 'Model class methods' do
+      describe '.has index_definitions' do
+        subject { model_class.index_definitions }
 
-      it 'has index_definitions' do
-        expect(model_class.index_definitions).to be_kind_of(Array)
-        expect(model_class.index_definitions.map(&:name)).to eq(['index_index_definition_test_models_on_name'])
-        expect([:name, :fields, :unique].map { |attr| model_class.index_definitions[0].send(attr)}).to eq(
-          ['index_index_definition_test_models_on_name', ['name'], false]
-        )
+        it 'returns indexes without primary key' do
+          expect(subject.map(&:to_key)).to eq([
+            ['index_index_definition_test_models_on_name', ['name'], false, nil],
+          ])
+        end
       end
 
-      it 'has index_definitions_with_primary_key' do
-        expect(model_class.index_definitions_with_primary_key).to be_kind_of(Array)
-        result = model_class.index_definitions_with_primary_key.sort_by(&:name)
-        expect(result.map(&:name)).to eq(['PRIMARY', 'index_index_definition_test_models_on_name'])
-        expect([:name, :fields, :unique].map { |attr| result[0].send(attr)}).to eq(
-          ['PRIMARY', ['id'], true]
-        )
-        expect([:name, :fields, :unique].map { |attr| result[1].send(attr)}).to eq(
-          ['index_index_definition_test_models_on_name', ['name'], false]
-        )
+      describe '.has index_definitions_with_primary_key' do
+        subject { model_class.index_definitions_with_primary_key }
+
+        it 'returns indexes with primary key' do
+          expect(subject.map(&:to_key)).to eq([
+            ['index_index_definition_test_models_on_name', ['name'], false, nil],
+            ['PRIMARY', ['id'], true, nil],
+          ])
+        end
       end
     end
 
@@ -80,29 +80,36 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
         ActiveRecord::Base.connection.schema_cache.clear!
       end
 
-      describe 'for_model' do
-        subject { described_class.for_model(model_class) }
+      describe 'for_table' do
+        let(:ignore_indexes) { model_class.ignore_indexes }
+        subject { described_class.for_table(model_class.table_name, ignore_indexes, model_class.connection) }
 
         context 'with single-column PK' do
           it 'returns the indexes for the model' do
-            expect(subject.size).to eq(2), subject.inspect
-            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
-              ['index_definition_test_models_on_name', ['name'], true]
-            )
-            expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
-              ['PRIMARY', ['id'], true]
-            )
+            expect(subject.map(&:to_key)).to eq([
+              ["index_definition_test_models_on_name", ["name"], true, nil],
+              ["PRIMARY", ["id"], true, nil]
+            ])
           end
         end
 
-        context 'with compound-column PK' do
+        context 'with composite (multi-column) PK' do
           let(:model_class) { IndexDefinitionCompoundIndexModel }
 
           it 'returns the indexes for the model' do
-            expect(subject.size).to eq(1), subject.inspect
-            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
-              ['PRIMARY', ['fk1_id', 'fk2_id'], true]
-            )
+            expect(subject.map(&:to_key)).to eq([
+              ["PRIMARY", ["fk1_id", "fk2_id"], true, nil]
+            ])
+          end
+        end
+
+        context 'with ignored_indexes' do
+          let(:ignore_indexes) { ['index_definition_test_models_on_name'] }
+
+          it 'skips the ignored index' do
+            expect(subject.map(&:to_key)).to eq([
+              ["PRIMARY", ["id"], true, nil]
+            ])
           end
         end
       end

metadata

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