activesupport 4.1.0 → 4.1.11

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

@@ -151,7 +151,9 @@ class DateTime
   # Layers additional behavior on DateTime#<=> so that Time and
   # ActiveSupport::TimeWithZone instances can be compared with a DateTime.
   def <=>(other)
-    if other.respond_to? :to_datetime
+    if other.kind_of?(Infinity)
+      super
+    elsif other.respond_to? :to_datetime
       super other.to_datetime
     else
       nil

data/lib/active_support/core_ext/hash/deep_merge.rb

@@ -1,27 +1,38 @@
 class Hash
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
-  #   h1 = { x: { y: [4, 5, 6] }, z: [7, 8, 9] }
-  #   h2 = { x: { y: [7, 8, 9] }, z: 'xyz' }
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
   #
-  #   h1.deep_merge(h2) # => {x: {y: [7, 8, 9]}, z: "xyz"}
-  #   h2.deep_merge(h1) # => {x: {y: [4, 5, 6]}, z: [7, 8, 9]}
-  #   h1.deep_merge(h2) { |key, old, new| Array.wrap(old) + Array.wrap(new) }
-  #   # => {:x=>{:y=>[4, 5, 6, 7, 8, 9]}, :z=>[7, 8, 9, "xyz"]}
+  #   h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
   def deep_merge(other_hash, &block)
     dup.deep_merge!(other_hash, &block)
   end
 
   # Same as +deep_merge+, but modifies +self+.
   def deep_merge!(other_hash, &block)
-    other_hash.each_pair do |k,v|
-      tv = self[k]
-      if tv.is_a?(Hash) && v.is_a?(Hash)
-        self[k] = tv.deep_merge(v, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
+
+      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        this_value.deep_merge(other_value, &block)
       else
-        self[k] = block && tv ? block.call(k, tv, v) : v
+        if block_given? && key?(current_key)
+          block.call(current_key, this_value, other_value)
+        else
+          other_value
+        end
       end
     end
+
     self
   end
 end

data/lib/active_support/core_ext/hash/keys.rb

@@ -75,34 +75,26 @@ class Hash
 
   # Returns a new hash with all keys converted by the block operation.
   # This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   #
   #  hash = { person: { name: 'Rob', age: '28' } }
   #
   #  hash.deep_transform_keys{ |key| key.to_s.upcase }
   #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
   def deep_transform_keys(&block)
-    result = {}
-    each do |key, value|
-      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
-    end
-    result
+    _deep_transform_keys_in_object(self, &block)
   end
 
   # Destructively convert all keys by using the block operation.
   # This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   def deep_transform_keys!(&block)
-    keys.each do |key|
-      value = delete(key)
-      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
-    end
-    self
+    _deep_transform_keys_in_object!(self, &block)
   end
 
   # Returns a new hash with all keys converted to strings.
   # This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   #
   #   hash = { person: { name: 'Rob', age: '28' } }
   #
@@ -114,14 +106,14 @@ class Hash
 
   # Destructively convert all keys to strings.
   # This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   def deep_stringify_keys!
     deep_transform_keys!{ |key| key.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
   # they respond to +to_sym+. This includes the keys from the root hash
-  # and from all nested hashes.
+  # and from all nested hashes and arrays.
   #
   #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
   #
@@ -133,8 +125,38 @@ class Hash
 
   # Destructively convert all keys to symbols, as long as they respond
   # to +to_sym+. This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   def deep_symbolize_keys!
     deep_transform_keys!{ |key| key.to_sym rescue key }
   end
+
+  private
+    # support methods for deep transforming nested hashes and arrays
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map {|e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+
+    def _deep_transform_keys_in_object!(object, &block)
+      case object
+      when Hash
+        object.keys.each do |key|
+          value = object.delete(key)
+          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+        end
+        object
+      when Array
+        object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+      else
+        object
+      end
+    end
 end

data/lib/active_support/core_ext/object/duplicable.rb

@@ -88,3 +88,13 @@ class BigDecimal
     # can't dup, so use superclass implementation
   end
 end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end

data/lib/active_support/core_ext/object/json.rb

@@ -162,7 +162,7 @@ end
 
 class Time
   def as_json(options = nil) #:nodoc:
-    if ActiveSupport.use_standard_json_time_format
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
       %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
@@ -172,7 +172,7 @@ end
 
 class Date
   def as_json(options = nil) #:nodoc:
-    if ActiveSupport.use_standard_json_time_format
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       strftime("%Y-%m-%d")
     else
       strftime("%Y/%m/%d")
@@ -182,7 +182,7 @@ end
 
 class DateTime
   def as_json(options = nil) #:nodoc:
-    if ActiveSupport.use_standard_json_time_format
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
       strftime('%Y/%m/%d %H:%M:%S %z')

data/lib/active_support/core_ext/object/to_param.rb

@@ -1,62 +1 @@
-class Object
-  # Alias of <tt>to_s</tt>.
-  def to_param
-    to_s
-  end
-end
-
-class NilClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class TrueClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class FalseClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class Array
-  # Calls <tt>to_param</tt> on all its elements and joins the result with
-  # slashes. This is used by <tt>url_for</tt> in Action Pack.
-  def to_param
-    collect { |e| e.to_param }.join '/'
-  end
-end
-
-class Hash
-  # Returns a string representation of the receiver suitable for use as a URL
-  # query string:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_param
-  #   # => "name=David&nationality=Danish"
-  #
-  # An optional namespace can be passed to enclose the param names:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_param('user')
-  #   # => "user[name]=David&user[nationality]=Danish"
-  #
-  # The string pairs "key=value" that conform the query string
-  # are sorted lexicographically in ascending order.
-  #
-  # This method is also aliased as +to_query+.
-  def to_param(namespace = nil)
-    if empty?
-      namespace ? nil.to_query(namespace) : ''
-    else
-      collect do |key, value|
-        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-      end.sort! * '&'
-    end
-  end
-end
+require 'active_support/core_ext/object/to_query'

data/lib/active_support/core_ext/object/to_query.rb

@@ -1,17 +1,45 @@
-require 'active_support/core_ext/object/to_param'
-
 class Object
-  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
-  # param name.
-  #
-  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+
+  # Converts an object into a string suitable for use as a URL query string,
+  # using the given <tt>key</tt> as the param name.
   def to_query(key)
     require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
     "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
   end
 end
 
+class NilClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
 class Array
+  # Calls <tt>to_param</tt> on all its elements and joins the result with
+  # slashes. This is used by <tt>url_for</tt> in Action Pack.
+  def to_param
+    collect { |e| e.to_param }.join '/'
+  end
+
   # Converts an array into a string suitable for use as a URL query string,
   # using the given +key+ as the param name.
   #
@@ -28,5 +56,28 @@ class Array
 end
 
 class Hash
-  alias_method :to_query, :to_param
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_query
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose key names:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_query('user')
+  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+  #
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
+  #
+  # This method is also aliased as +to_param+.
+  def to_query(namespace = nil)
+    collect do |key, value|
+      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end
+    end.compact.sort! * '&'
+  end
+
+  alias_method :to_param, :to_query
 end

data/lib/active_support/core_ext/string/filters.rb

@@ -3,7 +3,7 @@ class String
   # the string, and then changing remaining consecutive whitespace
   # groups into one space each.
   #
-  # Note that it handles both ASCII and Unicode whitespace like mongolian vowel separator (U+180E).
+  # Note that it handles both ASCII and Unicode whitespace.
   #
   #   %{ Multi-line
   #      string }.squish                   # => "Multi-line string"

data/lib/active_support/core_ext/string/output_safety.rb

@@ -6,7 +6,7 @@ class ERB
     HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
     JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003e', '<' => '\u003c', "\u2028" => '\u2028', "\u2029" => '\u2029' }
     HTML_ESCAPE_REGEXP = /[&"'><]/
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
+    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
     JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u
 
     # A utility method for escaping HTML tag characters.
@@ -142,7 +142,11 @@ module ActiveSupport #:nodoc:
       else
         if html_safe?
           new_safe_buffer = super
-          new_safe_buffer.instance_eval { @html_safe = true }
+
+          if new_safe_buffer
+            new_safe_buffer.instance_eval { @html_safe = true }
+          end
+
           new_safe_buffer
         else
           to_str[*args]
@@ -206,7 +210,7 @@ module ActiveSupport #:nodoc:
     end
 
     def encode_with(coder)
-      coder.represent_scalar nil, to_str
+      coder.represent_object nil, to_str
     end
 
     UNSAFE_STRING_METHODS.each do |unsafe_method|

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

@@ -1,4 +1,5 @@
 require 'active_support/time_with_zone'
+require 'active_support/core_ext/time/acts_like'
 require 'active_support/core_ext/date_and_time/zones'
 
 class Time

data/lib/active_support/dependencies.rb

@@ -186,7 +186,7 @@ module ActiveSupport #:nodoc:
       # and we assume therefore the user wants to refer to a top-level constant.
       def guess_for_anonymous(const_name)
         if Object.const_defined?(const_name)
-          raise NameError, "#{const_name} cannot be autoloaded from an anonymous class or module"
+          raise NameError.new "#{const_name} cannot be autoloaded from an anonymous class or module", const_name
         else
           Object
         end
@@ -515,9 +515,9 @@ module ActiveSupport #:nodoc:
         end
       end
 
-      raise NameError,
-            "uninitialized constant #{qualified_name}",
-            caller.reject { |l| l.starts_with? __FILE__ }
+      name_error = NameError.new("uninitialized constant #{qualified_name}", const_name)
+      name_error.set_backtrace(caller.reject {|l| l.starts_with? __FILE__ })
+      raise name_error
     end
 
     # Remove the constants that have been autoloaded, and those that have been

data/lib/active_support/duration.rb

@@ -49,6 +49,10 @@ module ActiveSupport
       end
     end
 
+    def eql?(other)
+      other.is_a?(Duration) && self == other
+    end
+
     def self.===(other) #:nodoc:
       other.is_a?(Duration)
     rescue ::NoMethodError
@@ -74,7 +78,7 @@ module ActiveSupport
         reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
         sort_by {|unit,  _ | [:years, :months, :days, :minutes, :seconds].index(unit)}.
         map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}"}.
-        to_sentence(:locale => :en)
+        to_sentence(locale: ::I18n.default_locale)
     end
 
     def as_json(options = nil) #:nodoc:

data/lib/active_support/gem_version.rb

@@ -7,7 +7,7 @@ module ActiveSupport
   module VERSION
     MAJOR = 4
     MINOR = 1
-    TINY  = 0
+    TINY  = 11
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")