activesupport 5.2.7.1 → 6.1.4.6

data/lib/active_support/inflector/inflections.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
-require "active_support/core_ext/array/prepend_and_append"
-require "active_support/core_ext/regexp"
 require "active_support/i18n"
-require "active_support/deprecation"
 
 module ActiveSupport
   module Inflector
@@ -67,8 +64,7 @@ module ActiveSupport
         @__instance__[locale] ||= new
       end
 
-      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
-      deprecate :acronym_regex
+      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms
 
       attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
 
@@ -80,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
@@ -233,7 +229,6 @@ module ActiveSupport
       end
 
       private
-
         def define_acronym_regex_patterns
           @acronym_regex             = @acronyms.empty? ? /(?=a)b/ : /#{@acronyms.values.join("|")}/
           @acronyms_camelize_regex   = /^(?:#{@acronym_regex}(?=\b|[A-Z_])|\w)/

data/lib/active_support/inflector/methods.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/inflections"
-require "active_support/core_ext/regexp"
+require "active_support/core_ext/object/blank"
 
 module ActiveSupport
   # The Inflector transforms words from singular to plural, class names to table
@@ -74,7 +74,7 @@ module ActiveSupport
         string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase }
       end
       string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!("/".freeze, "::".freeze)
+      string.gsub!("/", "::")
       string
     end
 
@@ -91,11 +91,11 @@ module ActiveSupport
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
       return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
-      word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
-      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_'.freeze }#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-      word.tr!("-".freeze, "_".freeze)
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
       word.downcase!
       word
     end
@@ -131,11 +131,11 @@ module ActiveSupport
 
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
 
-      result.sub!(/\A_+/, "".freeze)
+      result.sub!(/\A_+/, "")
       unless keep_id_suffix
-        result.sub!(/_id\z/, "".freeze)
+        result.delete_suffix!("_id")
       end
-      result.tr!("_".freeze, " ".freeze)
+      result.tr!("_", " ")
 
       result.gsub!(/([a-z\d]*)/i) do |match|
         "#{inflections.acronyms[match.downcase] || match.downcase}"
@@ -173,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
@@ -197,17 +197,17 @@ module ActiveSupport
     #
     # Singular names are not handled correctly:
     #
-    #   classify('calculus')     # => "Calculus"
+    #   classify('calculus')     # => "Calculu"
     def classify(table_name)
       # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, "".freeze)))
+      camelize(singularize(table_name.to_s.sub(/.*\./, "")))
     end
 
     # Replaces underscores with dashes in the string.
     #
     #   dasherize('puni_puni') # => "puni-puni"
     def dasherize(underscored_word)
-      underscored_word.tr("_".freeze, "-".freeze)
+      underscored_word.tr("_", "-")
     end
 
     # Removes the module part from the expression in the string.
@@ -270,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("::".freeze)
-
-      # 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
@@ -327,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
@@ -343,18 +346,7 @@ module ActiveSupport
     #   ordinal(-11)   # => "th"
     #   ordinal(-1021) # => "st"
     def ordinal(number)
-      abs_number = number.to_i.abs
-
-      if (11..13).include?(abs_number % 100)
-        "th"
-      else
-        case abs_number % 10
-        when 1; "st"
-        when 2; "nd"
-        when 3; "rd"
-        else    "th"
-        end
-      end
+      I18n.translate("number.nth.ordinals", number: number)
     end
 
     # Turns a number into an ordinal string used to denote the position in an
@@ -367,24 +359,23 @@ module ActiveSupport
     #   ordinalize(-11)   # => "-11th"
     #   ordinalize(-1021) # => "-1021st"
     def ordinalize(number)
-      "#{number}#{ordinal(number)}"
+      I18n.translate("number.nth.ordinalized", number: number)
     end
 
     private
-
       # Mounts a regular expression, returned as a string to ease interpolation,
       # that will match part by part the given constant.
       #
       #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
       #   const_regexp("::")            # => "::"
       def const_regexp(camel_cased_word)
-        parts = camel_cased_word.split("::".freeze)
+        parts = camel_cased_word.split("::")
 
         return Regexp.escape(camel_cased_word) if parts.blank?
 
         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 "?".
     #
@@ -51,20 +53,43 @@ module ActiveSupport
     #
     # Now you can have different transliterations for each locale:
     #
-    #   I18n.locale = :en
-    #   transliterate('Jürgen')
+    #   transliterate('Jürgen', locale: :en)
     #   # => "Jurgen"
     #
-    #   I18n.locale = :de
-    #   transliterate('Jürgen')
+    #   transliterate('Jürgen', locale: :de)
     #   # => "Juergen"
-    def transliterate(string, replacement = "?".freeze)
+    #
+    # Transliteration is restricted to UTF-8, US-ASCII and GB18030 strings
+    # Other encodings will raise an ArgumentError.
+    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)
+      raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
+
+      input_encoding = string.encoding
+
+      # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if
+      # US-ASCII is given. This way we can let tidy_bytes handle the string
+      # in the same way as we do for UTF-8
+      string.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::US_ASCII
+
+      # GB18030 is Unicode compatible but is not a direct mapping so needs to be
+      # transcoded. Using invalid/undef :replace will result in loss of data in
+      # the event of invalid characters, but since tidy_bytes will replace
+      # invalid/undef with a "?" we're safe to do the same beforehand
+      string.encode!(Encoding::UTF_8, invalid: :replace, undef: :replace) if string.encoding == Encoding::GB18030
+
+      transliterated = I18n.transliterate(
+        ActiveSupport::Multibyte::Unicode.tidy_bytes(string).unicode_normalize(:nfc),
+        replacement: replacement,
+        locale: locale
+      )
+
+      # Restore the string encoding of the input if it was not UTF-8.
+      # Apply invalid/undef :replace as tidy_bytes does
+      transliterated.encode!(input_encoding, invalid: :replace, undef: :replace) if input_encoding != transliterated.encoding
 
-      I18n.transliterate(
-        ActiveSupport::Multibyte::Unicode.normalize(
-          ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
-        replacement: replacement)
+      transliterated
     end
 
     # Replaces special characters in a string so that it may be used as part of
@@ -75,8 +100,8 @@ module ActiveSupport
     #
     # To use a custom separator, override the +separator+ argument.
     #
-    #  parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
-    #  parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
+    #   parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
+    #   parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
     #
     # To preserve the case of the characters in a string, use the +preserve_case+ argument.
     #
@@ -85,19 +110,23 @@ module ActiveSupport
     #
     # It preserves dashes and underscores unless they are used as separators:
     #
-    #  parameterize("^très|Jolie__ ")                 # => "tres-jolie__"
-    #  parameterize("^très|Jolie-- ", separator: "_") # => "tres_jolie--"
-    #  parameterize("^très_Jolie-- ", separator: ".") # => "tres_jolie--"
+    #   parameterize("^très|Jolie__ ")                 # => "tres-jolie__"
+    #   parameterize("^très|Jolie-- ", separator: "_") # => "tres_jolie--"
+    #   parameterize("^très_Jolie-- ", separator: ".") # => "tres_jolie--"
     #
-    def parameterize(string, separator: "-", preserve_case: false)
+    # 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>.
+    def parameterize(string, separator: "-", preserve_case: false, locale: nil)
       # Replace accented chars with their ASCII equivalents.
-      parameterized_string = transliterate(string)
+      parameterized_string = transliterate(string, locale: locale)
 
       # Turn unwanted chars into the separator.
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
 
       unless separator.nil? || separator.empty?
-        if separator == "-".freeze
+        if separator == "-"
           re_duplicate_separator        = /-{2,}/
           re_leading_trailing_separator = /^-|-$/i
         else
@@ -108,7 +137,7 @@ module ActiveSupport
         # No more than one of the separator in a row.
         parameterized_string.gsub!(re_duplicate_separator, separator)
         # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "".freeze)
+        parameterized_string.gsub!(re_leading_trailing_separator, "")
       end
 
       parameterized_string.downcase! unless preserve_case

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.
@@ -44,33 +44,32 @@ module ActiveSupport
       end
 
       private
-
-      def convert_dates_from(data)
-        case data
-        when nil
-          nil
-        when DATE_REGEX
-          begin
-            Date.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when DATETIME_REGEX
-          begin
-            Time.zone.parse(data)
-          rescue ArgumentError
+        def convert_dates_from(data)
+          case data
+          when nil
+            nil
+          when DATE_REGEX
+            begin
+              Date.parse(data)
+            rescue ArgumentError
+              data
+            end
+          when DATETIME_REGEX
+            begin
+              Time.zone.parse(data)
+            rescue ArgumentError
+              data
+            end
+          when Array
+            data.map! { |d| convert_dates_from(d) }
+          when Hash
+            data.transform_values! do |value|
+              convert_dates_from(value)
+            end
+          else
             data
           end
-        when Array
-          data.map! { |d| convert_dates_from(d) }
-        when Hash
-          data.each do |key, value|
-            data[key] = convert_dates_from(value)
-          end
-        else
-          data
         end
-      end
     end
   end
 end

data/lib/active_support/json/encoding.rb

@@ -54,9 +54,13 @@ module ActiveSupport
           class EscapedString < String #:nodoc:
             def to_json(*)
               if Encoding.escape_html_entities_in_json
-                super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
+                s = super
+                s.gsub! ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
+                s
               else
-                super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
+                s = super
+                s.gsub! ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
+                s
               end
             end
 
@@ -89,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,39 +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
-
-  class LegacyKeyGenerator # :nodoc:
-    SECRET_MIN_LENGTH = 30 # Characters
-
-    def initialize(secret)
-      ensure_secret_secure(secret)
-      @secret = secret
-    end
-
-    def generate_key(salt)
-      @secret
-    end
-
-    private
-
-      # To prevent users from using something insecure like "Password" we make sure that the
-      # secret they've provided is at least 30 characters in length.
-      def ensure_secret_secure(secret)
-        if secret.blank?
-          raise ArgumentError, "A secret is required to generate an integrity hash " \
-            "for cookie session data. Set a secret_key_base of at least " \
-            "#{SECRET_MIN_LENGTH} characters in via `bin/rails credentials:edit`."
-        end
-
-        if secret.length < SECRET_MIN_LENGTH
-          raise ArgumentError, "Secret should be something secure, " \
-            "like \"#{SecureRandom.hex(16)}\". The value you " \
-            "provided, \"#{secret}\", is shorter than the minimum length " \
-            "of #{SECRET_MIN_LENGTH} characters."
-        end
-      end
-  end
 end

data/lib/active_support/lazy_load_hooks.rb

@@ -54,7 +54,6 @@ module ActiveSupport
     end
 
     private
-
       def with_execution_control(name, block, once)
         unless @run_once[name].include?(block)
           @run_once[name] << block if once
@@ -68,7 +67,11 @@ module ActiveSupport
           if options[:yield]
             block.call(base)
           else
-            base.instance_eval(&block)
+            if base.is_a?(Module)
+              base.class_eval(&block)
+            else
+              base.instance_eval(&block)
+            end
           end
         end
       end

data/lib/active_support/locale/en.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+{
+  en: {
+    number: {
+      nth: {
+        ordinals: lambda do |_key, options|
+          number = options[:number]
+          case number
+          when 1; "st"
+          when 2; "nd"
+          when 3; "rd"
+          when 4, 5, 6, 7, 8, 9, 10, 11, 12, 13; "th"
+          else
+            num_modulo = number.to_i.abs % 100
+            num_modulo %= 10 if num_modulo > 13
+            case num_modulo
+            when 1; "st"
+            when 2; "nd"
+            when 3; "rd"
+            else    "th"
+            end
+          end
+        end,
+
+        ordinalized: lambda do |_key, options|
+          number = options[:number]
+          "#{number}#{ActiveSupport::Inflector.ordinal(number)}"
+        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

@@ -5,8 +5,8 @@ require "active_support/core_ext/class/attribute"
 require "active_support/subscriber"
 
 module ActiveSupport
-  # ActiveSupport::LogSubscriber is an object set to consume
-  # ActiveSupport::Notifications with the sole purpose of logging them.
+  # <tt>ActiveSupport::LogSubscriber</tt> is an object set to consume
+  # <tt>ActiveSupport::Notifications</tt> with the sole purpose of logging them.
   # The log subscriber dispatches notifications to a registered object based
   # on its given namespace.
   #
@@ -16,7 +16,7 @@ module ActiveSupport
   #   module ActiveRecord
   #     class LogSubscriber < ActiveSupport::LogSubscriber
   #       def sql(event)
-  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
+  #         info "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
   #       end
   #     end
   #   end
@@ -29,13 +29,39 @@ module ActiveSupport
   # subscriber, the line above should be called after your
   # <tt>ActiveRecord::LogSubscriber</tt> definition.
   #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the sql method.
+  # 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.
+  #
+  # Being an <tt>ActiveSupport::Notifications</tt> consumer,
+  # <tt>ActiveSupport::LogSubscriber</tt> exposes a simple interface to check if
+  # instrumented code raises an exception. It is common to log a different
+  # message in case of an error, and this can be achieved by extending
+  # the previous example:
+  #
+  #   module ActiveRecord
+  #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       def sql(event)
+  #         exception = event.payload[:exception]
+  #
+  #         if exception
+  #           exception_object = event.payload[:exception_object]
+  #
+  #           error "[ERROR] #{event.payload[:name]}: #{exception.join(', ')} " \
+  #                 "(#{exception_object.backtrace.first})"
+  #         else
+  #           # standard logger code
+  #         end
+  #       end
+  #     end
+  #   end
   #
   # Log subscriber also has some helpers to deal with logging and automatically
-  # flushes all logs when the request finishes (via action_dispatch.callback
-  # notification) in a Rails environment.
+  # flushes all logs when the request finishes
+  # (via <tt>action_dispatch.callback</tt> notification) in a Rails environment.
   class LogSubscriber < Subscriber
     # Embed in a String to clear all previous ANSI sequences.
     CLEAR   = "\e[0m"
@@ -70,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
@@ -89,7 +120,6 @@ module ActiveSupport
     end
 
   private
-
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{level}(progname = nil, &block)