Ruby 3.0 in support matrix (#43)

* Ruby 3.0 in support matrix

* Support interoperability betwen ruby 2.x and 3.x

* Using ruby2_keywords

Co-authored-by: Thomas Hareau <[email protected]>

Author: Izzette

.github/workflows/continuous-integration-workflow.yml

@@ -41,7 +41,7 @@ jobs:
     strategy:
       matrix:
         postgres: [ 9.6, 11.7 ]
-        ruby: [ 2.5, 2.6, 2.7 ]
+        ruby: [ 2.5, 2.6, 2.7, 3.0 ]
     services:
       postgres:
         image: postgres:${{ matrix.postgres }}

Gemfile.lock

@@ -4,6 +4,7 @@ PATH
     safe-pg-migrations (1.2.3)
       activerecord (>= 5.2)
       activesupport (>= 5.2)
+      ruby2_keywords (>= 0.0.4)
 
 GEM
   remote: https://rubygems.org/
@@ -53,6 +54,7 @@ GEM
       ruby-progressbar (~> 1.7)
       unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.10.0)
+    ruby2_keywords (0.0.4)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (1.4.0)

lib/safe-pg-migrations/base.rb

@@ -1,5 +1,6 @@
 # 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'
@@ -50,13 +51,13 @@ def close_alternate_connection
       @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
 
@@ -91,6 +92,7 @@ def disable_ddl_transaction
 
         safety_assured { super(*args) }
       end
+      ruby2_keywords method
     end
   end
 end

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

@@ -21,6 +21,7 @@ module BlockingActivityLogger
       define_method method do |*args, &block|
         log_blocking_queries { super(*args, &block) }
       end
+      ruby2_keywords method
     end
 
     private

lib/safe-pg-migrations/plugins/idem_potent_statements.rb

@@ -2,7 +2,8 @@
 
 module SafePgMigrations
   module IdemPotentStatements
-    def add_index(table_name, column_name, **options)
+    ruby2_keywords def add_index(table_name, column_name, *args)
+      options = args.last.is_a?(Hash) ? args.last : {}
       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)
 
@@ -12,49 +13,52 @@ def add_index(table_name, column_name, **options)
       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)
 
       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.",
         true
       )
     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
 

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

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  module StatementInsurer
+  module StatementInsurer # rubocop:disable Metrics/ModuleLength
     PG_11_VERSION_NUM = 110_000
 
     %i[change_column_null change_column].each do |method|
       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 @@ def add_column(table_name, column_name, type, **options)
       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,17 +71,17 @@ def add_index(table_name, column_name, **options)
         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)

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

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

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

safe-pg-migrations.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activerecord', '>= 5.2'
   s.add_dependency 'activesupport', '>= 5.2'
+  s.add_dependency 'ruby2_keywords', '>= 0.0.4'
 
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'minitest'

test/safe_pg_migrations_test.rb

@@ -73,7 +73,7 @@ def test_statement_retry
       '   -> Statement was being blocked by the following query:',
       '   -> ',
     ], calls[0..4]
-    assert_match(/\s*-> transaction started 1 second ago:\s*BEGIN; SELECT 1 FROM users/, calls[5])
+    assert_match(/\s*-> transaction started \d+ seconds? ago:\s*BEGIN; SELECT 1 FROM users/, calls[5])
     assert_equal [
       '   -> ',
       '   -> Retrying in 1 seconds...',