activesupport 3.2.14.rc2 → 3.2.14

data/CHANGELOG.md

@@ -1,9 +1,4 @@
-## Rails 3.2.14.rc2 (Jun 16, 2013) ##
-
-*   No changes.
-
-
-## Rails 3.2.14.rc1 (Jul 12, 2013) ##
+## Rails 3.2.14 (Jul 22, 2013) ##
 
 *   Make `Time.at_with_coercion` retain the second fraction and return local time.
 

data/lib/active_support/version.rb

@@ -3,7 +3,7 @@ module ActiveSupport
     MAJOR = 3
     MINOR = 2
     TINY  = 14
-    PRE   = "rc2"
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

metadata

@@ -1,15 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activesupport
 version: !ruby/object:Gem::Version 
-  hash: -648436064
-  prerelease: 7
+  hash: 19
+  prerelease: 
   segments: 
   - 3
   - 2
   - 14
-  - rc
-  - 2
-  version: 3.2.14.rc2
+  version: 3.2.14
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -17,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-07-16 00:00:00 -03:00
+date: 2013-07-22 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -217,7 +215,6 @@ files:
 - lib/active_support/file_watcher.rb
 - lib/active_support/gzip.rb
 - lib/active_support/hash_with_indifferent_access.rb
-- lib/active_support/hash_with_indifferent_access.rb.orig
 - lib/active_support/i18n.rb
 - lib/active_support/i18n_railtie.rb
 - lib/active_support/inflections.rb
@@ -227,7 +224,6 @@ files:
 - lib/active_support/inflector.rb
 - lib/active_support/json/decoding.rb
 - lib/active_support/json/encoding.rb
-- lib/active_support/json/encoding.rb.orig
 - lib/active_support/json/variable.rb
 - lib/active_support/json.rb
 - lib/active_support/lazy_load_hooks.rb
@@ -306,14 +302,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      hash: 25
+      hash: 3
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 

data/lib/active_support/hash_with_indifferent_access.rb.orig

@@ -1,272 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-
-module ActiveSupport
-  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
-  # to be the same.
-  #
-  #   rgb = ActiveSupport::HashWithIndifferentAccess.new
-  #
-  #   rgb[:black] = '#000000'
-  #   rgb[:black]  # => '#000000'
-  #   rgb['black'] # => '#000000'
-  #
-  #   rgb['white'] = '#FFFFFF'
-  #   rgb[:white]  # => '#FFFFFF'
-  #   rgb['white'] # => '#FFFFFF'
-  #
-  # Internally symbols are mapped to strings when used as keys in the entire
-  # writing interface (calling <tt>[]=</tt>, <tt>merge</tt>, etc). This
-  # mapping belongs to the public interface. For example, given:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
-  #
-  # You are guaranteed that the key is returned as a string:
-  #
-  #   hash.keys # => ["a"]
-  #
-  # Technically other types of keys are accepted:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
-  #   hash[0] = 0
-  #   hash # => {"a"=>1, 0=>0}
-  #
-  # but this class is intended for use cases where strings or symbols are the
-  # expected keys and it is convenient to understand both as the same. For
-  # example the +params+ hash in Ruby on Rails.
-  #
-  # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
-  #
-  #   rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access
-  #
-  # which may be handy.
-  class HashWithIndifferentAccess < Hash
-    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
-    # this class.
-    def extractable_options?
-      true
-    end
-
-    def with_indifferent_access
-      dup
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super()
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def default(key = nil)
-      if key.is_a?(Symbol) && include?(key = key.to_s)
-        self[key]
-      else
-        super
-      end
-    end
-
-    def self.new_from_hash_copying_default(hash)
-      new(hash).tap do |new_hash|
-        new_hash.default = hash.default
-      end
-    end
-
-    def self.[](*args)
-      new.merge!(Hash[*args])
-    end
-
-    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-    alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-    # Assigns a new value to the hash:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash[:key] = 'value'
-    #
-    # This value can be later fetched using either +:key+ or +'key'+.
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value, for: :assignment))
-    end
-
-    alias_method :store, :[]=
-
-    # Updates the receiver in-place, merging in the hash passed as argument:
-    #
-    #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash_1[:key] = 'value'
-    #
-    #   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash_2[:key] = 'New Value!'
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    # The argument can be either an
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
-    # In either case the merge respects the semantics of indifferent access.
-    #
-    # If the argument is a regular hash with keys +:key+ and +"key"+ only one
-    # of the values end up in the receiver, but which one is unspecified.
-    #
-    # When given a block, the value for duplicated keys will be determined
-    # by the result of invoking the block with the duplicated key, the value
-    # in the receiver, and the value in +other_hash+. The rules for duplicated
-    # keys follow the semantics of indifferent access:
-    #
-    #   hash_1[:key] = 10
-    #   hash_2['key'] = 12
-    #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-    def update(other_hash)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
-      else
-        other_hash.each_pair do |key, value|
-          if block_given? && key?(key)
-            value = yield(convert_key(key), self[key], value)
-          end
-          regular_writer(convert_key(key), convert_value(value))
-        end
-        self
-      end
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash['key'] = 'value'
-    #   hash.key?(:key)  # => true
-    #   hash.key?('key') # => true
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    alias_method :include?, :key?
-    alias_method :has_key?, :key?
-    alias_method :member?, :key?
-
-    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = ActiveSupport::HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters.fetch('foo')          # => 1
-    #   counters.fetch(:bar, 0)        # => 0
-    #   counters.fetch(:bar) {|key| 0} # => 0
-    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash[:a] = 'x'
-    #   hash[:b] = 'y'
-    #   hash.values_at('a', 'b') # => ["x", "y"]
-    def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
-    end
-
-    # Returns an exact copy of the hash.
-    def dup
-      self.class.new(self).tap do |new_hash|
-        new_hash.default = default
-      end
-    end
-
-    # This method has the same semantics of +update+, except it does not
-    # modify the receiver but rather returns a new hash with indifferent
-    # access with the result of the merge.
-    def merge(hash, &block)
-      self.dup.update(hash, &block)
-    end
-
-    # Like +merge+ but the other way around: Merges the receiver into the
-    # argument and returns a new hash with indifferent access as result:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash['a'] = nil
-    #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
-    def reverse_merge(other_hash)
-      super(self.class.new_from_hash_copying_default(other_hash))
-    end
-
-    # Same semantics as +reverse_merge+ but modifies the receiver in-place.
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Replaces the contents of this hash with other_hash.
-    #
-    #   h = { "a" => 100, "b" => 200 }
-    #   h.replace({ "c" => 300, "d" => 400 }) #=> {"c"=>300, "d"=>400}
-    def replace(other_hash)
-      super(self.class.new_from_hash_copying_default(other_hash))
-    end
-
-    # Removes the specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def deep_stringify_keys!; self end
-    def stringify_keys; dup end
-    def deep_stringify_keys; dup end
-    undef :symbolize_keys!
-    undef :deep_symbolize_keys!
-    def symbolize_keys; to_hash.symbolize_keys! end
-    def deep_symbolize_keys; to_hash.deep_symbolize_keys end
-    def to_options!; self end
-
-    # Convert to a regular hash with string keys.
-    def to_hash
-      _new_hash= {}
-      each do |key, value|
-<<<<<<< HEAD
-        _new_hash[convert_key(key)] = convert_value(value,true)
-=======
-        _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
->>>>>>> 424fa92... Merge pull request #10784 from senny/10526_prevent_key_transformation
-      end
-      Hash.new(default).merge!(_new_hash)
-    end
-
-    protected
-      def convert_key(key)
-        key.kind_of?(Symbol) ? key.to_s : key
-      end
-
-      def convert_value(value, options = {})
-        if value.is_a? Hash
-          if options[:for] == :to_hash
-            value.to_hash
-          else
-            value.nested_under_indifferent_access
-          end
-        elsif value.is_a?(Array)
-<<<<<<< HEAD
-          value = value.dup if value.frozen?
-          value.map! { |e| convert_value(e) }
-=======
-          unless options[:for] == :assignment
-            value = value.dup
-          end
-          value.map! { |e| convert_value(e, options) }
->>>>>>> 424fa92... Merge pull request #10784 from senny/10526_prevent_key_transformation
-        else
-          value
-        end
-      end
-  end
-end
-
-HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

data/lib/active_support/json/encoding.rb.orig

@@ -1,351 +0,0 @@
-#encoding: us-ascii
-
-require 'active_support/core_ext/object/to_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'
-
-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
-
-  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.
-    #
-    #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
-    #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-    def self.encode(value, options = nil)
-      Encoding::Encoder.new(options).encode(value)
-    end
-
-    module Encoding #:nodoc:
-      class CircularReferenceError < StandardError; end
-
-      class Encoder
-        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
-        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
-
-        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
-          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'
-            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',
-        "\xe2\x80\xa8" => '\u2028',
-        "\xe2\x80\xa9" => '\u2029',
-        "\r"   =>  '\r',
-        "\t"   =>  '\t',
-        '"'    =>  '\"',
-        '\\'   =>  '\\\\',
-        '>'    =>  '\u003E',
-        '<'    =>  '\u003C',
-        '&'    =>  '\u0026',
-        "#{0xe2.chr}#{0x80.chr}#{0xa8.chr}" => '\u2028',
-        "#{0xe2.chr}#{0x80.chr}#{0xa9.chr}" => '\u2029',
-        }
-
-      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
-
-        attr_accessor :escape_regex
-        attr_reader :escape_html_entities_in_json
-
-        def escape_html_entities_in_json=(value)
-          self.escape_regex = \
-            if @escape_html_entities_in_json = value
-<<<<<<< HEAD
-              /\xe2\x80\xa8|\xe2\x80\xa9|[\x00-\x1F"\\><&]/
-            else
-              /\xe2\x80\xa8|\xe2\x80\xa9|[\x00-\x1F"\\]/
-=======
-              /[\x00-\x1F"\\><&]|#{0xe2.chr}#{0x80.chr}#{0xa8.chr}|#{0xe2.chr}#{0x80.chr}#{0xa9.chr}/
-            else
-              /[\x00-\x1F"\\]|#{0xe2.chr}#{0x80.chr}#{0xa8.chr}|#{0xe2.chr}#{0x80.chr}#{0xa9.chr}/
->>>>>>> cmaruz/master
-            end
-        end
-
-        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
-
-      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.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) #:nodoc:
-    to_s
-  end
-end
-
-module Enumerable
-  def as_json(options = nil) #:nodoc:
-    to_a.as_json(options)
-  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
-    encoder = options && options[:encoder] || ActiveSupport::JSON::Encoding::Encoder.new(options)
-    map { |v| encoder.as_json(v, options) }
-  end
-
-  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
-
-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
-      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')
-    end
-  end
-end