declare_schema 1.4.0.colin.7 → 1.4.0.colin.8

data/lib/declare_schema.rb

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

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
@@ -335,9 +336,9 @@ module Generators
         end
 
         def create_constraints(model)
-          model.constraint_specs.map do |fk|
+          model.constraint_definitions.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 +426,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.to_a
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
@@ -485,8 +486,12 @@ 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)
-          model_fks = model.constraint_specs.to_a
+          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_definitions.to_a
 
           fks_to_drop = existing_fks - model_fks
           fks_to_add = model_fks - existing_fks
@@ -495,13 +500,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,9 +528,8 @@ module Generators
         end
 
         def fk_field_options(model, field_name)
-          foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key.to_s }
-          if foreign_key && (parent_table = foreign_key.parent_table_name)
-            parent_columns = connection.columns(parent_table) rescue []
+          if (foreign_key = model.constraint_definitions.find { |fk| field_name == fk.foreign_key_column })
+            parent_columns = connection.columns(foreign_key.parent_table_name) rescue []
             pk_limit =
               if (pk_column = parent_columns.find { |column| column.name.to_s == "id" }) # right now foreign keys assume id is the target
                 pk_column.limit
@@ -585,6 +589,8 @@ module Generators
           case charset
           when "utf8"
             "utf8_general_ci"
+          when "utf8mb3"
+            "utf8mb3_general_ci"
           when "utf8mb4"
             "utf8mb4_general_ci"
           end

data/spec/lib/declare_schema/field_spec_spec.rb

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

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -391,6 +391,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
       Advert.field_specs.delete(:c_id)
       Advert.index_definitions.delete_if { |spec| spec.fields == ["c_id"] }
+      Advert.constraint_definitions.delete_if { |spec| spec.foreign_key_column == "c_id" }
 
       # You can avoid generating the index by specifying `index: false`
 
@@ -403,13 +404,13 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       expect(Generators::DeclareSchema::Migration::Migrator.run).to(
         migrate_up(<<~EOS.strip)
           add_column :adverts, :category_id, :integer, limit: 8, null: false
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
+          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id" if defined?(Mysql2)}
        EOS
       )
 
       Advert.field_specs.delete(:category_id)
       Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
+      Advert.constraint_definitions.delete_if { |spec| spec.foreign_key_column == "category_id" }
 
       # You can specify the index name with index: 'name' [deprecated]
 
@@ -425,13 +426,13 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         migrate_up(<<~EOS.strip)
           add_column :adverts, :category_id, :integer, limit: 8, null: false
           add_index :adverts, [:category_id], name: :my_index
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
+          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :my_index" if defined?(Mysql2)}
         EOS
       )
 
       Advert.field_specs.delete(:category_id)
       Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
+      Advert.constraint_definitions.delete_if { |spec| spec.foreign_key_column == "category_id" }
 
       # You can specify the index name with index: { name: }'name', unique: true|false }
 
@@ -443,15 +444,15 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
       expect(Generators::DeclareSchema::Migration::Migrator.run).to(
         migrate_up(<<~EOS.strip)
-            add_column :adverts, :category_id, :integer, limit: 8, null: false
-            add_index :adverts, [:category_id], name: :my_index
-            #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-          "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
-      EOS
+          add_column :adverts, :category_id, :integer, limit: 8, null: false
+          add_index :adverts, [:category_id], name: :my_index
+          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :my_index" if defined?(Mysql2)}
+        EOS
       )
 
       Advert.field_specs.delete(:category_id)
       Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
+      Advert.constraint_definitions.delete_if { |spec| spec.foreign_key_column == "category_id" }
 
       ### Timestamps and Optimimistic Locking
 
@@ -470,12 +471,8 @@ RSpec.describe 'DeclareSchema Migration Generator' do
           add_column :adverts, :created_at, :datetime, null: true
           add_column :adverts, :updated_at, :datetime, null: true
           add_column :adverts, :lock_version, :integer#{lock_version_limit}, null: false, default: 1
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
         EOS
         .and migrate_down(<<~EOS.strip)
-            #{"remove_foreign_key :adverts, name: :index_adverts_on_c_id\n" +
-              "remove_foreign_key :adverts, name: :index_adverts_on_category_id" if defined?(Mysql2)}
             remove_column :adverts, :lock_version
             remove_column :adverts, :updated_at
             remove_column :adverts, :created_at
@@ -506,15 +503,15 @@ RSpec.describe 'DeclareSchema Migration Generator' do
           add_column :adverts, :category_id, :integer, limit: 8, null: false
           add_index :adverts, [:title], name: :index_adverts_on_title
           add_index :adverts, [:category_id], name: :my_index
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
+          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :my_index" if defined?(Mysql2)}
         EOS
       )
 
       Advert.field_specs.delete(:category_id)
       Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] || spec.fields == ["category_id"] }
+      Advert.constraint_definitions.delete_if { |spec| spec.foreign_key_column == "category_id" }
 
-      # You can ask for a unique index
+      # You can ask for a unique index (deprecated syntax; use index: { unique: true } instead).
 
       class Advert < ActiveRecord::Base
         declare_schema do
@@ -526,8 +523,6 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         migrate_up(<<~EOS.strip)
           add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
           add_index :adverts, [:title], name: :index_adverts_on_title, unique: true
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
         EOS
       )
 
@@ -545,8 +540,6 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         migrate_up(<<~EOS.strip)
           add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
           add_index :adverts, [:title], name: :my_index
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
         EOS
       )
 
@@ -555,6 +548,9 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       # You can ask for an index outside of the fields block
 
       class Advert < ActiveRecord::Base
+        declare_schema do
+          string :title, limit: 250, null: true
+        end
         index :title
       end
 
@@ -562,8 +558,6 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         migrate_up(<<~EOS.strip)
           add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
           add_index :adverts, [:title], name: :index_adverts_on_title
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
         EOS
       )
 
@@ -579,8 +573,6 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         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_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
         EOS
       )
 
@@ -596,8 +588,6 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         migrate_up(<<~EOS.strip)
           add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
           add_index :adverts, [:title, :category_id], name: :index_adverts_on_title_and_category_id
-          #{"add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-            "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id" if defined?(Mysql2)}
         EOS
       )
 
@@ -627,16 +617,8 @@ RSpec.describe 'DeclareSchema Migration Generator' do
           rename_table :adverts, :ads
           add_column :ads, :title, :string, limit: 250, null: true#{charset_and_collation}
           add_column :ads, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
-          #{if defined?(Mysql2)
-              "add_foreign_key :adverts, :categories, column: :category_id, name: :index_adverts_on_category_id\n" +
-              "add_foreign_key :adverts, :categories, column: :c_id, name: :index_adverts_on_c_id"
-            end}
-          EOS
+        EOS
           .and migrate_down(<<~EOS.strip)
-            #{if defined?(Mysql2)
-                "remove_foreign_key :adverts, name: :index_adverts_on_c_id\n" +
-                "remove_foreign_key :adverts, name: :index_adverts_on_category_id"
-              end}
             remove_column :ads, :body
             remove_column :ads, :title
             rename_table :ads, :adverts

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_name: 'advertisers' } }
+      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,63 +31,64 @@ 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_name: 'advertisers', parent_class_name: 'Network' } }
 
           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_advertisers_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_name: 'advertisers', parent_class_name: 'Network', 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
 
         describe `#<=>` do
+          let(:foreign_key_column) { :the_network_id }
+
           context 'when class name not passed' do
-            let(:options) { { foreign_key: :the_network_id, constraint_name: :constraint_1, dependent: :delete } }
+            let(:options) { { child_table_name: 'advertisers', constraint_name: :constraint_1, dependent: :delete } }
 
-            it 'compares equal without requring the parent class' do
+            it 'compares equal without requiring the parent class' do
               expect(subject <=> subject).to eq(0)
             end
           end
 
           context 'when class name passed' do
-            let(:options) { { foreign_key: :the_network_id, class_name: 'TheNetwork', constraint_name: :constraint_1 } }
+            let(:options) { { child_table_name: 'advertisers', parent_class_name: 'TheNetwork', constraint_name: :constraint_1 } }
 
-            it 'compares equal without requring the parent class' do
+            it 'compares equal without requiring the parent class' do
               expect(subject <=> subject).to eq(0)
             end
           end
         end
 
         context 'when constraint name passed as empty string' do
-          let(:options) { { constraint_name: "" } }
+          let(:options) { { child_table_name: 'advertisers', 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_advertisers_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_advertisers_on_network_id")
           end
         end
       end
@@ -103,13 +104,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,20 +67,20 @@ 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
 
@@ -98,20 +98,21 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
 
     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.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
       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,23 @@ 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.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
       end
     end
 
     describe '#index_definitions' 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
+        expect(indexes.size).to eq(2), indexes.inspect
       end
     end
 
@@ -146,21 +151,13 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       end
     end
 
-    describe '#constraint_specs' do
+    describe '#constraint_definitions' 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
-
-        sample = result.to_a.last
-        expect(sample).to be_a(::DeclareSchema::Model::ForeignKeyDefinition)
-        expect(sample.foreign_key).to eq(foreign_keys.last)
-        expect(sample.parent_table_name).to be(Parent2.table_name)
-        expect(sample.on_delete_cascade).to be_truthy
+        constraints = subject.constraint_definitions
+        expect(constraints.map(&:key)).to eq([
+          ["customers_users", "customer_id", :delete],
+          ["customers_users", "user_id", :delete]
+        ])
       end
     end
   end