activesupport 3.2.13 → 3.2.14.rc1

data/CHANGELOG.md

@@ -1,9 +1,34 @@
-## unreleased ##
+## Rails 3.2.14.rc1 (Jul 8, 2013) ##
 
-*   No changes.
+*   Make `Time.at_with_coercion` retain the second fraction and return local time.
+
+    Fixes #11350
+
+    *Neer Friedman*, *Andrew White*
+
+*   Fix `ActiveSupport::TaggedLogging` incorrectly providing program name the same as log message
+    even when block is not provided.
+
+    *Carson Reinke*
+
+*   Override `Time.at` to support the passing of Time-like values when called with a single argument.
+
+    *Andrew White*
+
+*   Revert the changes on unicode character encoding from `ActiveSupport::JSON.encode`.
+    This was causing a regression where the resulting string is always returning UTF-8.
+    Also it changes the behavior of this method on a stable release.
+    Fixes #9498.
+
+    *Rafael Mendonça França*
+
+*   Fix `ActiveSupport::TimeZone.parse` when time is at a local DST jump.
+    Fixes #9678.
+
+    *Andrew White*
 
 
-## Rails 3.2.13 (Feb 17, 2013) ##
+## Rails 3.2.13 (Mar 18, 2013) ##
 
 
 *   Fix DateTime comparison with DateTime::Infinity object.

data/lib/active_support/core_ext/class/attribute.rb

@@ -67,7 +67,7 @@ class Class
   #   object.setting = false  # => NoMethodError
   def class_attribute(*attrs)
     options = attrs.extract_options!
-    instance_reader = options.fetch(:instance_reader, true)
+    instance_reader = instance_reader = options.fetch(:instance_reader, true)
     instance_writer = options.fetch(:instance_writer, true)
 
     attrs.each do |name|

data/lib/active_support/core_ext/date_time/acts_like.rb

@@ -1,3 +1,4 @@
+require 'date'
 require 'active_support/core_ext/object/acts_like'
 
 class DateTime

data/lib/active_support/core_ext/time/calculations.rb

@@ -45,6 +45,23 @@ class Time
     def current
       ::Time.zone ? ::Time.zone.now : ::Time.now
     end
+
+    # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
+    # instances can be used when called with a single argument
+    def at_with_coercion(*args)
+      return at_without_coercion(*args) if args.size != 1
+
+      # Time.at can be called with a time or numerical value
+      time_or_number = args.first
+
+      if time_or_number.is_a?(ActiveSupport::TimeWithZone) || time_or_number.is_a?(DateTime)
+        at_without_coercion(time_or_number.to_f).getlocal
+      else
+        at_without_coercion(time_or_number)
+      end
+    end
+    alias_method :at_without_coercion, :at
+    alias_method :at, :at_with_coercion
   end
 
   # Tells whether the Time object's time lies in the past

data/lib/active_support/hash_with_indifferent_access.rb.orig

@@ -0,0 +1,272 @@
+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

@@ -122,7 +122,13 @@ module ActiveSupport
           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] }
+          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\&')
+          }
           json = %("#{json}")
           json.force_encoding(::Encoding::UTF_8) if json.respond_to?(:force_encoding)
           json

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

@@ -0,0 +1,351 @@
+#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

data/lib/active_support/tagged_logging.rb

@@ -44,7 +44,14 @@ module ActiveSupport
     deprecate :silence
 
     def add(severity, message = nil, progname = nil, &block)
-      message = (block_given? ? block.call : progname) if message.nil?
+      if message.nil?
+        if block_given?
+          message = block.call
+        else
+          message = progname
+          progname = nil #No instance variable for this like Logger
+        end
+      end
       @logger.add(severity, "#{tags_text}#{message}", progname)
     end
 

data/lib/active_support/testing/performance.rb

@@ -23,7 +23,7 @@ module ActiveSupport
 
       # each implementation should define metrics and freeze the defaults
       DEFAULTS =
-        if ARGV.include?('--benchmark') # HAX for rake test
+        if ENV["BENCHMARK_TESTS"]
           { :runs => 4,
             :output => 'tmp/performance',
             :benchmark => true }

data/lib/active_support/testing/performance/jruby.rb

@@ -6,7 +6,7 @@ module ActiveSupport
   module Testing
     module Performance
       DEFAULTS.merge!(
-        if ARGV.include?('--benchmark')
+        if ENV["BENCHMARK_TESTS"]
           {:metrics => [:wall_time, :user_time, :memory, :gc_runs, :gc_time]}
         else
           { :metrics => [:wall_time],

data/lib/active_support/testing/performance/rubinius.rb

@@ -4,7 +4,7 @@ module ActiveSupport
   module Testing
     module Performance
       DEFAULTS.merge!(
-        if ARGV.include?('--benchmark')
+        if ENV["BENCHMARK_TESTS"]
           {:metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time]}
         else
           { :metrics => [:wall_time],

data/lib/active_support/testing/performance/ruby.rb

@@ -9,7 +9,7 @@ module ActiveSupport
   module Testing
     module Performance
       DEFAULTS.merge!(
-        if ARGV.include?('--benchmark')
+        if ENV["BENCHMARK_TESTS"]
           { :metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time] }
         else
           { :min_percent => 0.01,

data/lib/active_support/values/time_zone.rb

@@ -268,13 +268,23 @@ module ActiveSupport
     #   Time.zone.now                 # => Fri, 31 Dec 1999 14:00:00 HST -10:00
     #   Time.zone.parse('22:30:00')   # => Fri, 31 Dec 1999 22:30:00 HST -10:00
     def parse(str, now=now)
-      date_parts = Date._parse(str)
-      return if date_parts.blank?
-      time = Time.parse(str, now) rescue DateTime.parse(str)
-      if date_parts[:offset].nil?
-        ActiveSupport::TimeWithZone.new(nil, self, time)
+      parts = Date._parse(str, false)
+      return if parts.empty?
+
+      time = Time.utc(
+        parts.fetch(:year, now.year),
+        parts.fetch(:mon, now.month),
+        parts.fetch(:mday, now.day),
+        parts.fetch(:hour, 0),
+        parts.fetch(:min, 0),
+        parts.fetch(:sec, 0),
+        parts.fetch(:sec_fraction, 0) * 1000000
+      )
+
+      if parts[:offset]
+        TimeWithZone.new(time - parts[:offset], self)
       else
-        time.in_time_zone(self)
+        TimeWithZone.new(nil, self, time)
       end
     end
 

data/lib/active_support/version.rb

@@ -2,8 +2,8 @@ module ActiveSupport
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 2
-    TINY  = 13
-    PRE   = nil
+    TINY  = 14
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

metadata

@@ -1,51 +1,72 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: activesupport
-version: !ruby/object:Gem::Version
-  version: 3.2.13
+version: !ruby/object:Gem::Version 
+  hash: 1423556129
+  prerelease: 7
+  segments: 
+  - 3
+  - 2
+  - 14
+  - rc
+  - 1
+  version: 3.2.14.rc1
 platform: ruby
-authors:
+authors: 
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-18 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: i18n
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.6.1
+
+date: 2013-07-12 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        version: "0.6"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 6
+        - 4
+        version: 0.6.4
   type: :runtime
+  name: i18n
+  version_requirements: *id001
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.6.1
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
   type: :runtime
+  name: multi_json
+  version_requirements: *id002
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-description: A toolkit of support libraries and Ruby core extensions extracted from
-  the Rails framework. Rich support for multibyte strings, internationalization, time
-  zones, and testing.
+description: A toolkit of support libraries and Ruby core extensions extracted from the Rails framework. Rich support for multibyte strings, internationalization, time zones, and testing.
 email: david@loudthinking.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - CHANGELOG.md
 - MIT-LICENSE
 - README.rdoc
@@ -196,6 +217,7 @@ 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
@@ -205,6 +227,7 @@ 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
@@ -259,30 +282,44 @@ files:
 - lib/active_support/xml_mini/rexml.rb
 - lib/active_support/xml_mini.rb
 - lib/active_support.rb
+has_rdoc: true
 homepage: http://www.rubyonrails.org
-licenses: []
-metadata: {}
+licenses: 
+- MIT
 post_install_message: 
-rdoc_options:
+rdoc_options: 
 - --encoding
 - UTF-8
-require_paths:
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - '>='
-    - !ruby/object:Gem::Version
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 1.6.2
 signing_key: 
-specification_version: 4
-summary: A toolkit of support libraries and Ruby core extensions extracted from the
-  Rails framework.
+specification_version: 3
+summary: A toolkit of support libraries and Ruby core extensions extracted from the Rails framework.
 test_files: []
+

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: c6d00c3317a3cee1653b4afd2e30f5214cfb9522
-  data.tar.gz: 4224817317c51c2c74e03f8fec3f87cb54a2249c
-SHA512:
-  metadata.gz: 26714413159c1268613e17639f89de58bbc2a7e87b8ac798ec2c343308e2a74eff9852f939ca76e84f1d6e24793c54c1f036fe4b0c2c5aeb72689605d6e711cc
-  data.tar.gz: 74e44db1d704d2c1adbd9032d88ccaaa3ff94c74386eda3966617e67b28c0ab1b5fe9cc1227e779baa8a8a6a9482defff0d7cca0953c9618cda24864cb668c6d