activesupport 4.2.11.3 → 5.2.8.1

data/lib/active_support/json/decoding.rb

@@ -1,6 +1,8 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/module/delegation'
-require 'json'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/module/delegation"
+require "json"
 
 module ActiveSupport
   # Look for and parse json strings that look like ISO 8601 times.
@@ -8,21 +10,16 @@ module ActiveSupport
 
   module JSON
     # matches YAML-formatted dates
-    DATE_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 = /^\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})?)?)$/
+
     class << self
       # Parses a JSON string (JavaScript Object Notation) into a hash.
       # See http://www.json.org for more info.
       #
       #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
       #   => {"team" => "rails", "players" => "36"}
-      def decode(json, options = {})
-        if options.present?
-          raise ArgumentError, "In Rails 4.1, ActiveSupport::JSON.decode no longer " \
-            "accepts an options hash for MultiJSON. MultiJSON reached its end of life " \
-            "and has been removed."
-        end
-
+      def decode(json)
         data = ::JSON.parse(json, quirks_mode: true)
 
         if ActiveSupport.parse_json_times
@@ -54,7 +51,13 @@ module ActiveSupport
           nil
         when DATE_REGEX
           begin
-            DateTime.parse(data)
+            Date.parse(data)
+          rescue ArgumentError
+            data
+          end
+        when DATETIME_REGEX
+          begin
+            Time.zone.parse(data)
           rescue ArgumentError
             data
           end

data/lib/active_support/json/encoding.rb

@@ -1,15 +1,15 @@
-require 'active_support/core_ext/object/json'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/deprecation'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/json"
+require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
   class << self
     delegate :use_standard_json_time_format, :use_standard_json_time_format=,
       :time_precision, :time_precision=,
       :escape_html_entities_in_json, :escape_html_entities_in_json=,
-      :encode_big_decimal_as_string, :encode_big_decimal_as_string=,
       :json_encoder, :json_encoder=,
-      :to => :'ActiveSupport::JSON::Encoding'
+      to: :'ActiveSupport::JSON::Encoding'
   end
 
   module JSON
@@ -42,9 +42,9 @@ module ActiveSupport
           ESCAPED_CHARS = {
             "\u2028" => '\u2028',
             "\u2029" => '\u2029',
-            '>'      => '\u003e',
-            '<'      => '\u003c',
-            '&'      => '\u0026',
+            ">"      => '\u003e',
+            "<"      => '\u003c',
+            "&"      => '\u0026',
             }
 
           ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
@@ -70,7 +70,8 @@ module ActiveSupport
             :ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, :EscapedString
 
           # Convert an object into a "JSON-ready" representation composed of
-          # primitives like Hash, Array, String, Numeric, and true/false/nil.
+          # primitives like Hash, Array, String, Numeric,
+          # and +true+/+false+/+nil+.
           # Recursively calls #as_json to the object to recursively build a
           # fully JSON-ready object.
           #
@@ -86,7 +87,7 @@ module ActiveSupport
             when String
               EscapedString.new(value)
             when Numeric, NilClass, TrueClass, FalseClass
-              value
+              value.as_json
             when Hash
               Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
             when Array
@@ -118,54 +119,6 @@ module ActiveSupport
         # Sets the encoder used by Rails to encode Ruby objects into JSON strings
         # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
         attr_accessor :json_encoder
-
-        def encode_big_decimal_as_string=(as_string)
-          message = \
-            "The JSON encoder in Rails 4.1 no longer supports encoding BigDecimals as JSON numbers. Instead, " \
-            "the new encoder will always encode them as strings.\n\n" \
-            "You are seeing this error because you have 'active_support.encode_big_decimal_as_string' in " \
-            "your configuration file. If you have been setting this to true, you can safely remove it from " \
-            "your configuration. Otherwise, you should add the 'activesupport-json_encoder' gem to your " \
-            "Gemfile in order to restore this functionality."
-
-          raise NotImplementedError, message
-        end
-
-        def encode_big_decimal_as_string
-          message = \
-            "The JSON encoder in Rails 4.1 no longer supports encoding BigDecimals as JSON numbers. Instead, " \
-            "the new encoder will always encode them as strings.\n\n" \
-            "You are seeing this error because you are trying to check the value of the related configuration, " \
-            "`active_support.encode_big_decimal_as_string`. If your application depends on this option, you should " \
-            "add the 'activesupport-json_encoder' gem to your Gemfile. For now, this option will always be true. " \
-            "In the future, it will be removed from Rails, so you should stop checking its value."
-
-          ActiveSupport::Deprecation.warn message
-
-          true
-        end
-
-        # Deprecate CircularReferenceError
-        def const_missing(name)
-          if name == :CircularReferenceError
-            message = "The JSON encoder in Rails 4.1 no longer offers protection from circular references. " \
-                      "You are seeing this warning because you are rescuing from (or otherwise referencing) " \
-                      "ActiveSupport::Encoding::CircularReferenceError. In the future, this error will be " \
-                      "removed from Rails. You should remove these rescue blocks from your code and ensure " \
-                      "that your data structures are free of circular references so they can be properly " \
-                      "serialized into JSON.\n\n" \
-                      "For example, the following Hash contains a circular reference to itself:\n" \
-                      "   h = {}\n" \
-                      "   h['circular'] = h\n" \
-                      "In this case, calling h.to_json would not work properly."
-
-            ActiveSupport::Deprecation.warn message
-
-            SystemStackError
-          else
-            super
-          end
-        end
       end
 
       self.use_standard_json_time_format = true

data/lib/active_support/json.rb

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

data/lib/active_support/key_generator.rb

@@ -1,8 +1,10 @@
-require 'thread_safe'
-require 'openssl'
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "openssl"
 
 module ActiveSupport
-  # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2
+  # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2.
   # It can be used to derive a number of keys for various purposes from a given secret.
   # This lets Rails applications have a single secure secret, but avoid reusing that
   # key in multiple incompatible contexts.
@@ -17,25 +19,23 @@ module ActiveSupport
     # Returns a derived key suitable for use.  The default key_size is chosen
     # to be compatible with the default settings of ActiveSupport::MessageVerifier.
     # i.e. OpenSSL::Digest::SHA1#block_length
-    def generate_key(salt, key_size=64)
+    def generate_key(salt, key_size = 64)
       OpenSSL::PKCS5.pbkdf2_hmac_sha1(@secret, salt, @iterations, key_size)
     end
   end
 
   # CachingKeyGenerator is a wrapper around KeyGenerator which allows users to avoid
   # re-executing the key generation process when it's called using the same salt and
-  # key_size
+  # key_size.
   class CachingKeyGenerator
     def initialize(key_generator)
       @key_generator = key_generator
-      @cache_keys = ThreadSafe::Cache.new
+      @cache_keys = Concurrent::Map.new
     end
 
-    # Returns a derived key suitable for use.  The default key_size is chosen
-    # to be compatible with the default settings of ActiveSupport::MessageVerifier.
-    # i.e. OpenSSL::Digest::SHA1#block_length
-    def generate_key(salt, key_size=64)
-      @cache_keys["#{salt}#{key_size}"] ||= @key_generator.generate_key(salt, key_size)
+    # Returns a derived key suitable for use.
+    def generate_key(*args)
+      @cache_keys[args.join] ||= @key_generator.generate_key(*args)
     end
   end
 
@@ -53,21 +53,21 @@ module ActiveSupport
 
     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
+      # 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."
+        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
 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
@@ -15,34 +17,62 @@ module ActiveSupport
   #     end
   #   end
   #
-  # When the entirety of +activerecord/lib/active_record/base.rb+ has been
+  # When the entirety of +ActiveRecord::Base+ has been
   # evaluated then +run_load_hooks+ is invoked. The very last line of
-  # +activerecord/lib/active_record/base.rb+ is:
+  # +ActiveRecord::Base+ is:
   #
   #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  @load_hooks = Hash.new { |h,k| h[k] = [] }
-  @loaded = Hash.new { |h,k| h[k] = [] }
-
-  def self.on_load(name, options = {}, &block)
-    @loaded[name].each do |base|
-      execute_hook(base, options, block)
+  module LazyLoadHooks
+    def self.extended(base) # :nodoc:
+      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
 
-    @load_hooks[name] << [block, options]
-  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(name, base, options, block)
+      end
 
-  def self.execute_hook(base, options, block)
-    if options[:yield]
-      block.call(base)
-    else
-      base.instance_eval(&block)
+      @load_hooks[name] << [block, options]
     end
-  end
 
-  def self.run_load_hooks(name, base = Object)
-    @loaded[name] << base
-    @load_hooks[name].each do |hook, options|
-      execute_hook(base, options, hook)
+    def run_load_hooks(name, base = Object)
+      @loaded[name] << base
+      @load_hooks[name].each do |hook, options|
+        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
+            base.instance_eval(&block)
+          end
+        end
+      end
   end
+
+  extend LazyLoadHooks
 end

data/lib/active_support/locale/en.yml

@@ -106,6 +106,8 @@ en:
           mb: "MB"
           gb: "GB"
           tb: "TB"
+          pb: "PB"
+          eb: "EB"
       # Used in NumberHelper.number_to_human()
       decimal_units:
         format: "%n %u"

data/lib/active_support/log_subscriber/test_helper.rb

@@ -1,6 +1,8 @@
-require 'active_support/log_subscriber'
-require 'active_support/logger'
-require 'active_support/notifications'
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+require "active_support/logger"
+require "active_support/notifications"
 
 module ActiveSupport
   class LogSubscriber
@@ -10,7 +12,7 @@ module ActiveSupport
     #   class SyncLogSubscriberTest < ActiveSupport::TestCase
     #     include ActiveSupport::LogSubscriber::TestHelper
     #
-    #     def setup
+    #     setup do
     #       ActiveRecord::LogSubscriber.attach_to(:active_record)
     #     end
     #
@@ -33,7 +35,7 @@ module ActiveSupport
     # you can collect them doing @logger.logged(level), where level is the level
     # used in logging, like info, debug, warn and so on.
     module TestHelper
-      def setup
+      def setup # :nodoc:
         @logger   = MockLogger.new
         @notifier = ActiveSupport::Notifications::Fanout.new
 
@@ -44,7 +46,7 @@ module ActiveSupport
         ActiveSupport::Notifications.notifier = @notifier
       end
 
-      def teardown
+      def teardown # :nodoc:
         set_logger(nil)
         ActiveSupport::Notifications.notifier = @old_notifier
       end
@@ -58,15 +60,15 @@ module ActiveSupport
         def initialize(level = DEBUG)
           @flush_count = 0
           @level = level
-          @logged = Hash.new { |h,k| h[k] = [] }
+          @logged = Hash.new { |h, k| h[k] = [] }
         end
 
         def method_missing(level, message = nil)
-           if block_given?
-             @logged[level] << yield
-           else
-             @logged[level] << message
-           end
+          if block_given?
+            @logged[level] << yield
+          else
+            @logged[level] << message
+          end
         end
 
         def logged(level)

data/lib/active_support/log_subscriber.rb

@@ -1,6 +1,8 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/subscriber'
+# 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
@@ -49,8 +51,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
@@ -81,11 +82,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
 
-  protected
+  private
 
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
@@ -95,11 +98,11 @@ module ActiveSupport
       METHOD
     end
 
-    # Set color by using a string or one of the defined constants. If a third
+    # Set color by using a symbol or one of the defined constants. If a third
     # option is set to +true+, it also adds bold to the string. This is based
     # on the Highline implementation and will automatically append CLEAR to the
     # end of the returned String.
-    def color(text, color, bold=false)
+    def color(text, color, bold = false) # :doc:
       return text unless colorize_logging
       color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
       bold  = bold ? BOLD : ""

data/lib/active_support/logger.rb

@@ -1,7 +1,8 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/logger_silence'
-require 'active_support/logger_thread_safe_level'
-require 'logger'
+# frozen_string_literal: true
+
+require "active_support/logger_silence"
+require "active_support/logger_thread_safe_level"
+require "logger"
 
 module ActiveSupport
   class Logger < ::Logger
@@ -58,16 +59,16 @@ module ActiveSupport
         end
 
         define_method(:silence) do |level = Logger::ERROR, &block|
-          if logger.respond_to?(:silence) && logger.method(:silence).owner != ::Kernel
+          if logger.respond_to?(:silence)
             logger.silence(level) do
-              if respond_to?(:silence) && method(:silence).owner != ::Kernel
+              if defined?(super)
                 super(level, &block)
               else
                 block.call(self)
               end
             end
           else
-            if respond_to?(:silence) && method(:silence).owner != ::Kernel
+            if defined?(super)
               super(level, &block)
             else
               block.call(self)

data/lib/active_support/logger_silence.rb

@@ -1,12 +1,14 @@
-require 'active_support/concern'
-require 'thread_safe'
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors"
+require "concurrent"
 
 module LoggerSilence
   extend ActiveSupport::Concern
 
   included do
-    cattr_accessor :silencer
-    self.silencer = true
+    cattr_accessor :silencer, default: true
   end
 
   # Silences the logger for the duration of the block.

data/lib/active_support/logger_thread_safe_level.rb

@@ -1,16 +1,18 @@
-require 'active_support/concern'
-require 'thread_safe'
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "fiber"
 
 module ActiveSupport
-  module LoggerThreadSafeLevel
+  module LoggerThreadSafeLevel # :nodoc:
     extend ActiveSupport::Concern
 
     def after_initialize
-      @local_levels = ThreadSafe::Cache.new
+      @local_levels = Concurrent::Map.new(initial_capacity: 2)
     end
 
     def local_log_id
-      Thread.current.__id__
+      Fiber.current.__id__
     end
 
     def local_level