safe-pg-migrations 1.2.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d981ad3d9694961fa982676398e257817a2f20fb5ef28111c664da67d8caef19
-  data.tar.gz: 7792a0f882fe9c594a1a0309bba12f03c2d0d18d5a0ef68fe49e1681da486ba6
+  metadata.gz: 2fb891279f68c60f15f81b6e7ccbc425750443c3ee294080c2286bb059ed2e89
+  data.tar.gz: f4a8d59c4ee5abf004e4141db1d09d3cde33ff42f180c03526767535f20a5acd
 SHA512:
-  metadata.gz: a3d03df54c2a401ea4d7d178d66c8fc49c605cebc1e15f87a69e262df2bfc6433ef7ab86ae21e3ce88b52224a0c9fd14c3cf5f923e109ef06da2d55072fc7d3e
-  data.tar.gz: b28101c7aedcdfb6fc3680ce9c5b14b459ed90fecf21aaf598942f6c91ebd757f1ed608f71c00e622ec9b24cf1f719a6450ae3ef28abd4f07476fd02f7c54242
+  metadata.gz: 5b8c48e973fc0296a54c2a8cceaa3b3c8c8d3380cf15a87ea5154e2ebfc28a8aa852172fe020946d8c758a4d1518bf22fe06eda08d31d318d9176df88820ac8e
+  data.tar.gz: e88101b365a400e21ca76cf64b1818fba36e8875958989e1864391faf476b793596bbcfbd6bed4c53db46d93a16981334f45fe83124dc04e2eb7132029a712e3

data/README.md

@@ -2,6 +2,8 @@
 
 ActiveRecord migrations for Postgres made safe.
 
+![safe-pg-migrations](./logo.png)
+
 ## Requirements
 
 - Ruby 2.5+
@@ -91,7 +93,7 @@ When **Safe PG Migrations** is used, migrations are not wrapped in a transaction
 - In order to be able to retry statements that have failed because of a lock timeout, we have to be outside a transaction.
 - In order to add an index concurrently, we have to be outside a transaction.
 
-Note that if a migration fails, it won't be rollbacked. This can result in migrations being partially applied. In that case, they need to be manually reverted.
+Note that if a migration fails, it won't be rolled back. This can result in migrations being partially applied. In that case, they need to be manually reverted.
 
 </details>
 
@@ -108,7 +110,7 @@ PG will still needs to update every row of the table, and will most likely state
 
 <blockquote>
 
-**Note: Pre-postgre 11**
+**Note: Pre-postgres 11**
 Adding a column with a default value and a not-null constraint is [dangerous](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
 
 **Safe PG Migrations** makes it safe by:
@@ -120,7 +122,7 @@ Adding a column with a default value and a not-null constraint is [dangerous](ht
 
 Note: the addition of the not null constraint may timeout. In that case, you may want to add the not-null constraint as initially not valid and validate it in a separate statement. See [Adding a not-null constraint on Postgres with minimal locking](https://medium.com/doctolib-engineering/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c).
 
-</blockquote>    
+</blockquote>
 
 </details>
 
@@ -137,7 +139,7 @@ If you still get lock timeout while adding / removing indexes, it might be for o
 
 </details>
 
-<details><summary id="safe_add_foreign_key">safe <code>add_foreign_key</code> (and <code>add_reference</code>)</summary>
+<details><summary id="safe_add_foreign_key">Safe <code>add_foreign_key</code> (and <code>add_reference</code>)</summary>
 
 Adding a foreign key requires a `SHARE ROW EXCLUSIVE` lock, which **prevent writing in the tables** while the migration is running.
 
@@ -150,7 +152,7 @@ Adding the constraint itself is rather fast, the major part of the time is spent
 
 <details><summary>Retry after lock timeout</summary>
 
-When a statement fails with a lock timeout, **Safe PG Migrations** retries it (5 times max) [list of retryable statments](https://github.com/doctolib/safe-pg-migrations/blob/66933256252b6bbf12e404b829a361dbba30e684/lib/safe-pg-migrations/plugins/statement_retrier.rb#L5)
+When a statement fails with a lock timeout, **Safe PG Migrations** retries it (5 times max) [list of retriable statements](https://github.com/doctolib/safe-pg-migrations/blob/66933256252b6bbf12e404b829a361dbba30e684/lib/safe-pg-migrations/plugins/statement_retrier.rb#L5)
 </details>
 
 <details><summary>Blocking activity logging</summary>
@@ -208,6 +210,8 @@ So you can actually check that the `CREATE INDEX` statement will be performed co
 ```ruby
 SafePgMigrations.config.safe_timeout = 5.seconds # Lock and statement timeout used for all DDL operations except from CREATE / DROP INDEX
 
+SafePgMigrations.config.blocking_activity_logger_verbose = true # Outputs the raw blocking queries on timeout. When false, outputs information about the lock instead
+
 SafePgMigrations.config.blocking_activity_logger_margin = 1.second # Delay to output blocking queries before timeout. Must be shorter than safe_timeout
 
 SafePgMigrations.config.batch_size = 1000 # Size of the batches used for backfilling when adding a column with a default value pre-PG11
@@ -217,11 +221,11 @@ SafePgMigrations.config.retry_delay = 1.minute # Delay between retries for retry
 SafePgMigrations.config.max_tries = 5 # Number of retries before abortion of the migration
 ```
 
-## Runnings tests
+## Running tests
 
 ```bash
 bundle
-psql -h localhost -U postgres -c 'CREATE DATABASE safe_pg_migrations_test'
+psql -h localhost -c 'CREATE DATABASE safe_pg_migrations_test'
 rake test
 ```
 
@@ -255,3 +259,4 @@ Interesting reads:
 - [Safe Operations For High Volume PostgreSQL](https://www.braintreepayments.com/blog/safe-operations-for-high-volume-postgresql/)
 - [Rails Migrations with Zero Downtime](https://blog.codeship.com/rails-migrations-zero-downtime/)
 - [Stop worrying about PostgreSQL locks in your Rails migrations](https://medium.com/doctolib/stop-worrying-about-postgresql-locks-in-your-rails-migrations-3426027e9cc9)
+- [PostgreSQL at Scale: Database Schema Changes Without Downtime](https://medium.com/paypal-tech/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680)

data/lib/safe-pg-migrations/base.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
+require 'ruby2_keywords'
 require 'safe-pg-migrations/configuration'
 require 'safe-pg-migrations/plugins/verbose_sql_logger'
 require 'safe-pg-migrations/plugins/blocking_activity_logger'
 require 'safe-pg-migrations/plugins/statement_insurer'
 require 'safe-pg-migrations/plugins/statement_retrier'
-require 'safe-pg-migrations/plugins/idem_potent_statements'
+require 'safe-pg-migrations/plugins/idempotent_statements'
 require 'safe-pg-migrations/plugins/useless_statements_logger'
+require 'safe-pg-migrations/plugins/legacy_active_record_support'
 
 module SafePgMigrations
   # Order matters: the bottom-most plugin will have precedence
   PLUGINS = [
     BlockingActivityLogger,
-    IdemPotentStatements,
+    IdempotentStatements,
     StatementRetrier,
     StatementInsurer,
     UselessStatementsLogger,
+    LegacyActiveRecordSupport,
   ].freeze
 
   class << self
@@ -50,13 +53,13 @@ module SafePgMigrations
       @alternate_connection = nil
     end
 
-    def say(*args)
+    ruby2_keywords def say(*args)
       return unless current_migration
 
       current_migration.say(*args)
     end
 
-    def say_method_call(method, *args)
+    ruby2_keywords def say_method_call(method, *args)
       say "#{method}(#{args.map(&:inspect) * ', '})", true
     end
 
@@ -84,13 +87,23 @@ module SafePgMigrations
       true
     end
 
-    SAFE_METHODS = %i[execute add_column add_index add_reference add_belongs_to change_column_null].freeze
+    SAFE_METHODS = %i[
+      execute
+      add_column
+      add_index
+      add_reference
+      add_belongs_to
+      change_column_null
+      add_foreign_key
+    ].freeze
+
     SAFE_METHODS.each do |method|
       define_method method do |*args|
         return super(*args) unless respond_to?(:safety_assured)
 
         safety_assured { super(*args) }
       end
+      ruby2_keywords method
     end
   end
 end

data/lib/safe-pg-migrations/configuration.rb

@@ -6,6 +6,7 @@ module SafePgMigrations
   class Configuration
     attr_accessor :safe_timeout
     attr_accessor :blocking_activity_logger_margin
+    attr_accessor :blocking_activity_logger_verbose
     attr_accessor :batch_size
     attr_accessor :retry_delay
     attr_accessor :max_tries
@@ -13,6 +14,7 @@ module SafePgMigrations
     def initialize
       self.safe_timeout = 5.seconds
       self.blocking_activity_logger_margin = 1.second
+      self.blocking_activity_logger_verbose = true
       self.batch_size = 1000
       self.retry_delay = 1.minute
       self.max_tries = 5

data/lib/safe-pg-migrations/plugins/blocking_activity_logger.rb

@@ -1,28 +1,19 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  module BlockingActivityLogger
-    SELECT_BLOCKING_QUERIES_SQL = <<~SQL.squish
-      SELECT blocking_activity.query, blocked_activity.xact_start as start
-      FROM pg_catalog.pg_locks           blocked_locks
-      JOIN pg_catalog.pg_stat_activity   blocked_activity
-        ON blocked_activity.pid = blocked_locks.pid
-      JOIN pg_catalog.pg_locks           blocking_locks
-        ON blocking_locks.locktype = blocked_locks.locktype
-        AND blocking_locks.DATABASE      IS NOT DISTINCT FROM blocked_locks.DATABASE
-        AND blocking_locks.relation      IS NOT DISTINCT FROM blocked_locks.relation
-        AND blocking_locks.page          IS NOT DISTINCT FROM blocked_locks.page
-        AND blocking_locks.tuple         IS NOT DISTINCT FROM blocked_locks.tuple
-        AND blocking_locks.virtualxid    IS NOT DISTINCT FROM blocked_locks.virtualxid
-        AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
-        AND blocking_locks.classid       IS NOT DISTINCT FROM blocked_locks.classid
-        AND blocking_locks.objid         IS NOT DISTINCT FROM blocked_locks.objid
-        AND blocking_locks.objsubid      IS NOT DISTINCT FROM blocked_locks.objsubid
-        AND blocking_locks.pid != blocked_locks.pid
-      JOIN pg_catalog.pg_stat_activity   blocking_activity
-        ON blocking_activity.pid = blocking_locks.pid
-      WHERE blocked_locks.pid = %d
-    SQL
+  module BlockingActivityLogger # rubocop:disable Metrics/ModuleLength
+    FILTERED_COLUMNS = %w[
+      blocked_activity.xact_start
+      blocked_locks.locktype
+      blocked_locks.mode
+      blocking_activity.pid
+      blocked_locks.transactionid
+    ].freeze
+
+    VERBOSE_COLUMNS = %w[
+      blocking_activity.query
+      blocked_activity.xact_start
+    ].freeze
 
     %i[
       add_column remove_column add_foreign_key remove_foreign_key change_column_default change_column_null create_table
@@ -30,10 +21,37 @@ module SafePgMigrations
       define_method method do |*args, &block|
         log_blocking_queries { super(*args, &block) }
       end
+      ruby2_keywords method
     end
 
     private
 
+    def select_blocking_queries_sql
+      columns = SafePgMigrations.config.blocking_activity_logger_verbose ? VERBOSE_COLUMNS : FILTERED_COLUMNS
+
+      <<~SQL.squish
+        SELECT #{columns.join(', ')}
+        FROM pg_catalog.pg_locks           blocked_locks
+        JOIN pg_catalog.pg_stat_activity   blocked_activity
+          ON blocked_activity.pid = blocked_locks.pid
+        JOIN pg_catalog.pg_locks           blocking_locks
+          ON blocking_locks.locktype = blocked_locks.locktype
+          AND blocking_locks.DATABASE      IS NOT DISTINCT FROM blocked_locks.DATABASE
+          AND blocking_locks.relation      IS NOT DISTINCT FROM blocked_locks.relation
+          AND blocking_locks.page          IS NOT DISTINCT FROM blocked_locks.page
+          AND blocking_locks.tuple         IS NOT DISTINCT FROM blocked_locks.tuple
+          AND blocking_locks.virtualxid    IS NOT DISTINCT FROM blocked_locks.virtualxid
+          AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
+          AND blocking_locks.classid       IS NOT DISTINCT FROM blocked_locks.classid
+          AND blocking_locks.objid         IS NOT DISTINCT FROM blocked_locks.objid
+          AND blocking_locks.objsubid      IS NOT DISTINCT FROM blocked_locks.objsubid
+          AND blocking_locks.pid != blocked_locks.pid
+        JOIN pg_catalog.pg_stat_activity   blocking_activity
+          ON blocking_activity.pid = blocking_locks.pid
+        WHERE blocked_locks.pid = %d
+      SQL
+    end
+
     def log_blocking_queries
       delay_before_logging =
         SafePgMigrations.config.safe_timeout - SafePgMigrations.config.blocking_activity_logger_margin
@@ -41,7 +59,7 @@ module SafePgMigrations
       blocking_queries_retriever_thread =
         Thread.new do
           sleep delay_before_logging
-          SafePgMigrations.alternate_connection.query(SELECT_BLOCKING_QUERIES_SQL % raw_connection.backend_pid)
+          SafePgMigrations.alternate_connection.query(select_blocking_queries_sql % raw_connection.backend_pid)
         end
 
       yield
@@ -66,7 +84,7 @@ module SafePgMigrations
           "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:", true
         )
         SafePgMigrations.say '', true
-        queries.each { |query, start_time| SafePgMigrations.say "#{format_start_time start_time}:  #{query}", true }
+        output_blocking_queries(queries)
         SafePgMigrations.say(
           'Beware, some of those queries might run in a transaction. In this case the locking query might be '\
           'located elsewhere in the transaction',
@@ -78,7 +96,24 @@ module SafePgMigrations
       raise
     end
 
+    def output_blocking_queries(queries)
+      if SafePgMigrations.config.blocking_activity_logger_verbose
+        queries.each { |query, start_time| SafePgMigrations.say "#{format_start_time start_time}:  #{query}", true }
+      else
+        queries.each do |start_time, locktype, mode, pid, transactionid|
+          SafePgMigrations.say(
+            "#{format_start_time(start_time)}: lock type: #{locktype || 'null'}, " \
+              "lock mode: #{mode || 'null'}, " \
+              "lock pid: #{pid || 'null'}, " \
+              "lock transactionid: #{transactionid || 'null'}",
+            true
+          )
+        end
+      end
+    end
+
     def format_start_time(start_time, reference_time = Time.now)
+      start_time = Time.parse(start_time) unless start_time.is_a? Time
       duration = (reference_time - start_time).round
       "transaction started #{duration} #{'second'.pluralize(duration)} ago"
     end

data/lib/safe-pg-migrations/plugins/{idem_potent_statements.rb → idempotent_statements.rb}

@@ -1,30 +1,40 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  module IdemPotentStatements
-    def add_index(table_name, column_name, **options)
-      index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, index_column_names(column_name))
-      return super unless index_name_exists?(table_name, index_name)
+  module IdempotentStatements
+    ruby2_keywords def add_index(table_name, column_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
 
-      return if index_valid?(index_name)
+      index_definition, = add_index_options(table_name, column_name, **options)
 
-      remove_index(table_name, name: index_name)
+      return super unless index_name_exists?(index_definition.table, index_definition.name)
+
+      if index_valid?(index_definition.name)
+        SafePgMigrations.say(
+          "/!\\ Index '#{index_definition.name}' already exists in '#{table_name}'. Skipping statement.",
+          true
+        )
+        return
+      end
+
+      remove_index(table_name, name: index_definition.name)
       super
     end
 
-    def add_column(table_name, column_name, type, options = {})
+    ruby2_keywords def add_column(table_name, column_name, type, *)
       return super unless column_exists?(table_name, column_name)
 
       SafePgMigrations.say("/!\\ Column '#{column_name}' already exists in '#{table_name}'. Skipping statement.", true)
     end
 
-    def remove_column(table_name, column_name, type = nil, options = {})
+    ruby2_keywords def remove_column(table_name, column_name, type = nil, *)
       return super if column_exists?(table_name, column_name)
 
       SafePgMigrations.say("/!\\ Column '#{column_name}' not found on table '#{table_name}'. Skipping statement.", true)
     end
 
-    def remove_index(table_name, options = {})
+    ruby2_keywords def remove_index(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, options)
 
       return super if index_name_exists?(table_name, index_name)
@@ -32,9 +42,10 @@ module SafePgMigrations
       SafePgMigrations.say("/!\\ Index '#{index_name}' not found on table '#{table_name}'. Skipping statement.", true)
     end
 
-    def add_foreign_key(from_table, to_table, **options)
-      options_or_to_table = options.slice(:name, :column).presence || to_table
-      return super unless foreign_key_exists?(from_table, options_or_to_table)
+    ruby2_keywords def add_foreign_key(from_table, to_table, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      suboptions = options.slice(:name, :column)
+      return super unless foreign_key_exists?(from_table, suboptions.present? ? nil : to_table, **suboptions)
 
       SafePgMigrations.say(
         "/!\\ Foreign key '#{from_table}' -> '#{to_table}' already exists. Skipping statement.",
@@ -42,19 +53,20 @@ module SafePgMigrations
       )
     end
 
-    def create_table(table_name, comment: nil, **options)
+    ruby2_keywords def create_table(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       return super if options[:force] || !table_exists?(table_name)
 
       SafePgMigrations.say "/!\\ Table '#{table_name}' already exists.", true
 
-      td = create_table_definition(table_name, **options)
+      td = create_table_definition(table_name, *args)
 
       yield td if block_given?
 
       SafePgMigrations.say(td.indexes.empty? ? '-- Skipping statement' : '-- Creating indexes', true)
 
       td.indexes.each do |column_name, index_options|
-        add_index(table_name, column_name, index_options)
+        add_index(table_name, column_name, **index_options)
       end
     end
 

data/lib/safe-pg-migrations/plugins/legacy_active_record_support.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module LegacyActiveRecordSupport
+    ruby2_keywords def validate_foreign_key(from_table, to_table = nil, **options)
+      return super(from_table, to_table || options) unless satisfied? '>=6.0.0'
+
+      super(from_table, to_table, **options)
+    end
+
+    ruby2_keywords def foreign_key_exists?(from_table, to_table = nil, **options)
+      return super(from_table, to_table || options) unless satisfied? '>=6.0.0'
+
+      super(from_table, to_table, **options)
+    end
+
+    private
+
+    def satisfied?(version)
+      Gem::Requirement.new(version).satisfied_by? Gem::Version.new(::ActiveRecord::VERSION::STRING)
+    end
+  end
+end

data/lib/safe-pg-migrations/plugins/statement_insurer.rb

@@ -8,9 +8,11 @@ module SafePgMigrations
       define_method method do |*args, &block|
         with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) { super(*args, &block) }
       end
+      ruby2_keywords method
     end
 
-    def add_column(table_name, column_name, type, **options)
+    ruby2_keywords def add_column(table_name, column_name, type, *args) # rubocop:disable Metrics/CyclomaticComplexity
+      options = args.last.is_a?(Hash) ? args.last : {}
       return super if SafePgMigrations.pg_version_num >= PG_11_VERSION_NUM
 
       default = options.delete(:default)
@@ -36,17 +38,21 @@ module SafePgMigrations
       end
     end
 
-    def add_foreign_key(from_table, to_table, **options)
+    ruby2_keywords def add_foreign_key(from_table, to_table, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       validate_present = options.key? :validate
       options[:validate] = false unless validate_present
+      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) do
+        super(from_table, to_table, **options)
+      end
 
-      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) { super }
+      return if validate_present
 
-      options_or_to_table = options.slice(:name, :column).presence || to_table
-      without_statement_timeout { validate_foreign_key from_table, options_or_to_table } unless validate_present
+      suboptions = options.slice(:name, :column)
+      without_statement_timeout { validate_foreign_key from_table, suboptions.present? ? nil : to_table, **suboptions }
     end
 
-    def create_table(*)
+    ruby2_keywords def create_table(*)
       with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) do
         super do |td|
           yield td if block_given?
@@ -65,34 +71,25 @@ module SafePgMigrations
         options[:algorithm] = :concurrently
       end
 
-      SafePgMigrations.say_method_call(:add_index, table_name, column_name, options)
+      SafePgMigrations.say_method_call(:add_index, table_name, column_name, **options)
 
-      without_timeout { super }
+      without_timeout { super(table_name, column_name, **options) }
     end
 
-    def remove_index(table_name, options = {})
-      options = { column: options } unless options.is_a?(Hash)
-      options[:algorithm] = :concurrently
-      SafePgMigrations.say_method_call(:remove_index, table_name, options)
+    ruby2_keywords def remove_index(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : { column: args.last }
+      options[:algorithm] = :concurrently unless options.key?(:algorithm)
+      SafePgMigrations.say_method_call(:remove_index, table_name, **options)
 
-      without_timeout { super }
+      without_timeout { super(table_name, **options) }
     end
 
     def backfill_column_default(table_name, column_name)
-      quoted_table_name = quote_table_name(table_name)
+      model = Class.new(ActiveRecord::Base) { self.table_name = table_name }
       quoted_column_name = quote_column_name(column_name)
-      primary_key_offset = 0
-      loop do
-        ids = query_values <<~SQL.squish
-          SELECT id FROM #{quoted_table_name} WHERE id > #{primary_key_offset}
-          ORDER BY id LIMIT #{SafePgMigrations.config.batch_size}
-        SQL
-        break if ids.empty?
-
-        primary_key_offset = ids.last
-        execute <<~SQL.squish
-          UPDATE #{quoted_table_name} SET #{quoted_column_name} = DEFAULT WHERE id IN (#{ids.join(',')})
-        SQL
+
+      model.in_batches(of: SafePgMigrations.config.batch_size).each do |relation|
+        relation.update_all("#{quoted_column_name} = DEFAULT")
       end
     end
 

data/lib/safe-pg-migrations/plugins/statement_retrier.rb

@@ -10,6 +10,7 @@ module SafePgMigrations
       define_method method do |*args, &block|
         retry_if_lock_timeout { super(*args, &block) }
       end
+      ruby2_keywords method
     end
 
     private

data/lib/safe-pg-migrations/plugins/useless_statements_logger.rb

@@ -2,22 +2,27 @@
 
 module SafePgMigrations
   module UselessStatementsLogger
-    def self.warn_useless(action, link = nil, *args)
-      SafePgMigrations.say "/!\\ No need to explicitly use #{action}, safe-pg-migrations does it for you", *args
-      SafePgMigrations.say "\t see #{link} for more details", *args if link
+    class << self
+      ruby2_keywords def warn_useless(action, link = nil, *args)
+        SafePgMigrations.say "/!\\ No need to explicitly use #{action}, safe-pg-migrations does it for you", *args
+        SafePgMigrations.say "\t see #{link} for more details", *args if link
+      end
     end
 
-    def add_index(*, **options)
+    ruby2_keywords def add_index(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       warn_for_index(**options)
       super
     end
 
-    def remove_index(table_name, options = {})
-      warn_for_index(options) if options.is_a? Hash
+    ruby2_keywords def remove_index(table_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      warn_for_index(**options) unless options.empty?
       super
     end
 
-    def add_foreign_key(*, **options)
+    ruby2_keywords def add_foreign_key(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       if options[:validate] == false
         UselessStatementsLogger.warn_useless '`validate: :false`', 'https://github.com/doctolib/safe-pg-migrations#safe_add_foreign_key'
       end

data/lib/safe-pg-migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  VERSION = '1.2.2'
+  VERSION = '1.4.0'
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: safe-pg-migrations
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Matthieu Prat
 - Romain Choquet
+- Thomas Hareau
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,6 +40,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: ruby2_keywords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -152,7 +167,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Make your PG migrations safe.
-email: matthieuprat@gmail.com
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -163,7 +178,8 @@ files:
 - lib/safe-pg-migrations/base.rb
 - lib/safe-pg-migrations/configuration.rb
 - lib/safe-pg-migrations/plugins/blocking_activity_logger.rb
-- lib/safe-pg-migrations/plugins/idem_potent_statements.rb
+- lib/safe-pg-migrations/plugins/idempotent_statements.rb
+- lib/safe-pg-migrations/plugins/legacy_active_record_support.rb
 - lib/safe-pg-migrations/plugins/statement_insurer.rb
 - lib/safe-pg-migrations/plugins/statement_retrier.rb
 - lib/safe-pg-migrations/plugins/useless_statements_logger.rb
@@ -173,7 +189,12 @@ files:
 homepage: https://github.com/doctolib/safe-pg-migrations
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/doctolib/safe-pg-migrations/issues
+  homepage_uri: https://github.com/doctolib/safe-pg-migrations#safe-pg-migrations
+  mailing_list_uri: https://doctolib.engineering/engineering-news-ruby-rails-react
+  source_code_uri: https://github.com/doctolib/safe-pg-migrations
+  contributors_uri: https://github.com/doctolib/safe-pg-migrations/graphs/contributors
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -183,6 +204,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="