declare_schema 1.4.0.colin.7 → 1.4.0.colin.9

data/lib/declare_schema/version.rb

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

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
@@ -203,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
 
@@ -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)
@@ -335,9 +341,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 +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.to_a
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
@@ -485,8 +491,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 +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,9 +533,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 +594,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,17 +404,17 @@ 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]
 
-      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
@@ -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
@@ -490,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
@@ -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
       )
 
@@ -578,9 +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_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_index :adverts, [:title], name: :my_index, length: { title: 10 }
         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
@@ -838,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.
@@ -858,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
@@ -881,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|
@@ -1178,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/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