Rename :urlsafe option to :url_safe

Although Ruby provides `Base64.urlsafe_encode64` and
`Base64.urlsafe_decode64` methods, the technical term is "URL-safe",
with "URL" and "safe" as separate words.

For better readability, this commit renames the `:urlsafe` option for
`MessageEncryptor` and `MessageVerifier` to `:url_safe`.

Author: jonathanhefner

activesupport/CHANGELOG.md

@@ -8,22 +8,22 @@
 
     *Ryo Nakamura*
 
-*   Support `:urlsafe` option for `MessageEncryptor`.
+*   Support `:url_safe` option for `MessageEncryptor`.
 
-    The `MessageEncryptor` constructor now accepts a `:urlsafe` option, similar
+    The `MessageEncryptor` constructor now accepts a `:url_safe` option, similar
     to the `MessageVerifier` constructor.  When enabled, this option ensures
     that messages use a URL-safe encoding.
 
     *Jonathan Hefner*
 
-*   Add `urlsafe` option to `ActiveSupport::MessageVerifier` initializer
+*   Add `url_safe` option to `ActiveSupport::MessageVerifier` initializer
 
-    `ActiveSupport::MessageVerifier.new` now takes optional `urlsafe` argument.
-    It can generate urlsafe strings by passing `urlsafe: true`.
+    `ActiveSupport::MessageVerifier.new` now takes optional `url_safe` argument.
+    It can generate URL-safe strings by passing `url_safe: true`.
 
     ```ruby
-    verifier = ActiveSupport::MessageVerifier.new(urlsafe: true)
-    message = verifier.generate(data) # => "urlsafe_string"
+    verifier = ActiveSupport::MessageVerifier.new(url_safe: true)
+    message = verifier.generate(data) # => URL-safe string
     ```
 
     This option is `false` by default to be backwards compatible.

activesupport/lib/active_support/message_encryptor.rb

@@ -143,9 +143,9 @@ class InvalidMessage < StandardError; end
     # * <tt>:digest</tt> - String of digest to use for signing. Default is
     #   +SHA1+. Ignored when using an AEAD cipher like 'aes-256-gcm'.
     # * <tt>:serializer</tt> - Object serializer to use. Default is +JSON+.
-    # * <tt>:urlsafe</tt> - Whether to encode messages using a URL-safe
+    # * <tt>:url_safe</tt> - Whether to encode messages using a URL-safe
     #   encoding. Default is +false+ for backward compatibility.
-    def initialize(secret, sign_secret = nil, cipher: nil, digest: nil, serializer: nil, urlsafe: false)
+    def initialize(secret, sign_secret = nil, cipher: nil, digest: nil, serializer: nil, url_safe: false)
       @secret = secret
       @sign_secret = sign_secret
       @cipher = cipher || self.class.default_cipher
@@ -159,7 +159,7 @@ def initialize(secret, sign_secret = nil, cipher: nil, digest: nil, serializer:
         elsif @@default_message_encryptor_serializer.equal?(:json)
           JSON
         end
-      @urlsafe = urlsafe
+      @url_safe = url_safe
       @verifier = resolve_verifier
     end
 
@@ -190,11 +190,11 @@ def deserialize(value)
       end
 
       def encode(data)
-        @urlsafe ? ::Base64.urlsafe_encode64(data, padding: false) : ::Base64.strict_encode64(data)
+        @url_safe ? ::Base64.urlsafe_encode64(data, padding: false) : ::Base64.strict_encode64(data)
       end
 
       def decode(data)
-        @urlsafe ? ::Base64.urlsafe_decode64(data) : ::Base64.strict_decode64(data)
+        @url_safe ? ::Base64.urlsafe_decode64(data) : ::Base64.strict_decode64(data)
       end
 
       def _encrypt(value, **metadata_options)
@@ -242,7 +242,7 @@ def _decrypt(encrypted_message, purpose)
       end
 
       def length_after_encode(length_before_encode)
-        if @urlsafe
+        if @url_safe
           (4 * length_before_encode / 3.0).ceil # length without padding
         else
           4 * (length_before_encode / 3.0).ceil # length with padding
@@ -295,7 +295,7 @@ def resolve_verifier
         if aead_mode?
           NullVerifier
         else
-          MessageVerifier.new(@sign_secret || @secret, digest: @digest, serializer: NullSerializer, urlsafe: @urlsafe)
+          MessageVerifier.new(@sign_secret || @secret, digest: @digest, serializer: NullSerializer, url_safe: @url_safe)
         end
       end
   end

activesupport/lib/active_support/message_verifier.rb

@@ -108,16 +108,16 @@ module ActiveSupport
   #
   #   verifier.rotate(old_secret, digest: "SHA256", serializer: Marshal)
   #
-  # === Generating URL safe strings
+  # === Generating URL-safe strings
   #
   # By default MessageVerifier generates RFC 4648 compliant strings which are
-  # not URL safe. In other words, they can contain "+" and "/". If you want to
-  # generate URL safe strings (in compliance with "Base 64 Encoding with URL and
-  # Filename Safe Alphabet" in RFC 4648), you can pass <tt>urlsafe: true</tt>
+  # not URL-safe. In other words, they can contain "+" and "/". If you want to
+  # generate URL-safe strings (in compliance with "Base 64 Encoding with URL and
+  # Filename Safe Alphabet" in RFC 4648), you can pass <tt>url_safe: true</tt>
   # to the constructor:
   #
-  #   @verifier = ActiveSupport::MessageVerifier.new("secret", urlsafe: true)
-  #   @verifier.generate("signed message") #=> "urlsafe_string"
+  #   @verifier = ActiveSupport::MessageVerifier.new("secret", url_safe: true)
+  #   @verifier.generate("signed message") #=> URL-safe string
   class MessageVerifier
     prepend Messages::Rotator::Verifier
 
@@ -128,7 +128,7 @@ class InvalidSignature < StandardError; end
 
     cattr_accessor :default_message_verifier_serializer, instance_accessor: false, default: :marshal
 
-    def initialize(secret, digest: nil, serializer: nil, urlsafe: false)
+    def initialize(secret, digest: nil, serializer: nil, url_safe: false)
       raise ArgumentError, "Secret should not be nil." unless secret
       @secret = secret
       @digest = digest&.to_s || "SHA1"
@@ -140,7 +140,7 @@ def initialize(secret, digest: nil, serializer: nil, urlsafe: false)
         elsif @@default_message_verifier_serializer.equal?(:json)
           JSON
         end
-      @urlsafe = urlsafe
+      @url_safe = url_safe
     end
 
     # Checks if a signed message could have been generated by signing an object
@@ -221,11 +221,11 @@ def generate(value, expires_at: nil, expires_in: nil, purpose: nil)
 
     private
       def encode(data)
-        @urlsafe ? Base64.urlsafe_encode64(data, padding: false) : Base64.strict_encode64(data)
+        @url_safe ? Base64.urlsafe_encode64(data, padding: false) : Base64.strict_encode64(data)
       end
 
       def decode(data)
-        @urlsafe ? Base64.urlsafe_decode64(data) : Base64.strict_decode64(data)
+        @url_safe ? Base64.urlsafe_decode64(data) : Base64.strict_decode64(data)
       end
 
       def generate_digest(data)

activesupport/test/message_encryptor_test.rb

@@ -84,11 +84,11 @@ def test_message_obeys_strict_encoding
   end
 
   test "supports URL-safe encoding when using authenticated encryption" do
-    encryptor = ActiveSupport::MessageEncryptor.new(@secret, urlsafe: true, cipher: "aes-256-gcm")
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, url_safe: true, cipher: "aes-256-gcm")
 
     # Because encrypted data appears random, we cannot control whether it will
     # contain bytes that _would_ be encoded as non-URL-safe characters (i.e. "+"
-    # or "/") if `urlsafe: true` were broken.  Therefore, to make our test
+    # or "/") if `url_safe: true` were broken.  Therefore, to make our test
     # falsifiable, we use a large string so that the encrypted data will almost
     # certainly contain such bytes.
     data = "x" * 10001
@@ -99,16 +99,16 @@ def test_message_obeys_strict_encoding
   end
 
   test "supports URL-safe encoding when using unauthenticated encryption" do
-    encryptor = ActiveSupport::MessageEncryptor.new(@secret, urlsafe: true, cipher: "aes-256-cbc")
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, url_safe: true, cipher: "aes-256-cbc")
 
     # When using unauthenticated encryption, messages are double encoded: once
     # when encrypting and once again when signing with a MessageVerifier.  The
     # 1st encode eliminates the possibility of a 6-bit aligned occurrence of
     # `0b111110` or `0b111111`, which the 2nd encode _would_ map to a
-    # non-URL-safe character (i.e. "+" or "/") if `urlsafe: true` were broken.
+    # non-URL-safe character (i.e. "+" or "/") if `url_safe: true` were broken.
     # Therefore, to ensure our test is falsifiable, we also assert that the
     # message payload _would_ have padding characters (i.e. "=") if
-    # `urlsafe: true` were broken.
+    # `url_safe: true` were broken.
     data = 1
     message = encryptor.encrypt_and_sign(data)
 

activesupport/test/message_verifier_test.rb

@@ -50,7 +50,7 @@ def test_verify_exception_on_invalid_message
   end
 
   test "supports URL-safe encoding" do
-    verifier = ActiveSupport::MessageVerifier.new(@secret, urlsafe: true, serializer: JSON)
+    verifier = ActiveSupport::MessageVerifier.new(@secret, url_safe: true, serializer: JSON)
 
     # To verify that the message payload uses a URL-safe encoding (i.e. does not
     # use "+" or "/"), the unencoded bytes should have a 6-bit aligned