activesupport 4.0.13 → 4.2.11.3

data/lib/active_support/json/encoding.rb

@@ -1,338 +1,177 @@
-require 'active_support/core_ext/object/to_json'
+require 'active_support/core_ext/object/json'
 require 'active_support/core_ext/module/delegation'
-require 'active_support/json/variable'
-
-require 'bigdecimal'
-require 'active_support/core_ext/big_decimal/conversions' # for #to_s
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
-require 'active_support/core_ext/object/instance_variables'
-require 'time'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/date/conversions'
-require 'set'
+require 'active_support/deprecation'
 
 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'
   end
 
   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})?))$/
-
     # Dumps objects in JSON (JavaScript Object Notation).
-    # See www.json.org for more info.
+    # See http://www.json.org for more info.
     #
     #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
     #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
     def self.encode(value, options = nil)
-      Encoding::Encoder.new(options).encode(value)
+      Encoding.json_encoder.new(options).encode(value)
     end
 
     module Encoding #:nodoc:
-      class CircularReferenceError < StandardError; end
-
-      class Encoder
+      class JSONGemEncoder #:nodoc:
         attr_reader :options
 
         def initialize(options = nil)
           @options = options || {}
-          @seen = Set.new
         end
 
-        def encode(value, use_options = true)
-          check_for_circular_references(value) do
-            jsonified = use_options ? value.as_json(options_for(value)) : value.as_json
-            jsonified.encode_json(self)
-          end
+        # Encode the given object into a JSON string
+        def encode(value)
+          stringify jsonify value.as_json(options.dup)
         end
 
-        # like encode, but only calls as_json, without encoding to string.
-        def as_json(value, use_options = true)
-          check_for_circular_references(value) do
-            use_options ? value.as_json(options_for(value)) : value.as_json
-          end
-        end
+        private
+          # Rails does more escaping than the JSON gem natively does (we
+          # escape \u2028 and \u2029 and optionally >, <, & to work around
+          # certain browser problems).
+          ESCAPED_CHARS = {
+            "\u2028" => '\u2028',
+            "\u2029" => '\u2029',
+            '>'      => '\u003e',
+            '<'      => '\u003c',
+            '&'      => '\u0026',
+            }
+
+          ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
+          ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = /[\u2028\u2029]/u
+
+          # This class wraps all the strings we see and does the extra escaping
+          class EscapedString < String #:nodoc:
+            def to_json(*)
+              if Encoding.escape_html_entities_in_json
+                super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
+              else
+                super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
+              end
+            end
 
-        def options_for(value)
-          if value.is_a?(Array) || value.is_a?(Hash)
-            # hashes and arrays need to get encoder in the options, so that
-            # they can detect circular references.
-            options.merge(:encoder => self)
-          else
-            options.dup
+            def to_s
+              self
+            end
           end
-        end
 
-        def escape(string)
-          Encoding.escape(string)
-        end
-
-        private
-          def check_for_circular_references(value)
-            unless @seen.add?(value.__id__)
-              raise CircularReferenceError, 'object references itself'
+          # Mark these as private so we don't leak encoding-specific constructs
+          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES,
+            :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.
+          # Recursively calls #as_json to the object to recursively build a
+          # fully JSON-ready object.
+          #
+          # This allows developers to implement #as_json without having to
+          # worry about what base types of objects they are allowed to return
+          # or having to remember to call #as_json recursively.
+          #
+          # Note: the +options+ hash passed to +object.to_json+ is only passed
+          # to +object.as_json+, not any of this method's recursive +#as_json+
+          # calls.
+          def jsonify(value)
+            case value
+            when String
+              EscapedString.new(value)
+            when Numeric, NilClass, TrueClass, FalseClass
+              value
+            when Hash
+              Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
+            when Array
+              value.map { |v| jsonify(v) }
+            else
+              jsonify value.as_json
             end
-            yield
-          ensure
-            @seen.delete(value.__id__)
           end
-      end
 
-
-      ESCAPED_CHARS = {
-        "\x00" => '\u0000', "\x01" => '\u0001', "\x02" => '\u0002',
-        "\x03" => '\u0003', "\x04" => '\u0004', "\x05" => '\u0005',
-        "\x06" => '\u0006', "\x07" => '\u0007', "\x0B" => '\u000B',
-        "\x0E" => '\u000E', "\x0F" => '\u000F', "\x10" => '\u0010',
-        "\x11" => '\u0011', "\x12" => '\u0012', "\x13" => '\u0013',
-        "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016',
-        "\x17" => '\u0017', "\x18" => '\u0018', "\x19" => '\u0019',
-        "\x1A" => '\u001A', "\x1B" => '\u001B', "\x1C" => '\u001C',
-        "\x1D" => '\u001D', "\x1E" => '\u001E', "\x1F" => '\u001F',
-        "\010" =>  '\b',
-        "\f"   =>  '\f',
-        "\n"   =>  '\n',
-        "\r"   =>  '\r',
-        "\t"   =>  '\t',
-        '"'    =>  '\"',
-        '\\'   =>  '\\\\',
-        '>'    =>  '\u003E',
-        '<'    =>  '\u003C',
-        '&'    =>  '\u0026' }
+          # Encode a "jsonified" Ruby data structure using the JSON gem
+          def stringify(jsonified)
+            ::JSON.generate(jsonified, quirks_mode: true, max_nesting: false)
+          end
+      end
 
       class << self
         # If true, use ISO 8601 format for dates and times. Otherwise, fall back
         # to the Active Support legacy format.
         attr_accessor :use_standard_json_time_format
 
-        # If false, serializes BigDecimal objects as numeric instead of wrapping
-        # them in a string.
-        attr_accessor :encode_big_decimal_as_string
+        # If true, encode >, <, & as escaped unicode sequences (e.g. > as \u003e)
+        # as a safety measure.
+        attr_accessor :escape_html_entities_in_json
 
-        attr_accessor :escape_regex
-        attr_reader :escape_html_entities_in_json
+        # Sets the precision of encoded time values.
+        # Defaults to 3 (equivalent to millisecond precision)
+        attr_accessor :time_precision
 
-        def escape_html_entities_in_json=(value)
-          self.escape_regex = \
-            if @escape_html_entities_in_json = value
-              /[\x00-\x1F"\\><&]/
-            else
-              /[\x00-\x1F"\\]/
-            end
-        end
+        # 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 escape(string)
-          string = string.encode(::Encoding::UTF_8, :undef => :replace).force_encoding(::Encoding::BINARY)
-          json = string.gsub(escape_regex) { |s| ESCAPED_CHARS[s] }
-          json = %("#{json}")
-          json.force_encoding(::Encoding::UTF_8)
-          json
-        end
-      end
+        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."
 
-      self.use_standard_json_time_format = true
-      self.escape_html_entities_in_json  = true
-      self.encode_big_decimal_as_string  = true
-    end
-  end
-end
-
-class Object
-  def as_json(options = nil) #:nodoc:
-    if respond_to?(:to_hash)
-      to_hash
-    else
-      instance_values
-    end
-  end
-end
-
-class Struct #:nodoc:
-  def as_json(options = nil)
-    Hash[members.zip(values)]
-  end
-end
-
-class TrueClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-
-  def encode_json(encoder) #:nodoc:
-    to_s
-  end
-end
-
-class FalseClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-
-  def encode_json(encoder) #:nodoc:
-    to_s
-  end
-end
-
-class NilClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-
-  def encode_json(encoder) #:nodoc:
-    'null'
-  end
-end
-
-class String
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-
-  def encode_json(encoder) #:nodoc:
-    encoder.escape(self)
-  end
-end
-
-class Symbol
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Numeric
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-
-  def encode_json(encoder) #:nodoc:
-    to_s
-  end
-end
-
-class Float
-  # Encoding Infinity or NaN to JSON should return "null". The default returns
-  # "Infinity" or "NaN" which breaks parsing the JSON. E.g. JSON.parse('[NaN]').
-  def as_json(options = nil) #:nodoc:
-    finite? ? self : nil
-  end
-end
-
-class BigDecimal
-  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
-  # however, parse non-integer JSON numbers directly as floats. Clients using
-  # those libraries would get in general a wrong number and no way to recover
-  # other than manually inspecting the string with the JSON code itself.
-  #
-  # That's why a JSON string is returned. The JSON literal is not numeric, but
-  # if the other end knows by contract that the data is supposed to be a
-  # BigDecimal, it still has the chance to post-process the string and get the
-  # real value.
-  #
-  # Use <tt>ActiveSupport.encode_big_decimal_as_string = true</tt> to
-  # override this behavior.
-  def as_json(options = nil) #:nodoc:
-    if finite?
-      ActiveSupport.encode_big_decimal_as_string ? to_s : self
-    else
-      nil
-    end
-  end
-end
-
-class Regexp
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-module Enumerable
-  def as_json(options = nil) #:nodoc:
-    to_a.as_json(options)
-  end
-end
+          raise NotImplementedError, message
+        end
 
-class Range
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-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."
 
-class Array
-  def as_json(options = nil) #:nodoc:
-    # use encoder as a proxy to call as_json on all elements, to protect from circular references
-    encoder = options && options[:encoder] || ActiveSupport::JSON::Encoding::Encoder.new(options)
-    map { |v| encoder.as_json(v, options) }
-  end
+          ActiveSupport::Deprecation.warn message
 
-  def encode_json(encoder) #:nodoc:
-    # we assume here that the encoder has already run as_json on self and the elements, so we run encode_json directly
-    "[#{map { |v| v.encode_json(encoder) } * ','}]"
-  end
-end
+          true
+        end
 
-class Hash
-  def as_json(options = nil) #:nodoc:
-    # create a subset of the hash by applying :only or :except
-    subset = if options
-      if attrs = options[:only]
-        slice(*Array(attrs))
-      elsif attrs = options[:except]
-        except(*Array(attrs))
-      else
-        self
+        # 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
-    else
-      self
-    end
-
-    # use encoder as a proxy to call as_json on all values in the subset, to protect from circular references
-    encoder = options && options[:encoder] || ActiveSupport::JSON::Encoding::Encoder.new(options)
-    Hash[subset.map { |k, v| [k.to_s, encoder.as_json(v, options)] }]
-  end
-
-  def encode_json(encoder) #:nodoc:
-    # values are encoded with use_options = false, because we don't want hash representations from ActiveModel to be
-    # processed once again with as_json with options, as this could cause unexpected results (i.e. missing fields);
-
-    # on the other hand, we need to run as_json on the elements, because the model representation may contain fields
-    # like Time/Date in their original (not jsonified) form, etc.
 
-    "{#{map { |k,v| "#{encoder.encode(k.to_s)}:#{encoder.encode(v, false)}" } * ','}}"
-  end
-end
-
-class Time
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport.use_standard_json_time_format
-      xmlschema
-    else
-      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
-    end
-  end
-end
-
-class Date
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport.use_standard_json_time_format
-      strftime("%Y-%m-%d")
-    else
-      strftime("%Y/%m/%d")
-    end
-  end
-end
-
-class DateTime
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport.use_standard_json_time_format
-      xmlschema
-    else
-      strftime('%Y/%m/%d %H:%M:%S %z')
+      self.use_standard_json_time_format = true
+      self.escape_html_entities_in_json  = true
+      self.json_encoder = JSONGemEncoder
+      self.time_precision = 3
     end
   end
 end

data/lib/active_support/key_generator.rb

@@ -4,7 +4,7 @@ require 'openssl'
 module ActiveSupport
   # 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
+  # This lets Rails applications have a single secure secret, but avoid reusing that
   # key in multiple incompatible contexts.
   class KeyGenerator
     def initialize(secret, options = {})
@@ -57,18 +57,16 @@ module ActiveSupport
     # 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. Use " +
-          "config.secret_key_base = \"some secret phrase of at " +
-          "least #{SECRET_MIN_LENGTH} characters\"" +
-          "in config/initializers/secret_token.rb"
+        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"
+        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

data/lib/active_support/lazy_load_hooks.rb

@@ -1,5 +1,5 @@
 module ActiveSupport
-  # lazy_load_hooks allows rails to lazily load a lot of components and thus
+  # 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
   # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
   # configuration. Instead a hook is registered that applies configuration once

data/lib/active_support/log_subscriber/test_helper.rb

@@ -1,5 +1,5 @@
 require 'active_support/log_subscriber'
-require 'active_support/buffered_logger'
+require 'active_support/logger'
 require 'active_support/notifications'
 
 module ActiveSupport

data/lib/active_support/logger.rb

@@ -1,11 +1,24 @@
-require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/attribute_accessors'
 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
+    #
+    #   logger = Logger.new(STDOUT)
+    #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
+    #   # => true
+    def self.logger_outputs_to?(logger, *sources)
+      logdev = logger.instance_variable_get("@logdev")
+      logger_source = logdev.dev if logdev.respond_to?(:dev)
+      sources.any? { |source| source == logger_source }
+    end
+
     # Broadcasts logs to multiple loggers.
     def self.broadcast(logger) # :nodoc:
       Module.new do
@@ -38,12 +51,49 @@ module ActiveSupport
           logger.level = level
           super(level)
         end
+
+        define_method(:local_level=) do |level|
+          logger.local_level = level if logger.respond_to?(:local_level=)
+          super(level) if respond_to?(:local_level=)
+        end
+
+        define_method(:silence) do |level = Logger::ERROR, &block|
+          if logger.respond_to?(:silence) && logger.method(:silence).owner != ::Kernel
+            logger.silence(level) do
+              if respond_to?(:silence) && method(:silence).owner != ::Kernel
+                super(level, &block)
+              else
+                block.call(self)
+              end
+            end
+          else
+            if respond_to?(:silence) && method(:silence).owner != ::Kernel
+              super(level, &block)
+            else
+              block.call(self)
+            end
+          end
+        end
       end
     end
 
     def initialize(*args)
       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,8 +1,9 @@
 require 'active_support/concern'
+require 'thread_safe'
 
 module LoggerSilence
   extend ActiveSupport::Concern
-  
+
   included do
     cattr_accessor :silencer
     self.silencer = true
@@ -12,13 +13,15 @@ module LoggerSilence
   def silence(temporary_level = Logger::ERROR)
     if silencer
       begin
-        old_logger_level, self.level = level, temporary_level
+        old_local_level            = local_level
+        self.local_level           = temporary_level
+
         yield self
       ensure
-        self.level = old_logger_level
+        self.local_level = old_local_level
       end
     else
       yield self
     end
   end
-end
+end

data/lib/active_support/logger_thread_safe_level.rb

@@ -0,0 +1,32 @@
+require 'active_support/concern'
+require 'thread_safe'
+
+module ActiveSupport
+  module LoggerThreadSafeLevel
+    extend ActiveSupport::Concern
+
+    def after_initialize
+      @local_levels = ThreadSafe::Cache.new
+    end
+
+    def local_log_id
+      Thread.current.__id__
+    end
+
+    def local_level
+      @local_levels[local_log_id]
+    end
+
+    def local_level=(level)
+      if level
+        @local_levels[local_log_id] = level
+      else
+        @local_levels.delete(local_log_id)
+      end
+    end
+
+    def level
+      local_level || super
+    end
+  end
+end