activesupport 3.2.22.5 → 4.0.0.beta1

data/lib/active_support/inflector/transliterate.rb

@@ -8,7 +8,7 @@ module ActiveSupport
     # Replaces non-ASCII characters with an ASCII approximation, or if none
     # exists, a replacement character which defaults to "?".
     #
-    #    transliterate("Ærøskøbing")
+    #    transliterate('Ærøskøbing')
     #    # => "AEroskobing"
     #
     # Default approximations are provided for Western/Latin characters,
@@ -30,33 +30,33 @@ module ActiveSupport
     #         ö: "oe"
     #
     #   # Or set them using Ruby
-    #   I18n.backend.store_translations(:de, :i18n => {
-    #     :transliterate => {
-    #       :rule => {
-    #         "ü" => "ue",
-    #         "ö" => "oe"
+    #   I18n.backend.store_translations(:de, i18n: {
+    #     transliterate: {
+    #       rule: {
+    #         'ü' => 'ue',
+    #         'ö' => 'oe'
     #       }
     #     }
     #   })
     #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that maps
-    # characters to ASCII approximations as shown above, or, for more complex
-    # requirements, a Proc:
+    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
+    # maps characters to ASCII approximations as shown above, or, for more
+    # complex requirements, a Proc:
     #
-    #   I18n.backend.store_translations(:de, :i18n => {
-    #     :transliterate => {
-    #       :rule => lambda {|string| MyTransliterator.transliterate(string)}
+    #   I18n.backend.store_translations(:de, i18n: {
+    #     transliterate: {
+    #       rule: ->(string) { MyTransliterator.transliterate(string) }
     #     }
     #   })
     #
     # Now you can have different transliterations for each locale:
     #
     #   I18n.locale = :en
-    #   transliterate("Jürgen")
+    #   transliterate('Jürgen')
     #   # => "Jurgen"
     #
     #   I18n.locale = :de
-    #   transliterate("Jürgen")
+    #   transliterate('Jürgen')
     #   # => "Juergen"
     def transliterate(string, replacement = "?")
       I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
@@ -64,9 +64,8 @@ module ActiveSupport
           :replacement => replacement)
     end
 
-    # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
-    #
-    # ==== Examples
+    # Replaces special characters in a string so that it may be used as part of
+    # a 'pretty' URL.
     #
     #   class Person
     #     def to_param

data/lib/active_support/json/decoding.rb

@@ -8,14 +8,13 @@ module ActiveSupport
 
   module JSON
     class << self
+      # Parses a JSON string (JavaScript Object Notation) into a hash.
+      # See www.json.org for more info.
+      #
+      #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
+      #   => {"team" => "rails", "players" => "36"}
       def decode(json, options ={})
-        # Can't reliably detect whether MultiJson responds to load, since it's
-        # a reserved word. Use adapter as a proxy for new features.
-        data = if MultiJson.respond_to?(:adapter)
-          MultiJson.load(json, options)
-        else
-          MultiJson.decode(json, options)
-        end
+        data = MultiJson.load(json, options)
         if ActiveSupport.parse_json_times
           convert_dates_from(data)
         else
@@ -24,20 +23,12 @@ module ActiveSupport
       end
 
       def engine
-        if MultiJson.respond_to?(:adapter)
-          MultiJson.adapter
-        else
-          MultiJson.engine
-        end
+        MultiJson.adapter
       end
       alias :backend :engine
 
       def engine=(name)
-        if MultiJson.respond_to?(:use)
-          MultiJson.use name
-        else
-          MultiJson.engine = name
-        end
+        MultiJson.use(name)
       end
       alias :backend= :engine=
 
@@ -48,6 +39,16 @@ module ActiveSupport
         self.backend = old_backend
       end
 
+      # Returns the class of the error that will be raised when there is an
+      # error in decoding JSON. Using this method means you won't directly
+      # depend on the ActiveSupport's JSON implementation, in case it changes
+      # in the future.
+      #
+      #   begin
+      #     obj = ActiveSupport::JSON.decode(some_string)
+      #   rescue ActiveSupport::JSON.parse_error
+      #     Rails.logger.warn("Attempted to decode invalid JSON: #{some_string}")
+      #   end
       def parse_error
         MultiJson::DecodeError
       end

data/lib/active_support/json/encoding.rb

@@ -1,11 +1,9 @@
 require 'active_support/core_ext/object/to_json'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/json/variable'
-require 'active_support/ordered_hash'
 
 require 'bigdecimal'
 require 'active_support/core_ext/big_decimal/conversions' # for #to_s
-require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/object/instance_variables'
@@ -19,6 +17,7 @@ module ActiveSupport
   class << self
     delegate :use_standard_json_time_format, :use_standard_json_time_format=,
       :escape_html_entities_in_json, :escape_html_entities_in_json=,
+      :encode_big_decimal_as_string, :encode_big_decimal_as_string=,
       :to => :'ActiveSupport::JSON::Encoding'
   end
 
@@ -26,7 +25,11 @@ module ActiveSupport
     # 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 object in JSON (JavaScript Object Notation). See www.json.org for more info.
+    # Dumps objects in JSON (JavaScript Object Notation).
+    # See 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)
     end
@@ -49,7 +52,7 @@ module ActiveSupport
           end
         end
 
-        # like encode, but only calls as_json, without encoding to string
+        # 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
@@ -58,7 +61,8 @@ module ActiveSupport
 
         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
+            # hashes and arrays need to get encoder in the options, so that
+            # they can detect circular references.
             options.merge(:encoder => self)
           else
             options.dup
@@ -103,9 +107,14 @@ module ActiveSupport
         '&'    =>  '\u0026' }
 
       class << self
-        # If true, use ISO 8601 format for dates and times. Otherwise, fall back to the Active Support legacy format.
+        # 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
+
         attr_accessor :escape_regex
         attr_reader :escape_html_entities_in_json
 
@@ -119,24 +128,17 @@ module ActiveSupport
         end
 
         def escape(string)
-          if string.respond_to?(:force_encoding)
-            string = string.encode(::Encoding::UTF_8, :undef => :replace).force_encoding(::Encoding::BINARY)
-          end
-          json = string.
-            gsub(escape_regex) { |s| ESCAPED_CHARS[s] }.
-            gsub(/([\xC0-\xDF][\x80-\xBF]|
-                   [\xE0-\xEF][\x80-\xBF]{2}|
-                   [\xF0-\xF7][\x80-\xBF]{3})+/nx) { |s|
-            s.unpack("U*").pack("n*").unpack("H*")[0].gsub(/.{4}/n, '\\\\u\&')
-          }
+          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) if json.respond_to?(:force_encoding)
+          json.force_encoding(::Encoding::UTF_8)
           json
         end
       end
 
       self.use_standard_json_time_format = true
-      self.escape_html_entities_in_json  = false
+      self.escape_html_entities_in_json  = true
+      self.encode_big_decimal_as_string  = true
     end
   end
 end
@@ -158,32 +160,67 @@ class Struct #:nodoc:
 end
 
 class TrueClass
-  def as_json(options = nil) self end #:nodoc:
-  def encode_json(encoder) to_s end #:nodoc:
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+
+  def encode_json(encoder) #:nodoc:
+    to_s
+  end
 end
 
 class FalseClass
-  def as_json(options = nil) self end #:nodoc:
-  def encode_json(encoder) to_s end #:nodoc:
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+
+  def encode_json(encoder) #:nodoc:
+    to_s
+  end
 end
 
 class NilClass
-  def as_json(options = nil) self end #:nodoc:
-  def encode_json(encoder) 'null' end #:nodoc:
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+
+  def encode_json(encoder) #:nodoc:
+    'null'
+  end
 end
 
 class String
-  def as_json(options = nil) self end #:nodoc:
-  def encode_json(encoder) encoder.escape(self) end #:nodoc:
+  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) to_s end #:nodoc:
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
 end
 
 class Numeric
-  def as_json(options = nil) self end #:nodoc:
-  def encode_json(encoder) to_s end #:nodoc:
+  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
@@ -192,14 +229,26 @@ class BigDecimal
   # 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.
-  def as_json(options = nil) to_s end #:nodoc:
+  # 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.use_standard_json_big_decimal_format = 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) to_s end #:nodoc:
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
 end
 
 module Enumerable
@@ -208,6 +257,12 @@ module Enumerable
   end
 end
 
+class Range
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
 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
@@ -226,9 +281,9 @@ class Hash
     # create a subset of the hash by applying :only or :except
     subset = if options
       if attrs = options[:only]
-        slice(*Array.wrap(attrs))
+        slice(*Array(attrs))
       elsif attrs = options[:except]
-        except(*Array.wrap(attrs))
+        except(*Array(attrs))
       else
         self
       end
@@ -238,11 +293,10 @@ class Hash
 
     # 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)
-    result = self.is_a?(ActiveSupport::OrderedHash) ? ActiveSupport::OrderedHash : Hash
-    result[subset.map { |k, v| [k.to_s, encoder.as_json(v, options)] }]
+    Hash[subset.map { |k, v| [k.to_s, encoder.as_json(v, options)] }]
   end
 
-  def encode_json(encoder)
+  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);
 

data/lib/active_support/json/variable.rb

@@ -1,7 +1,16 @@
+require 'active_support/deprecation'
+
 module ActiveSupport
   module JSON
-    # A string that returns itself as its JSON-encoded form.
+    # Deprecated: A string that returns itself as its JSON-encoded form.
     class Variable < String
+      def initialize(*args)
+        message = 'ActiveSupport::JSON::Variable is deprecated and will be removed in Rails 4.1. ' \
+                  'For your own custom JSON literals, define #as_json and #encode_json yourself.'
+        ActiveSupport::Deprecation.warn message
+        super
+      end
+
       def as_json(options = nil) self end #:nodoc:
       def encode_json(encoder) self end #:nodoc:
     end

data/lib/active_support/key_generator.rb

@@ -0,0 +1,75 @@
+require 'thread_safe'
+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
+  # key in multiple incompatible contexts.
+  class KeyGenerator
+    def initialize(secret, options = {})
+      @secret = secret
+      # The default iterations are higher than required for our key derivation uses
+      # on the off chance someone uses this for password storage
+      @iterations = options[:iterations] || 2**16
+    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)
+      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
+  class CachingKeyGenerator
+    def initialize(key_generator)
+      @key_generator = key_generator
+      @cache_keys = ThreadSafe::Cache.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)
+    end
+  end
+
+  class DummyKeyGenerator # :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. Use " +
+          "config.secret_key_base = \"some secret phrase of at " +
+          "least #{SECRET_MIN_LENGTH} characters\"" +
+          "in config/initializers/secret_token.rb"
+      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