schema_plus_foreign_keys 0.1.8 → 1.0.1

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/abstract_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'abstract/schema_creation'
 
 module SchemaPlus::ForeignKeys
@@ -22,27 +24,16 @@ module SchemaPlus::ForeignKeys
         # constraints; they must be included in the table specification when
         # it's created.  If you're using Sqlite3, this method will raise an
         # error.)
-        def add_foreign_key(*args) # (table_name, column, to_table, primary_key, options = {})
-          options = args.extract_options!
-          case args.length
-          when 2
-            from_table, to_table = args
-          when 4
-            ActiveSupport::Deprecation.warn "4-argument form of add_foreign_key is deprecated.  use add_foreign_key(from_table, to_table, options)"
-            (from_table, column, to_table, primary_key) = args
-            options.merge!(column: column, primary_key: primary_key)
-          end
-
+        def add_foreign_key(from_table, to_table, **options) # (table_name, column, to_table, primary_key, options = {})
           options = options.dup
           options[:column] ||= foreign_key_column_for(to_table)
-          options[:name]   ||= ForeignKeyDefinition.default_name(from_table, options[:column])
 
           foreign_key_sql = add_foreign_key_sql(from_table, to_table, options)
           execute "ALTER TABLE #{quote_table_name(from_table)} #{foreign_key_sql}"
         end
 
         # called directly by AT's bulk_change_table, for migration
-        # change_table :name, :bulk => true { ... }
+        # change_table :name, bulk: true { ... }
         def add_foreign_key_sql(from_table, to_table, options = {}) #:nodoc:
           foreign_key = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, AbstractAdapter.proper_table_name(to_table), options)
           "ADD #{foreign_key.to_sql}"
@@ -53,7 +44,7 @@ module SchemaPlus::ForeignKeys
         end
 
         def self.proper_table_name(name)
-          proper_name = ::ActiveRecord::Migration.new.proper_table_name(name)
+          ::ActiveRecord::Migration.new.proper_table_name(name)
         end
 
         # Remove a foreign key constraint
@@ -66,49 +57,18 @@ module SchemaPlus::ForeignKeys
         # (NOTE: Sqlite3 does not support altering a table to remove
         # foreign-key constraints.  If you're using Sqlite3, this method will
         # raise an error.)
-        def remove_foreign_key(*args)
-          from_table, to_table, options = normalize_remove_foreign_key_args(*args)
+        def remove_foreign_key(from_table, to_table = nil, **options)
           options[:column] ||= foreign_key_column_for(to_table)
           if sql = remove_foreign_key_sql(from_table, to_table, options)
             execute "ALTER TABLE #{quote_table_name(from_table)} #{sql}"
           end
         end
 
-        def normalize_remove_foreign_key_args(*args)
-          options = args.extract_options!
-          if options.has_key? :column_names
-            ActiveSupport::Deprecation.warn ":column_names option is deprecated, use :column"
-            options[:column] = options.delete(:column_names)
-          end
-          if options.has_key? :references_column_names
-            ActiveSupport::Deprecation.warn ":references_column_names option is deprecated, use :primary_key"
-            options[:primary_key] = options.delete(:references_column_names)
-          end
-          if options.has_key? :references_table_name
-            ActiveSupport::Deprecation.warn ":references_table_name option is deprecated, use :to_table"
-            options[:to_table] = options.delete(:references_table_name)
-          end
-          case args.length
-          when 1
-            from_table = args[0]
-          when 2
-            from_table, to_table = args
-          when 3, 4
-            ActiveSupport::Deprecation.warn "3- and 4-argument forms of remove_foreign_key are deprecated.  use add_foreign_key(from_table, to_table, options)"
-            (from_table, column, to_table, primary_key) = args
-            options.merge!(column: column, primary_key: primary_key)
-          else
-            raise ArgumentError, "Wrong number of arguments(#{args.length}) to remove_foreign_key"
-          end
-          to_table ||= options.delete(:to_table)
-          [from_table, to_table, options]
-        end
-
         def get_foreign_key_name(from_table, to_table, options)
           return options[:name] if options[:name]
 
           fks = foreign_keys(from_table)
-          if fks.detect(&its.name == to_table)
+          if fks.detect { |it| it.name == to_table }
             ActiveSupport::Deprecation.warn "remove_foreign_key(table, name) is deprecated.  use remove_foreign_key(table, name: name)"
             return to_table
           end

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/foreign_key_definition.rb

@@ -1,4 +1,5 @@
-require 'openssl'
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/abstract/schema_definitions'
 
 module SchemaPlus::ForeignKeys
@@ -17,28 +18,7 @@ module SchemaPlus::ForeignKeys
       #   true
       #   :initially_deferred
       module ForeignKeyDefinition
-
-        def column_names
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#column_names is deprecated, use Array.wrap(column)"
-          Array.wrap(column)
-        end
-
-        def references_column_names
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_column_names is deprecated, use Array.wrap(primary_key)"
-          Array.wrap(primary_key)
-        end
-
-        def references_table_name
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_table_name is deprecated, use #to_table"
-          to_table
-        end
-
-        def table_name
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#table_name is deprecated, use #from_table"
-          from_table
-        end
-
-        ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :nullify => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
+        ACTIONS = { cascade: "CASCADE", restrict: "RESTRICT", nullify: "SET NULL", set_default: "SET DEFAULT", no_action: "NO ACTION" }.freeze
         ACTION_LOOKUP = ACTIONS.invert.freeze
 
         def initialize(from_table, to_table, options={})
@@ -88,7 +68,7 @@ module SchemaPlus::ForeignKeys
         end
 
         def to_sql
-          sql = name ? "CONSTRAINT #{name} " : ""
+          sql = name ? +"CONSTRAINT #{name} " : +""
           sql << "FOREIGN KEY (#{quoted_column_names.join(", ")}) REFERENCES #{quoted_to_table} (#{quoted_primary_keys.join(", ")})"
           sql << " ON UPDATE #{ACTIONS[on_update]}" if on_update
           sql << " ON DELETE #{ACTIONS[on_delete]}" if on_delete
@@ -109,17 +89,6 @@ module SchemaPlus::ForeignKeys
           ::ActiveRecord::Base.connection.quote_table_name(to_table)
         end
 
-        def self.default_name(from_table, column)
-          name = "fk_#{fixup_schema_name(from_table)}_#{Array.wrap(column).join('_and_')}"
-          name = name.slice(0, 27) + "_" + OpenSSL::Digest::MD5.new.hexdigest(name) if name.length > 60
-          name
-        end
-
-        def self.fixup_schema_name(table_name)
-          # replace . with _
-          table_name.to_s.gsub(/[.]/, '_')
-        end
-
         def match(test)
           return false unless from_table == test.from_table
           [:to_table, :column].reject{ |attr| test.send(attr).blank? }.all? { |attr|

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module ActiveRecord
     module ConnectionAdapters
@@ -7,27 +9,24 @@ module SchemaPlus::ForeignKeys
 
         #:enddoc:
 
-        def remove_column(table_name, column_name, type=nil, options={})
+        def remove_column(table_name, column_name, type=nil, **options)
           foreign_keys(table_name).select { |foreign_key| Array.wrap(foreign_key.column).include?(column_name.to_s) }.each do |foreign_key|
             remove_foreign_key(table_name, name: foreign_key.name)
           end
-          super table_name, column_name, type, options
+          super table_name, column_name, type, **options
         end
 
-        def remove_foreign_key(*args)
-          from_table, to_table, options = normalize_remove_foreign_key_args(*args)
+        def remove_foreign_key(from_table, to_table = nil, **options)
           if options[:if_exists]
             foreign_key_name = get_foreign_key_name(from_table, to_table, options)
             return if !foreign_key_name or not foreign_keys(from_table).detect{|fk| fk.name == foreign_key_name}
           end
           options.delete(:if_exists)
-          super from_table, to_table, options
+          super from_table, to_table, **options
         end
 
         def remove_foreign_key_sql(*args)
-          super.tap { |ret|
-            ret.sub!(/DROP CONSTRAINT/, 'DROP FOREIGN KEY') if ret
-          }
+          super&.sub(/DROP CONSTRAINT/, 'DROP FOREIGN KEY')
         end
 
         def foreign_keys(table_name, name = nil)
@@ -52,11 +51,11 @@ module SchemaPlus::ForeignKeys
                 on_update = ForeignKeyDefinition::ACTION_LOOKUP[on_update] || :restrict
                 on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :restrict
 
-                options = { :name => name,
-                            :on_delete => on_delete,
-                            :on_update => on_update,
-                            :column => columns.gsub('`', '').split(', '),
-                            :primary_key => primary_keys.gsub('`', '').split(', ')
+                options = { name: name,
+                            on_delete: on_delete,
+                            on_update: on_update,
+                            column: columns.gsub('`', '').split(', '),
+                            primary_key: primary_keys.gsub('`', '').split(', ')
                 }
 
                 foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
@@ -92,9 +91,9 @@ module SchemaPlus::ForeignKeys
             to_table = table_namespace_prefix(to_table) + to_table
 
             options = {
-              :name => constraint_name,
-              :column => columns.map { |row| row['column_name'] },
-              :primary_key => columns.map { |row| row['referenced_column_name'] }
+              name: constraint_name,
+              column: columns.map { |row| row['column_name'] },
+              primary_key: columns.map { |row| row['referenced_column_name'] }
             }
 
             ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, to_table, options)

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module ActiveRecord
     module ConnectionAdapters
@@ -61,12 +63,12 @@ module SchemaPlus::ForeignKeys
               on_update = ForeignKeyDefinition::ACTION_LOOKUP[on_update] || :no_action
               on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :no_action
 
-              options = { :name => name,
-                          :on_delete => on_delete,
-                          :on_update => on_update,
-                          :column => columns,
-                          :primary_key => primary_keys,
-                          :deferrable => deferrable }
+              options = { name: name,
+                          on_delete: on_delete,
+                          on_update: on_update,
+                          column: columns,
+                          primary_key: primary_keys,
+                          deferrable: deferrable }
 
               foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
                 from_table,

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module ActiveRecord
     module ConnectionAdapters
@@ -59,12 +61,12 @@ module SchemaPlus::ForeignKeys
               on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :no_action
               deferrable = deferrable ? (initially_deferred ? :initially_deferred : true) : false
 
-              options = { :name => name,
-                          :on_update => on_update,
-                          :on_delete => on_delete,
-                          :column => columns,
-                          :primary_key => primary_keys,
-                          :deferrable => deferrable }
+              options = { name: name,
+                          on_update: on_update,
+                          on_delete: on_delete,
+                          column: columns,
+                          primary_key: primary_keys,
+                          deferrable: deferrable }
 
               foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
                 from_table,

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/table_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys::ActiveRecord::ConnectionAdapters
 
   #
@@ -25,7 +27,7 @@ module SchemaPlus::ForeignKeys::ActiveRecord::ConnectionAdapters
   # definition, via:
   #
   #   create_table :widgets do |t|
-  #      t.string :name, :index => true
+  #      t.string :name, index: true
   #   end
   #
   # For details about the :index option (including unique and multi-column indexes), see the
@@ -36,15 +38,15 @@ module SchemaPlus::ForeignKeys::ActiveRecord::ConnectionAdapters
   #    create_table :posts do |t|  # not DRY
   #       t.references :author
   #    end
-  #    add_foreign_key :posts, :author_id, :references => :authors
+  #    add_foreign_key :posts, :author_id, references: :authors
   #
   #    create_table :posts do |t|  # DRYer
   #       t.references :author
-  #       t.foreign_key :author_id, :references => :authors
+  #       t.foreign_key :author_id, references: :authors
   #    end
   #
   #    create_table :posts do |t|  # Dryest
-  #       t.references :author, :foreign_key => true
+  #       t.references :author, foreign_key: true
   #    end
   #
   # <b>NOTE:</b> In the standard configuration, SchemaPlus::ForeignKeys automatically
@@ -59,7 +61,7 @@ module SchemaPlus::ForeignKeys::ActiveRecord::ConnectionAdapters
   # Finally, the configuration for foreign keys can be overriden on a per-table
   # basis by passing Config options to Migration::ClassMethods#create_table, such as
   #
-  #      create_table :students, :foreign_keys => {:auto_create => false} do
+  #      create_table :students, foreign_keys: {auto_create: false} do
   #         t.references :student
   #      end
   #
@@ -67,46 +69,5 @@ module SchemaPlus::ForeignKeys::ActiveRecord::ConnectionAdapters
 
     attr_accessor :schema_plus_foreign_keys_config #:nodoc:
 
-    if Gem::Requirement.new('= 4.2.0').satisfied_by?(::ActiveRecord.version)
-      def foreign_keys
-        @foreign_keys ||= []
-      end
-
-      def foreign_keys_for_table(*)
-        foreign_keys
-      end
-    elsif Gem::Requirement.new('< 4.2.6').satisfied_by?(::ActiveRecord.version)
-      def foreign_keys_for_table(table)
-        foreign_keys[table] ||= []
-      end
-    else
-      def foreign_keys_for_table(*)
-        foreign_keys
-      end
-    end
-
-    def foreign_key(*args) # (column_names, to_table, primary_key=nil, options=nil)
-      options = args.extract_options!
-      case args.length
-      when 1
-        to_table = args[0]
-        column_names = "#{to_table.to_s.singularize}_id"
-      when 2
-        column_names, to_table = args
-      when 3
-        ActiveSupport::Deprecation.warn "positional arg for foreign primary key is deprecated, use :primary_key option instead"
-        column_names, to_table, primary_key = args
-        options.merge!(:primary_key => primary_key)
-      else
-        raise ArgumentError, "wrong number of arguments (#{args.length}) for foreign_key(column_names, table_name, options)"
-      end
-
-      options.merge!(:column => column_names)
-      options.reverse_merge!(:name => ForeignKeyDefinition.default_name(self.name, column_names))
-      fk = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(self.name, AbstractAdapter.proper_table_name(to_table), options)
-      foreign_keys_for_table(fk.to_table) << fk
-      self
-    end
-
   end
 end

data/lib/schema_plus/foreign_keys/active_record/migration/command_recorder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module ActiveRecord
     module Migration
@@ -6,7 +8,7 @@ module SchemaPlus::ForeignKeys
         attr_accessor :schema_plus_foreign_keys_config #:nodoc:
 
         # seems like this is fixing a rails bug:
-        #   change_table foo, :bulk => true { |t| t.references :bar }
+        #   change_table foo, bulk: true { |t| t.references :bar }
         # results in an 'unknown method :add_reference_sql' (with mysql2)
         #
         # should track it down separately and submit a patch/fix to rails
@@ -16,7 +18,7 @@ module SchemaPlus::ForeignKeys
           options[:references] = nil if polymorphic
           # ugh.  copying and pasting code from ::ActiveRecord::ConnectionAdapters::SchemaStatements#add_reference
           index_options = options.delete(:index)
-          add_column(table_name, "#{ref_name}_id", :integer, options)
+          add_column(table_name, "#{ref_name}_id", :integer, **options)
           add_column(table_name, "#{ref_name}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
           add_index(table_name, polymorphic ? %w[id type].map{ |t| "#{ref_name}_#{t}" } : "#{ref_name}_id", index_options.is_a?(Hash) ? index_options : {}) if index_options
 

data/lib/schema_plus/foreign_keys/middleware/dumper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module Middleware
     module Dumper
@@ -14,7 +16,7 @@ module SchemaPlus::ForeignKeys
           @inline_fks = Hash.new{ |h, k| h[k] = [] }
           @backref_fks = Hash.new{ |h, k| h[k] = [] }
 
-          env.connection.tables_only.each do |table|
+          env.connection.tables.each do |table|
             if (fks = env.connection.foreign_keys(table)).any?
               env.dump.data.has_fks = true
               @inline_fks[table] = fks
@@ -37,7 +39,7 @@ module SchemaPlus::ForeignKeys
 
         # Ignore the foreign key dumps at the end of the schema; we'll put them in/near their tables
         def after(env)
-          env.dump.final.reject!(&it =~/foreign_key/)
+          env.dump.final.reject!{ |it| it =~/foreign_key/ }
         end
 
         private
@@ -66,7 +68,7 @@ module SchemaPlus::ForeignKeys
         def after(env)
           dumped = {}
           env.table.columns.each do |column|
-            if (foreign_key = env.dump.data.inline_fks[env.table.name].find(&its.column.to_s == column.name))
+            if (foreign_key = env.dump.data.inline_fks[env.table.name].find { |it| it.column.to_s == column.name })
               column.options[:foreign_key] = {references: foreign_key.to_table}.merge foreign_key.options_for_dump
               dumped[foreign_key] = true
             end

data/lib/schema_plus/foreign_keys/middleware/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module Middleware
     module Migration
@@ -22,7 +24,13 @@ module SchemaPlus::ForeignKeys
           env.connection.foreign_keys(newname).each do |fk|
             begin
               env.connection.remove_foreign_key(newname, name: fk.name)
-              env.connection.add_foreign_key(newname, fk.to_table, :column => fk.column, :primary_key => fk.primary_key, :name => fk.name.sub(/#{oldname}/, newname), :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
+              env.connection.add_foreign_key(newname, fk.to_table,
+                                             column: fk.column,
+                                             primary_key: fk.primary_key,
+                                             name: fk.name.sub(/#{oldname}/, newname),
+                                             on_update: fk.on_update,
+                                             on_delete: fk.on_delete,
+                                             deferrable: fk.deferrable)
             rescue NotImplementedError
               # sqlite3 can't remote or add foreign keys, so just skip it
             end
@@ -123,9 +131,9 @@ module SchemaPlus::ForeignKeys
           references = fk_opts.delete(:references)
           case env.caller
           when ::ActiveRecord::ConnectionAdapters::TableDefinition
-            env.caller.foreign_key(env.column_name, references, fk_opts)
+            env.caller.foreign_key(references, **fk_opts)
           else
-            env.caller.add_foreign_key(env.table_name, references, fk_opts.merge(:column => env.column_name))
+            env.caller.add_foreign_key(env.table_name, references, **fk_opts)
           end
         end
 
@@ -134,6 +142,7 @@ module SchemaPlus::ForeignKeys
           return nil if opts.nil?
           return :none if opts == false
           opts = {} if opts == true
+          opts[:column] ||= env.column_name
           opts[:references] ||= default_table_name(env)
           opts[:on_update] ||= config.on_update
           opts[:on_delete] ||= config.on_delete
@@ -141,7 +150,7 @@ module SchemaPlus::ForeignKeys
         end
 
         def remove_foreign_key_if_exists(env)
-          env.caller.remove_foreign_key(env.table_name.to_s, column: env.column_name.to_s, :if_exists => true)
+          env.caller.remove_foreign_key(env.table_name.to_s, column: env.column_name.to_s, if_exists: true)
         end
 
         def default_table_name(env)
@@ -159,4 +168,3 @@ module SchemaPlus::ForeignKeys
     end
   end
 end
-

data/lib/schema_plus/foreign_keys/middleware/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module Middleware
 

data/lib/schema_plus/foreign_keys/middleware/mysql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module Middleware
 
@@ -6,7 +8,7 @@ module SchemaPlus::ForeignKeys
         module DropTable
 
           def around(env)
-            if (env.options[:force] == :cascade)
+            if env.options[:force] == :cascade
               env.connection.reverse_foreign_keys(env.table_name).each do |foreign_key|
                 env.connection.remove_foreign_key(foreign_key.from_table, name: foreign_key.name)
               end

data/lib/schema_plus/foreign_keys/middleware/sql.rb

@@ -1,23 +1,9 @@
+# frozen_string_literal: true
+
 module SchemaPlus::ForeignKeys
   module Middleware
     module Sql
       module Table
-        if Gem::Requirement.new('< 5.0').satisfied_by?(::ActiveRecord.version)
-          def after(env)
-            foreign_keys = if env.table_definition.foreign_keys.is_a? Array
-                             env.table_definition.foreign_keys
-                           else
-                             env.table_definition.foreign_keys.values.tap { |v| v.flatten! }
-                           end
-
-            # create foreign key constraints inline in table definition
-            env.sql.body = ([env.sql.body] + foreign_keys.map(&:to_sql)).join(', ')
-
-            # prevents AR >= 4.2.1 from emitting add_foreign_key after the table
-            env.table_definition.foreign_keys.clear
-          end
-        end
-
         module SQLite3
           def before(env)
             env.connection.execute('PRAGMA FOREIGN_KEYS = ON') if env.table_definition.foreign_keys.any?

data/lib/schema_plus/foreign_keys/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module ForeignKeys
-    VERSION = "0.1.8"
+    VERSION = "1.0.1"
   end
 end

data/lib/schema_plus/foreign_keys.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
+
 require 'schema_plus/core'
-require 'schema_plus_compatibility'
-require 'its-it'
 require 'valuable'
 
 require_relative 'foreign_keys/version'

data/lib/schema_plus_foreign_keys.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'schema_plus/foreign_keys'

data/schema_dev.yml

@@ -1,12 +1,13 @@
 ruby:
-    - 2.3.1
+    - 2.5
+    - 2.7
+    - 3.0
+    - 3.1
 activerecord:
-    - 4.2.0
-    - 4.2.1
-    - 4.2.6
-    - 5.0
-    - 5.1
     - 5.2
+    - 6.0
+    - 6.1
+    - 7.0
 db:
     - mysql2
     - sqlite3

data/schema_plus_foreign_keys.gemspec

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'schema_plus/foreign_keys/version'
@@ -18,16 +20,14 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "activerecord", ">= 4.2", "< 5.3"
-  gem.add_dependency "schema_plus_core"
-  gem.add_dependency "schema_plus_compatibility", "~> 0.2"
+  gem.required_ruby_version = ">= 2.5.0"
+
+  gem.add_dependency "activerecord",  ">= 5.2", "< 7.1"
+  gem.add_dependency "schema_plus_core", "~> 3.1.0"
   gem.add_dependency "valuable"
-  gem.add_dependency "its-it", "~> 1.2"
 
-  gem.add_development_dependency "bundler", "~> 1.7"
-  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rake", "~> 13.0"
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "schema_dev", "~> 3.5"
-  gem.add_development_dependency "simplecov"
-  gem.add_development_dependency "simplecov-gem-profile"
+  gem.add_development_dependency "schema_dev", "~> 4.2.0"
 end