activesupport 5.1.1 → 6.1.1

data/lib/active_support/json/encoding.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/json"
 require "active_support/core_ext/module/delegation"
 
@@ -52,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
 
@@ -87,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/json.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require "active_support/json/decoding"
 require "active_support/json/encoding"

data/lib/active_support/key_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
 require "openssl"
 
@@ -33,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)
-    end
-  end
-
-  class LegacyKeyGenerator # :nodoc:
-    SECRET_MIN_LENGTH = 30 # Characters
-
-    def initialize(secret)
-      ensure_secret_secure(secret)
-      @secret = secret
+      @cache_keys[args.join("|")] ||= @key_generator.generate_key(*args)
     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 config/secrets.yml."
-        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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   # lazy_load_hooks allows Rails to lazily load a lot of components and thus
   # making the app boot faster. Because of this feature now there is no need to
@@ -25,33 +27,54 @@ module ActiveSupport
       base.class_eval do
         @load_hooks = Hash.new { |h, k| h[k] = [] }
         @loaded     = Hash.new { |h, k| h[k] = [] }
+        @run_once   = Hash.new { |h, k| h[k] = [] }
       end
     end
 
     # Declares a block that will be executed when a Rails component is fully
     # loaded.
+    #
+    # Options:
+    #
+    # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
+    # * <tt>:run_once</tt> - Given +block+ will run only once.
     def on_load(name, options = {}, &block)
       @loaded[name].each do |base|
-        execute_hook(base, options, block)
+        execute_hook(name, base, options, block)
       end
 
       @load_hooks[name] << [block, options]
     end
 
-    def execute_hook(base, options, block)
-      if options[:yield]
-        block.call(base)
-      else
-        base.instance_eval(&block)
-      end
-    end
-
     def run_load_hooks(name, base = Object)
       @loaded[name] << base
       @load_hooks[name].each do |hook, options|
-        execute_hook(base, options, hook)
+        execute_hook(name, base, options, hook)
       end
     end
+
+    private
+      def with_execution_control(name, block, once)
+        unless @run_once[name].include?(block)
+          @run_once[name] << block if once
+
+          yield
+        end
+      end
+
+      def execute_hook(name, base, options, block)
+        with_execution_control(name, block, options[:run_once]) do
+          if options[:yield]
+            block.call(base)
+          else
+            if base.is_a?(Module)
+              base.class_eval(&block)
+            else
+              base.instance_eval(&block)
+            end
+          end
+        end
+      end
   end
 
   extend LazyLoadHooks

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: !ruby/sym 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/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/log_subscriber"
 require "active_support/logger"
 require "active_support/notifications"

data/lib/active_support/log_subscriber.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
 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.
   #
@@ -14,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
@@ -27,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"
@@ -49,8 +77,7 @@ module ActiveSupport
     CYAN    = "\e[36m"
     WHITE   = "\e[37m"
 
-    mattr_accessor :colorize_logging
-    self.colorize_logging = true
+    mattr_accessor :colorize_logging, default: true
 
     class << self
       def logger
@@ -69,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
@@ -81,12 +113,13 @@ module ActiveSupport
 
     def finish(name, id, payload)
       super if logger
-    rescue Exception => e
-      logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
+    rescue => e
+      if logger
+        logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
+      end
     end
 
   private
-
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{level}(progname = nil, &block)

data/lib/active_support/logger.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require "active_support/logger_silence"
 require "active_support/logger_thread_safe_level"
 require "logger"
 
 module ActiveSupport
   class Logger < ::Logger
-    include ActiveSupport::LoggerThreadSafeLevel
     include LoggerSilence
 
     # Returns true if the logger destination matches one of the sources
@@ -13,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
@@ -76,23 +77,9 @@ module ActiveSupport
       end
     end
 
-    def initialize(*args)
+    def initialize(*args, **kwargs)
       super
       @formatter = SimpleFormatter.new
-      after_initialize if respond_to? :after_initialize
-    end
-
-    def add(severity, message = nil, progname = nil, &block)
-      return true if @logdev.nil? || (severity || UNKNOWN) < level
-      super
-    end
-
-    Logger::Severity.constants.each do |severity|
-      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
     end
 
     # Simple formatter which only displays the message.

data/lib/active_support/logger_silence.rb

@@ -1,28 +1,21 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
-require "concurrent"
-
-module LoggerSilence
-  extend ActiveSupport::Concern
+require "active_support/logger_thread_safe_level"
 
-  included do
-    cattr_accessor :silencer
-    self.silencer = true
-  end
+module ActiveSupport
+  module LoggerSilence
+    extend ActiveSupport::Concern
 
-  # 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
+    included do
+      cattr_accessor :silencer, default: true
+      include ActiveSupport::LoggerThreadSafeLevel
+    end
 
-        yield self
-      ensure
-        self.local_level = old_local_level
-      end
-    else
-      yield self
+    # Silences the logger for the duration of the block.
+    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

@@ -1,31 +1,78 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors"
+require "concurrent"
+require "fiber"
 
 module ActiveSupport
   module LoggerThreadSafeLevel # :nodoc:
     extend ActiveSupport::Concern
 
-    def after_initialize
-      @local_levels = Concurrent::Map.new(initial_capacity: 2)
+    included do
+      cattr_accessor :local_levels, default: Concurrent::Map.new(initial_capacity: 2), instance_accessor: false
+    end
+
+    Logger::Severity.constants.each do |severity|
+      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
+        def #{severity.downcase}?                # def debug?
+          Logger::#{severity} >= level           #   DEBUG >= level
+        end                                      # end
+      EOT
     end
 
     def local_log_id
-      Thread.current.__id__
+      Fiber.current.__id__
     end
 
     def local_level
-      @local_levels[local_log_id]
+      self.class.local_levels[local_log_id]
     end
 
     def local_level=(level)
-      if level
-        @local_levels[local_log_id] = level
+      case level
+      when Integer
+        self.class.local_levels[local_log_id] = level
+      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
-        @local_levels.delete(local_log_id)
+        raise ArgumentError, "Invalid log level: #{level.inspect}"
       end
     end
 
     def level
       local_level || super
     end
+
+    # 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