activesupport 6.0.4 → 6.1.4

data/lib/active_support/hash_with_indifferent_access.rb

@@ -3,6 +3,7 @@
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
 
 module ActiveSupport
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
@@ -69,7 +70,7 @@ module ActiveSupport
         super()
         update(constructor)
 
-        hash = constructor.to_hash
+        hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
         self.default = hash.default if hash.default
         self.default_proc = hash.default_proc if hash.default_proc
       else
@@ -91,12 +92,12 @@ module ActiveSupport
     #
     # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
     def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+      regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
     end
 
     alias_method :store, :[]=
 
-    # Updates the receiver in-place, merging in the hash passed as argument:
+    # Updates the receiver in-place, merging in the hashes passed as arguments:
     #
     #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
     #   hash_1[:key] = 'value'
@@ -106,11 +107,14 @@ module ActiveSupport
     #
     #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
     #
-    # The argument can be either an
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
+    #
+    # The arguments can be either an
     # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
     # In either case the merge respects the semantics of indifferent access.
     #
-    # If the argument is a regular hash with keys +:key+ and +"key"+ only one
+    # If the argument is a regular hash with keys +:key+ and <tt>"key"</tt> only one
     # of the values end up in the receiver, but which one is unspecified.
     #
     # When given a block, the value for duplicated keys will be determined
@@ -121,18 +125,15 @@ module ActiveSupport
     #   hash_1[:key] = 10
     #   hash_2['key'] = 12
     #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-    def update(other_hash)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
+    def update(*other_hashes, &block)
+      if other_hashes.size == 1
+        update_with_single_argument(other_hashes.first, block)
       else
-        other_hash.to_hash.each_pair do |key, value|
-          if block_given? && key?(key)
-            value = yield(convert_key(key), self[key], value)
-          end
-          regular_writer(convert_key(key), convert_value(value))
+        other_hashes.each do |other_hash|
+          update_with_single_argument(other_hash, block)
         end
-        self
       end
+      self
     end
 
     alias_method :merge!, :update
@@ -259,8 +260,8 @@ module ActiveSupport
     # This method has the same semantics of +update+, except it does not
     # modify the receiver but rather returns a new hash with indifferent
     # access with the result of the merge.
-    def merge(hash, &block)
-      dup.update(hash, &block)
+    def merge(*hashes, &block)
+      dup.update(*hashes, &block)
     end
 
     # Like +merge+ but the other way around: Merges the receiver into the
@@ -293,6 +294,10 @@ module ActiveSupport
       super(convert_key(key))
     end
 
+    # Returns a hash with indifferent access that includes everything except given keys.
+    #   hash = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    #   hash.except(:a, "b") # => {c: 10}.with_indifferent_access
+    #   hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access
     def except(*keys)
       slice(*self.keys - keys.map { |key| convert_key(key) })
     end
@@ -357,40 +362,59 @@ module ActiveSupport
       set_defaults(_new_hash)
 
       each do |key, value|
-        _new_hash[key] = convert_value(value, for: :to_hash)
+        _new_hash[key] = convert_value(value, conversion: :to_hash)
       end
       _new_hash
     end
 
     private
-      def convert_key(key) # :doc:
-        key.kind_of?(Symbol) ? key.to_s : key
+      if Symbol.method_defined?(:name)
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.name : key
+        end
+      else
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.to_s : key
+        end
       end
 
-      def convert_value(value, options = {}) # :doc:
+      def convert_value(value, conversion: nil)
         if value.is_a? Hash
-          if options[:for] == :to_hash
+          if conversion == :to_hash
             value.to_hash
           else
             value.nested_under_indifferent_access
           end
         elsif value.is_a?(Array)
-          if options[:for] != :assignment || value.frozen?
+          if conversion != :assignment || value.frozen?
             value = value.dup
           end
-          value.map! { |e| convert_value(e, options) }
+          value.map! { |e| convert_value(e, conversion: conversion) }
         else
           value
         end
       end
 
-      def set_defaults(target) # :doc:
+      def set_defaults(target)
         if default_proc
           target.default_proc = default_proc.dup
         else
           target.default = default
         end
       end
+
+      def update_with_single_argument(other_hash, block)
+        if other_hash.is_a? HashWithIndifferentAccess
+          regular_update(other_hash, &block)
+        else
+          other_hash.to_hash.each_pair do |key, value|
+            if block && key?(key)
+              value = block.call(convert_key(key), self[key], value)
+            end
+            regular_writer(convert_key(key), convert_value(value))
+          end
+        end
+      end
   end
 end
 

data/lib/active_support/i18n_railtie.rb

@@ -12,9 +12,7 @@ module I18n
     config.i18n.load_path = []
     config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
 
-    if I18n.respond_to?(:eager_load!)
-      config.eager_load_namespaces << I18n
-    end
+    config.eager_load_namespaces << I18n
 
     # Set the i18n configuration after initialization since a lot of
     # configuration is still usually done in application initializers.
@@ -50,8 +48,10 @@ module I18n
           app.config.i18n.load_path.unshift(*value.flat_map(&:existent))
         when :load_path
           I18n.load_path += value
+        when :raise_on_missing_translations
+          forward_raise_on_missing_translations_config(app)
         else
-          I18n.send("#{setting}=", value)
+          I18n.public_send("#{setting}=", value)
         end
       end
 
@@ -64,8 +64,6 @@ module I18n
       reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
         I18n.load_path.keep_if { |p| File.exist?(p) }
         I18n.load_path |= reloadable_paths.flat_map(&:existent)
-
-        I18n.reload!
       end
 
       app.reloaders << reloader
@@ -77,6 +75,16 @@ module I18n
       @i18n_inited = true
     end
 
+    def self.forward_raise_on_missing_translations_config(app)
+      ActiveSupport.on_load(:action_view) do
+        self.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        AbstractController::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
+      end
+    end
+
     def self.include_fallbacks_module
       I18n.backend.class.include(I18n::Backend::Fallbacks)
     end
@@ -94,19 +102,6 @@ module I18n
           [I18n.default_locale]
         end
 
-      if args.empty? || args.first.is_a?(Hash)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Using I18n fallbacks with an empty `defaults` sets the defaults to
-          include the `default_locale`. This behavior will change in Rails 6.1.
-          If you desire the default locale to be included in the defaults, please
-          explicitly configure it with `config.i18n.fallbacks.defaults =
-          [I18n.default_locale]` or `config.i18n.fallbacks = [I18n.default_locale,
-          {...}]`. If you want to opt-in to the new behavior, use
-          `config.i18n.fallbacks.defaults = [nil, {...}]`.
-        MSG
-        args.unshift I18n.default_locale
-      end
-
       I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
     end
 

data/lib/active_support/inflector/inflections.rb

@@ -2,7 +2,6 @@
 
 require "concurrent/map"
 require "active_support/i18n"
-require "active_support/deprecation"
 
 module ActiveSupport
   module Inflector
@@ -77,7 +76,7 @@ module ActiveSupport
       # Private, for the test suite.
       def initialize_dup(orig) # :nodoc:
         %w(plurals singulars uncountables humans acronyms).each do |scope|
-          instance_variable_set("@#{scope}", orig.send(scope).dup)
+          instance_variable_set("@#{scope}", orig.public_send(scope).dup)
         end
         define_acronym_regex_patterns
       end

data/lib/active_support/inflector/methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/inflections"
+require "active_support/core_ext/object/blank"
 
 module ActiveSupport
   # The Inflector transforms words from singular to plural, class names to table
@@ -132,7 +133,7 @@ module ActiveSupport
 
       result.sub!(/\A_+/, "")
       unless keep_id_suffix
-        result.sub!(/_id\z/, "")
+        result.delete_suffix!("_id")
       end
       result.tr!("_", " ")
 
@@ -172,7 +173,7 @@ module ActiveSupport
     #   titleize('raiders_of_the_lost_ark')                      # => "Raiders Of The Lost Ark"
     #   titleize('string_ending_with_id', keep_id_suffix: true)  # => "String Ending With Id"
     def titleize(word, keep_id_suffix: false)
-      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`])[a-z]/) do |match|
+      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`()])[a-z]/) do |match|
         match.capitalize
       end
     end
@@ -269,32 +270,36 @@ module ActiveSupport
     # NameError is raised when the name is not in CamelCase or the constant is
     # unknown.
     def constantize(camel_cased_word)
-      names = camel_cased_word.split("::")
-
-      # Trigger a built-in NameError exception including the ill-formed constant in the message.
-      Object.const_get(camel_cased_word) if names.empty?
-
-      # Remove the first blank element in case of '::ClassName' notation.
-      names.shift if names.size > 1 && names.first.empty?
-
-      names.inject(Object) do |constant, name|
-        if constant == Object
-          constant.const_get(name)
-        else
-          candidate = constant.const_get(name)
-          next candidate if constant.const_defined?(name, false)
-          next candidate unless Object.const_defined?(name)
-
-          # Go down the ancestors to check if it is owned directly. The check
-          # stops when we reach Object or the end of ancestors tree.
-          constant = constant.ancestors.inject(constant) do |const, ancestor|
-            break const    if ancestor == Object
-            break ancestor if ancestor.const_defined?(name, false)
-            const
+      if camel_cased_word.blank? || !camel_cased_word.include?("::")
+        Object.const_get(camel_cased_word)
+      else
+        names = camel_cased_word.split("::")
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject(constant) do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
           end
-
-          # owner is in Object, so raise
-          constant.const_get(name, false)
         end
       end
     end
@@ -326,10 +331,9 @@ module ActiveSupport
     rescue NameError => e
       raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
         e.name.to_s == camel_cased_word.to_s)
-    rescue ArgumentError => e
-      raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
     rescue LoadError => e
-      raise unless /Unable to autoload constant #{const_regexp(camel_cased_word)}/.match?(e.message)
+      message = e.respond_to?(:original_message) ? e.original_message : e.message
+      raise unless /Unable to autoload constant #{const_regexp(camel_cased_word)}/.match?(message)
     end
 
     # Returns the suffix that should be added to a number to denote the position
@@ -371,7 +375,7 @@ module ActiveSupport
 
         last = parts.pop
 
-        parts.reverse.inject(last) do |acc, part|
+        parts.reverse!.inject(last) do |acc, part|
           part.empty? ? acc : "#{part}(::#{acc})?"
         end
       end

data/lib/active_support/inflector/transliterate.rb

@@ -5,6 +5,8 @@ require "active_support/i18n"
 
 module ActiveSupport
   module Inflector
+    ALLOWED_ENCODINGS_FOR_TRANSLITERATE = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::GB18030].freeze
+
     # Replaces non-ASCII characters with an ASCII approximation, or if none
     # exists, a replacement character which defaults to "?".
     #
@@ -62,9 +64,7 @@ module ActiveSupport
     def transliterate(string, replacement = "?", locale: nil)
       string = string.dup if string.frozen?
       raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
-
-      allowed_encodings = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::GB18030]
-      raise ArgumentError, "Can not transliterate strings with #{string.encoding} encoding" unless allowed_encodings.include?(string.encoding)
+      raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
 
       input_encoding = string.encoding
 
@@ -117,7 +117,7 @@ module ActiveSupport
     # If the optional parameter +locale+ is specified,
     # the word will be parameterized as a word of that language.
     # By default, this parameter is set to <tt>nil</tt> and it will use
-    # the configured <tt>I18n.locale<tt>.
+    # the configured <tt>I18n.locale</tt>.
     def parameterize(string, separator: "-", preserve_case: false, locale: nil)
       # Replace accented chars with their ASCII equivalents.
       parameterized_string = transliterate(string, locale: locale)

data/lib/active_support/json/decoding.rb

@@ -10,8 +10,8 @@ module ActiveSupport
 
   module JSON
     # matches YAML-formatted dates
-    DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/
-    DATETIME_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)$/
+    DATE_REGEX = /\A\d{4}-\d{2}-\d{2}\z/
+    DATETIME_REGEX = /\A(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)\z/
 
     class << self
       # Parses a JSON string (JavaScript Object Notation) into a hash.
@@ -63,8 +63,8 @@ module ActiveSupport
           when Array
             data.map! { |d| convert_dates_from(d) }
           when Hash
-            data.each do |key, value|
-              data[key] = convert_dates_from(value)
+            data.transform_values! do |value|
+              convert_dates_from(value)
             end
           else
             data

data/lib/active_support/json/encoding.rb

@@ -93,7 +93,11 @@ module ActiveSupport
             when Numeric, NilClass, TrueClass, FalseClass
               value.as_json
             when Hash
-              Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
+              result = {}
+              value.each do |k, v|
+                result[jsonify(k)] = jsonify(v)
+              end
+              result
             when Array
               value.map { |v| jsonify(v) }
             else

data/lib/active_support/key_generator.rb

@@ -35,7 +35,7 @@ module ActiveSupport
 
     # Returns a derived key suitable for use.
     def generate_key(*args)
-      @cache_keys[args.join] ||= @key_generator.generate_key(*args)
+      @cache_keys[args.join("|")] ||= @key_generator.generate_key(*args)
     end
   end
 end

data/lib/active_support/locale/en.yml

@@ -44,10 +44,12 @@ en:
       delimiter: ","
       # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
       precision: 3
+      # Determine how rounding is performed (see BigDecimal::mode)
+      round_mode: default
       # If set to true, precision will mean the number of significant digits instead
       # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
       significant: false
-      # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
+      # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
       strip_insignificant_zeros: false
 
     # Used in NumberHelper.number_to_currency()
@@ -56,10 +58,11 @@ en:
         # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
         format: "%u%n"
         unit: "$"
-        # These five are to override number.format and are optional
+        # These six are to override number.format and are optional
         separator: "."
         delimiter: ","
         precision: 2
+        # round_mode:
         significant: false
         strip_insignificant_zeros: false
 
@@ -87,10 +90,11 @@ en:
     # Used in NumberHelper.number_to_human_size() and NumberHelper.number_to_human()
     human:
       format:
-        # These five are to override number.format and are optional
+        # These six are to override number.format and are optional
         # separator:
         delimiter: ""
         precision: 3
+        # round_mode:
         significant: true
         strip_insignificant_zeros: true
       # Used in number_to_human_size()

data/lib/active_support/log_subscriber.rb

@@ -29,6 +29,9 @@ module ActiveSupport
   # subscriber, the line above should be called after your
   # <tt>ActiveRecord::LogSubscriber</tt> definition.
   #
+  # A logger also needs to be set with <tt>ActiveRecord::LogSubscriber.logger=</tt>.
+  # This is assigned automatically in a Rails environment.
+  #
   # After configured, whenever a <tt>"sql.active_record"</tt> notification is published,
   # it will properly dispatch the event
   # (<tt>ActiveSupport::Notifications::Event</tt>) to the sql method.
@@ -93,6 +96,11 @@ module ActiveSupport
       def flush_all!
         logger.flush if logger.respond_to?(:flush)
       end
+
+      private
+        def fetch_public_methods(subscriber, inherit_all)
+          subscriber.public_methods(inherit_all) - LogSubscriber.public_instance_methods(true)
+        end
     end
 
     def logger

data/lib/active_support/logger.rb

@@ -14,7 +14,7 @@ module ActiveSupport
     #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
     #   # => true
     def self.logger_outputs_to?(logger, *sources)
-      logdev = logger.instance_variable_get("@logdev")
+      logdev = logger.instance_variable_get(:@logdev)
       logger_source = logdev.dev if logdev.respond_to?(:dev)
       sources.any? { |source| source == logger_source }
     end

data/lib/active_support/logger_silence.rb

@@ -4,19 +4,6 @@ require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/logger_thread_safe_level"
 
-module LoggerSilence
-  extend ActiveSupport::Concern
-
-  included do
-    ActiveSupport::Deprecation.warn(
-      "Including LoggerSilence is deprecated and will be removed in Rails 6.1. " \
-      "Please use `ActiveSupport::LoggerSilence` instead"
-    )
-
-    include ActiveSupport::LoggerSilence
-  end
-end
-
 module ActiveSupport
   module LoggerSilence
     extend ActiveSupport::Concern
@@ -27,19 +14,8 @@ module ActiveSupport
     end
 
     # Silences the logger for the duration of the block.
-    def silence(temporary_level = Logger::ERROR)
-      if silencer
-        begin
-          old_local_level            = local_level
-          self.local_level           = temporary_level
-
-          yield self
-        ensure
-          self.local_level = old_local_level
-        end
-      else
-        yield self
-      end
+    def silence(severity = Logger::ERROR)
+      silencer ? log_at(severity) { yield self } : yield(self)
     end
   end
 end

data/lib/active_support/logger_thread_safe_level.rb

@@ -21,13 +21,6 @@ module ActiveSupport
       EOT
     end
 
-    def after_initialize
-      ActiveSupport::Deprecation.warn(
-        "Logger don't need to call #after_initialize directly anymore. It will be deprecated without replacement in " \
-        "Rails 6.1."
-      )
-    end
-
     def local_log_id
       Fiber.current.__id__
     end
@@ -37,10 +30,15 @@ module ActiveSupport
     end
 
     def local_level=(level)
-      if level
+      case level
+      when Integer
         self.class.local_levels[local_log_id] = level
-      else
+      when Symbol
+        self.class.local_levels[local_log_id] = Logger::Severity.const_get(level.to_s.upcase)
+      when nil
         self.class.local_levels.delete(local_log_id)
+      else
+        raise ArgumentError, "Invalid log level: #{level.inspect}"
       end
     end
 
@@ -48,9 +46,33 @@ module ActiveSupport
       local_level || super
     end
 
-    def add(severity, message = nil, progname = nil, &block) # :nodoc:
-      return true if @logdev.nil? || (severity || UNKNOWN) < level
-      super
+    # Change the thread-local level for the duration of the given block.
+    def log_at(level)
+      old_local_level, self.local_level = local_level, level
+      yield
+    ensure
+      self.local_level = old_local_level
+    end
+
+    # Redefined to check severity against #level, and thus the thread-local level, rather than +@level+.
+    # FIXME: Remove when the minimum Ruby version supports overriding Logger#level.
+    def add(severity, message = nil, progname = nil, &block) #:nodoc:
+      severity ||= UNKNOWN
+      progname ||= @progname
+
+      return true if @logdev.nil? || severity < level
+
+      if message.nil?
+        if block_given?
+          message  = yield
+        else
+          message  = progname
+          progname = @progname
+        end
+      end
+
+      @logdev.write \
+        format_message(format_severity(severity), Time.now, progname, message)
     end
   end
 end

data/lib/active_support/message_encryptor.rb

@@ -2,7 +2,6 @@
 
 require "openssl"
 require "base64"
-require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/message_verifier"
 require "active_support/messages/metadata"
@@ -134,15 +133,13 @@ module ActiveSupport
     # * <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 +Marshal+.
-    def initialize(secret, *signature_key_or_options)
-      options = signature_key_or_options.extract_options!
-      sign_secret = signature_key_or_options.first
+    def initialize(secret, sign_secret = nil, cipher: nil, digest: nil, serializer: nil)
       @secret = secret
       @sign_secret = sign_secret
-      @cipher = options[:cipher] || self.class.default_cipher
-      @digest = options[:digest] || "SHA1" unless aead_mode?
+      @cipher = cipher || self.class.default_cipher
+      @digest = digest || "SHA1" unless aead_mode?
       @verifier = resolve_verifier
-      @serializer = options[:serializer] || Marshal
+      @serializer = serializer || Marshal
     end
 
     # Encrypt and sign a message. We need to sign the message in order to avoid

data/lib/active_support/message_verifier.rb

@@ -103,11 +103,11 @@ module ActiveSupport
 
     class InvalidSignature < StandardError; end
 
-    def initialize(secret, options = {})
+    def initialize(secret, digest: nil, serializer: nil)
       raise ArgumentError, "Secret should not be nil." unless secret
       @secret = secret
-      @digest = options[:digest] || "SHA1"
-      @serializer = options[:serializer] || Marshal
+      @digest = digest || "SHA1"
+      @serializer = serializer || Marshal
     end
 
     # Checks if a signed message could have been generated by signing an object
@@ -178,8 +178,8 @@ module ActiveSupport
 
     # Generates a signed message for the provided value.
     #
-    # The message is signed with the +MessageVerifier+'s secret. Without knowing
-    # the secret, the original value cannot be extracted from the message.
+    # The message is signed with the +MessageVerifier+'s secret.
+    # Returns Base64-encoded message joined with the generated signature.
     #
     #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
     #   verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"