Fix Ruby 2.7 keyword argument warnings in Active Support

activesupport/lib/active_support/cache.rb

@@ -52,12 +52,12 @@ class << self
       #
       #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
       #   # => returns MyOwnCacheStore.new
-      def lookup_store(*store_option)
-        store, *parameters = *Array.wrap(store_option).flatten
+      def lookup_store(*store_args, **store_options)
+        store, *parameters = *Array.wrap(store_args).flatten
 
         case store
         when Symbol
-          retrieve_store_class(store).new(*parameters)
+          retrieve_store_class(store).new(*parameters, **store_options)
         when nil
           ActiveSupport::Cache::MemoryStore.new
         else

activesupport/lib/active_support/deprecation/proxy_wrappers.rb

@@ -121,7 +121,7 @@ def warn(callstack, called, args)
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < Module
-      def self.new(*args, &block)
+      def self.new(*args, **kwargs, &block)
         object = args.first
 
         return object unless object

activesupport/lib/active_support/encrypted_file.rb

@@ -94,7 +94,7 @@ def read_key_file
       end
 
       def handle_missing_key
-        raise MissingKeyError, key_path: key_path, env_key: env_key if raise_if_missing_key
+        raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
       end
   end
 end

activesupport/lib/active_support/message_encryptor.rb

@@ -172,7 +172,7 @@ def _encrypt(value, **metadata_options)
         iv = cipher.random_iv
         cipher.auth_data = "" if aead_mode?
 
-        encrypted_data = cipher.update(Messages::Metadata.wrap(@serializer.dump(value), metadata_options))
+        encrypted_data = cipher.update(Messages::Metadata.wrap(@serializer.dump(value), **metadata_options))
         encrypted_data << cipher.final
 
         blob = "#{::Base64.strict_encode64 encrypted_data}--#{::Base64.strict_encode64 iv}"

activesupport/lib/active_support/message_verifier.rb

@@ -172,8 +172,8 @@ def verified(signed_message, purpose: nil, **)
     #
     #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
     #   other_verifier.verify(signed_message) # => ActiveSupport::MessageVerifier::InvalidSignature
-    def verify(*args)
-      verified(*args) || raise(InvalidSignature)
+    def verify(*args, **options)
+      verified(*args, **options) || raise(InvalidSignature)
     end
 
     # Generates a signed message for the provided value.

activesupport/lib/active_support/messages/rotator.rb

@@ -20,25 +20,25 @@ module Encryptor
         def decrypt_and_verify(*args, on_rotation: nil, **options)
           super
         rescue MessageEncryptor::InvalidMessage, MessageVerifier::InvalidSignature
-          run_rotations(on_rotation) { |encryptor| encryptor.decrypt_and_verify(*args, options) } || raise
+          run_rotations(on_rotation) { |encryptor| encryptor.decrypt_and_verify(*args, **options) } || raise
         end
 
         private
           def build_rotation(secret = @secret, sign_secret = @sign_secret, options)
-            self.class.new(secret, sign_secret, options)
+            self.class.new(secret, sign_secret, **options)
           end
       end
 
       module Verifier
         include Rotator
 
         def verified(*args, on_rotation: nil, **options)
-          super || run_rotations(on_rotation) { |verifier| verifier.verified(*args, options) }
+          super || run_rotations(on_rotation) { |verifier| verifier.verified(*args, **options) }
         end
 
         private
           def build_rotation(secret = @secret, options)
-            self.class.new(secret, options)
+            self.class.new(secret, **options)
           end
       end
 

activesupport/lib/active_support/multibyte/chars.rb

@@ -122,7 +122,7 @@ def reverse
       #
       #   'こんにちは'.mb_chars.limit(7).to_s # => "こん"
       def limit(limit)
-        truncate_bytes(limit, omission: nil)
+        chars(@wrapped_string.truncate_bytes(limit, omission: nil))
       end
 
       # Capitalizes the first letter of every word, when possible.

activesupport/lib/active_support/number_helper/number_converter.rb

@@ -162,11 +162,11 @@ def i18n_format_options
         end
 
         def translate_number_value_with_default(key, **i18n_options)
-          I18n.translate(key, **{default: default_value(key), scope: :number}.merge!(i18n_options))
+          I18n.translate(key, **{ default: default_value(key), scope: :number }.merge!(i18n_options))
         end
 
         def translate_in_locale(key, **i18n_options)
-          translate_number_value_with_default(key, **{locale: options[:locale]}.merge(i18n_options))
+          translate_number_value_with_default(key, **{ locale: options[:locale] }.merge(i18n_options))
         end
 
         def default_value(key)

activesupport/test/cache/behaviors/connection_pool_behavior.rb

@@ -7,7 +7,7 @@ def test_connection_pool
     threads = []
 
     emulating_latency do
-      cache = ActiveSupport::Cache.lookup_store(*store, { pool_size: 2, pool_timeout: 1 }.merge(store_options))
+      cache = ActiveSupport::Cache.lookup_store(*store, **{ pool_size: 2, pool_timeout: 1 }.merge(store_options))
       cache.clear
 
       assert_raises Timeout::Error do
@@ -32,7 +32,7 @@ def test_no_connection_pool
     threads = []
 
     emulating_latency do
-      cache = ActiveSupport::Cache.lookup_store(*store, store_options)
+      cache = ActiveSupport::Cache.lookup_store(*store, **store_options)
       cache.clear
 
       assert_nothing_raised do

activesupport/test/message_encryptor_test.rb

@@ -65,7 +65,7 @@ def test_alternative_serialization_method
     prev = ActiveSupport.use_standard_json_time_format
     ActiveSupport.use_standard_json_time_format = true
     encryptor = ActiveSupport::MessageEncryptor.new(SecureRandom.random_bytes(32), SecureRandom.random_bytes(128), serializer: JSONSerializer.new)
-    message = encryptor.encrypt_and_sign(:foo => 123, "bar" => Time.utc(2010))
+    message = encryptor.encrypt_and_sign({ :foo => 123, "bar" => Time.utc(2010) })
     exp = { "foo" => 123, "bar" => "2010-01-01T00:00:00.000Z" }
     assert_equal exp, encryptor.decrypt_and_verify(message)
   ensure
@@ -126,7 +126,7 @@ def test_rotating_secret
 
   def test_rotating_serializer
     old_message = ActiveSupport::MessageEncryptor.new(secrets[:old], cipher: "aes-256-gcm", serializer: JSON).
-      encrypt_and_sign(ahoy: :hoy)
+      encrypt_and_sign({ ahoy: :hoy })
 
     encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm", serializer: JSON)
     encryptor.rotate secrets[:old]
@@ -158,7 +158,7 @@ def test_multiple_rotations
   end
 
   def test_on_rotation_is_called_and_returns_modified_messages
-    older_message = ActiveSupport::MessageEncryptor.new(secrets[:older], "older sign").encrypt_and_sign(encoded: "message")
+    older_message = ActiveSupport::MessageEncryptor.new(secrets[:older], "older sign").encrypt_and_sign({ encoded: "message" })
 
     encryptor = ActiveSupport::MessageEncryptor.new(@secret)
     encryptor.rotate secrets[:old]
@@ -216,19 +216,21 @@ class MessageEncryptorMetadataTest < ActiveSupport::TestCase
 
   setup do
     @secret    = SecureRandom.random_bytes(32)
-    @encryptor = ActiveSupport::MessageEncryptor.new(@secret, encryptor_options)
+    @encryptor = ActiveSupport::MessageEncryptor.new(@secret, **encryptor_options)
   end
 
   private
     def generate(message, **options)
-      @encryptor.encrypt_and_sign(message, options)
+      @encryptor.encrypt_and_sign(message, **options)
     end
 
     def parse(data, **options)
-      @encryptor.decrypt_and_verify(data, options)
+      @encryptor.decrypt_and_verify(data, **options)
     end
 
-    def encryptor_options; end
+    def encryptor_options
+      {}
+    end
 end
 
 class MessageEncryptorMetadataMarshalTest < MessageEncryptorMetadataTest

activesupport/test/message_verifier_test.rb

@@ -53,7 +53,7 @@ def test_alternative_serialization_method
     prev = ActiveSupport.use_standard_json_time_format
     ActiveSupport.use_standard_json_time_format = true
     verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!", serializer: JSONSerializer.new)
-    message = verifier.generate(:foo => 123, "bar" => Time.utc(2010))
+    message = verifier.generate({ :foo => 123, "bar" => Time.utc(2010) })
     exp = { "foo" => 123, "bar" => "2010-01-01T00:00:00.000Z" }
     assert_equal exp, verifier.verified(message)
     assert_equal exp, verifier.verify(message)
@@ -115,7 +115,7 @@ def test_multiple_rotations
   end
 
   def test_on_rotation_is_called_and_verified_returns_message
-    older_message = ActiveSupport::MessageVerifier.new("older", digest: "SHA1").generate(encoded: "message")
+    older_message = ActiveSupport::MessageVerifier.new("older", digest: "SHA1").generate({ encoded: "message" })
 
     verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA512")
     verifier.rotate "old",   digest: "SHA256"
@@ -142,7 +142,7 @@ class MessageVerifierMetadataTest < ActiveSupport::TestCase
   include SharedMessageMetadataTests
 
   setup do
-    @verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!", verifier_options)
+    @verifier = ActiveSupport::MessageVerifier.new("Hey, I'm a secret!", **verifier_options)
   end
 
   def test_verify_raises_when_purpose_differs
@@ -162,11 +162,11 @@ def test_verify_raises_when_expired
 
   private
     def generate(message, **options)
-      @verifier.generate(message, options)
+      @verifier.generate(message, **options)
     end
 
     def parse(message, **options)
-      @verifier.verified(message, options)
+      @verifier.verified(message, **options)
     end
 
     def verifier_options