activesupport 3.2.22.5 → 4.0.0

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

@@ -1,14 +1,16 @@
 require 'active_support/xml_mini'
 require 'active_support/time'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/object/to_query'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string/inflections'
 
 class Hash
   # Returns a string containing an XML representation of its receiver:
   #
-  #   {"foo" => 1, "bar" => 2}.to_xml
+  #   {'foo' => 1, 'bar' => 2}.to_xml
   #   # =>
   #   # <?xml version="1.0" encoding="UTF-8"?>
   #   # <hash>
@@ -26,21 +28,21 @@ class Hash
   #
   # * If +value+ is a callable object it must expect one or two arguments. Depending
   #   on the arity, the callable is invoked with the +options+ hash as first argument
-  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The 
+  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The
   #   callable can add nodes by using <tt>options[:builder]</tt>.
   #
-  #     "foo".to_xml(lambda { |options, key| options[:builder].b(key) })
+  #     'foo'.to_xml(lambda { |options, key| options[:builder].b(key) })
   #     # => "<b>foo</b>"
   #
   # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
-  #     
+  #
   #     class Foo
   #       def to_xml(options)
-  #         options[:builder].bar "fooing!"
+  #         options[:builder].bar 'fooing!'
   #       end
   #     end
-  #          
-  #     {:foo => Foo.new}.to_xml(:skip_instruct => true)
+  #
+  #     { foo: Foo.new }.to_xml(skip_instruct: true)
   #     # => "<hash><bar>fooing!</bar></hash>"
   #
   # * Otherwise, a node with +key+ as tag is created with a string representation of
@@ -57,8 +59,8 @@ class Hash
   #       "TrueClass"  => "boolean",
   #       "FalseClass" => "boolean",
   #       "Date"       => "date",
-  #       "DateTime"   => "datetime",
-  #       "Time"       => "datetime"
+  #       "DateTime"   => "dateTime",
+  #       "Time"       => "dateTime"
   #     }
   #
   # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
@@ -71,105 +73,169 @@ class Hash
 
     options = options.dup
     options[:indent]  ||= 2
-    options[:root]    ||= "hash"
-    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    options[:root]    ||= 'hash'
+    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
 
     builder = options[:builder]
     builder.instruct! unless options.delete(:skip_instruct)
 
     root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
 
-    builder.__send__(:method_missing, root) do
+    builder.tag!(root) do
       each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
       yield builder if block_given?
     end
   end
 
-  class DisallowedType < StandardError #:nodoc:
-    def initialize(type)
-      super "Disallowed type attribute: #{type.inspect}"
-    end
-  end
-
-  DISALLOWED_XML_TYPES = %w(symbol yaml)
-
   class << self
+    # Returns a Hash containing a collection of pairs when the key is the node name and the value is
+    # its content
+    #
+    #   xml = <<-XML
+    #     <?xml version="1.0" encoding="UTF-8"?>
+    #       <hash>
+    #         <foo type="integer">1</foo>
+    #         <bar type="integer">2</bar>
+    #       </hash>
+    #   XML
+    #
+    #   hash = Hash.from_xml(xml)
+    #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
+    #
+    # DisallowedType is raise if the XML contains attributes with <tt>type="yaml"</tt> or
+    # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to parse this XML.
     def from_xml(xml, disallowed_types = nil)
-      typecast_xml_value(unrename_keys(ActiveSupport::XmlMini.parse(xml)), disallowed_types)
+      ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
     end
 
+    # Builds a Hash from XML just like <tt>Hash.from_xml</tt>, but also allows Symbol and YAML.
     def from_trusted_xml(xml)
       from_xml xml, []
     end
+  end
+end
 
-    private
-      def typecast_xml_value(value, disallowed_types = nil)
-        disallowed_types ||= DISALLOWED_XML_TYPES
+module ActiveSupport
+  class XMLConverter # :nodoc:
+    class DisallowedType < StandardError
+      def initialize(type)
+        super "Disallowed type attribute: #{type.inspect}"
+      end
+    end
 
-        case value.class.to_s
-          when 'Hash'
-            if value.include?('type') && !value['type'].is_a?(Hash) && disallowed_types.include?(value['type'])
-              raise DisallowedType, value['type']
-            end
+    DISALLOWED_TYPES = %w(symbol yaml)
 
-            if value['type'] == 'array'
-              _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
-              if entries.nil? || (c = value['__content__'] && c.blank?)
-                []
-              else
-                case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
-                when "Array"
-                  entries.collect { |v| typecast_xml_value(v, disallowed_types) }
-                when "Hash"
-                  [typecast_xml_value(entries, disallowed_types)]
-                else
-                  raise "can't typecast #{entries.inspect}"
-                end
-              end
-            elsif value['type'] == 'file' || 
-               (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
-              content = value["__content__"]
-              if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
-                parser.arity == 1 ? parser.call(content) : parser.call(content, value)
-              else
-                content
-              end
-            elsif value['type'] == 'string' && value['nil'] != 'true'
-              ""
-            # blank or nil parsed values are represented by nil
-            elsif value.blank? || value['nil'] == 'true'
-              nil
-            # If the type is the only element which makes it then
-            # this still makes the value nil, except if type is
-            # a XML node(where type['value'] is a Hash)
-            elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
-              nil
-            else
-              xml_value = Hash[value.map { |k,v| [k, typecast_xml_value(v, disallowed_types)] }]
+    def initialize(xml, disallowed_types = nil)
+      @xml = normalize_keys(XmlMini.parse(xml))
+      @disallowed_types = disallowed_types || DISALLOWED_TYPES
+    end
 
-              # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with
-              # how multipart uploaded files from HTML appear
-              xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
-            end
-          when 'Array'
-            value.map! { |i| typecast_xml_value(i, disallowed_types) }
-            value.length > 1 ? value : value.first
-          when 'String'
+    def to_h
+      deep_to_h(@xml)
+    end
+
+    private
+      def normalize_keys(params)
+        case params
+          when Hash
+            Hash[params.map { |k,v| [k.to_s.tr('-', '_'), normalize_keys(v)] } ]
+          when Array
+            params.map { |v| normalize_keys(v) }
+          else
+            params
+        end
+      end
+
+      def deep_to_h(value)
+        case value
+          when Hash
+            process_hash(value)
+          when Array
+            process_array(value)
+          when String
             value
           else
             raise "can't typecast #{value.class.name} - #{value.inspect}"
         end
       end
 
-      def unrename_keys(params)
-        case params.class.to_s
-          when "Hash"
-            Hash[params.map { |k,v| [k.to_s.tr("-", "_"), unrename_keys(v)] } ]
-          when "Array"
-            params.map { |v| unrename_keys(v) }
+      def process_hash(value)
+        if value.include?('type') && !value['type'].is_a?(Hash) && @disallowed_types.include?(value['type'])
+          raise DisallowedType, value['type']
+        end
+
+        if become_array?(value)
+          _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
+          if entries.nil? || value['__content__'].try(:empty?)
+            []
           else
-            params
+            case entries
+            when Array
+              entries.collect { |v| deep_to_h(v) }
+            when Hash
+              [deep_to_h(entries)]
+            else
+              raise "can't typecast #{entries.inspect}"
+            end
+          end
+        elsif become_content?(value)
+          process_content(value)
+
+        elsif become_empty_string?(value)
+          ''
+        elsif become_hash?(value)
+          xml_value = Hash[value.map { |k,v| [k, deep_to_h(v)] }]
+
+          # Turn { files: { file: #<StringIO> } } into { files: #<StringIO> } so it is compatible with
+          # how multipart uploaded files from HTML appear
+          xml_value['file'].is_a?(StringIO) ? xml_value['file'] : xml_value
         end
       end
+
+      def become_content?(value)
+        value['type'] == 'file' || (value['__content__'] && (value.keys.size == 1 || value['__content__'].present?))
+      end
+
+      def become_array?(value)
+        value['type'] == 'array'
+      end
+
+      def become_empty_string?(value)
+        # {"string" => true}
+        # No tests fail when the second term is removed.
+        value['type'] == 'string' && value['nil'] != 'true'
+      end
+
+      def become_hash?(value)
+        !nothing?(value) && !garbage?(value)
+      end
+
+      def nothing?(value)
+        # blank or nil parsed values are represented by nil
+        value.blank? || value['nil'] == 'true'
+      end
+
+      def garbage?(value)
+        # If the type is the only element which makes it then
+        # this still makes the value nil, except if type is
+        # a XML node(where type['value'] is a Hash)
+        value['type'] && !value['type'].is_a?(::Hash) && value.size == 1
+      end
+
+      def process_content(value)
+        content = value['__content__']
+        if parser = ActiveSupport::XmlMini::PARSING[value['type']]
+          parser.arity == 1 ? parser.call(content) : parser.call(content, value)
+        else
+          content
+        end
+      end
+
+      def process_array(value)
+        value.map! { |i| deep_to_h(i) }
+        value.length > 1 ? value : value.first
+      end
+
   end
 end
+

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

@@ -1,20 +1,26 @@
 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 = { x: { y: [4,5,6] }, z: [7,8,9] }
+  #   h2 = { x: { y: [7,8,9] }, z: 'xyz' }
   #
-  #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
-  #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
-  def deep_merge(other_hash)
-    dup.deep_merge!(other_hash)
+  #   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"]}
+  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)
+  def deep_merge!(other_hash, &block)
     other_hash.each_pair do |k,v|
       tv = self[k]
-      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+      if tv.is_a?(Hash) && v.is_a?(Hash)
+        self[k] = tv.deep_merge(v, &block)
+      else
+        self[k] = block && tv ? block.call(k, tv, v) : v
+      end
     end
     self
   end

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

@@ -1,13 +1,14 @@
 class Hash
   # Returns a hash that represents the difference between two hashes.
   #
-  # Examples:
-  #
   #   {1 => 2}.diff(1 => 2)         # => {}
   #   {1 => 2}.diff(1 => 3)         # => {1 => 2}
   #   {}.diff(1 => 2)               # => {1 => 2}
   #   {1 => 2, 3 => 4}.diff(1 => 2) # => {3 => 4}
-  def diff(h2)
-    dup.delete_if { |k, v| h2[k] == v }.merge!(h2.dup.delete_if { |k, v| has_key?(k) })
+  def diff(other)
+    ActiveSupport::Deprecation.warn "Hash#diff is no longer used inside of Rails, and is being deprecated with no replacement. If you're using it to compare hashes for the purpose of testing, please use MiniTest's assert_equal instead."
+    dup.
+      delete_if { |k, v| other[k] == v }.
+      merge!(other.dup.delete_if { |k, v| has_key?(k) })
   end
 end

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

@@ -2,15 +2,7 @@ class Hash
   # Return a hash that includes everything but the given keys. This is useful for
   # limiting a set of parameters to everything but a few known toggles:
   #
-  #   @person.update_attributes(params[:person].except(:admin))
-  #
-  # If the receiver responds to +convert_key+, the method is called on each of the
-  # arguments. This allows +except+ to play nice with hashes with indifferent access
-  # for instance:
-  #
-  #   {:a => 1}.with_indifferent_access.except(:a)  # => {}
-  #   {:a => 1}.with_indifferent_access.except("a") # => {}
-  #
+  #   @person.update(params[:person].except(:admin))
   def except(*keys)
     dup.except!(*keys)
   end

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

@@ -1,10 +1,10 @@
 require 'active_support/hash_with_indifferent_access'
 
 class Hash
+
   # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
   #
-  #   {:a => 1}.with_indifferent_access["a"] # => 1
-  #
+  #   { a: 1 }.with_indifferent_access['a'] # => 1
   def with_indifferent_access
     ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
   end
@@ -16,8 +16,7 @@ class Hash
   # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
   # desirable.
   #
-  #   b = {:b => 1}
-  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
-  #
+  #   b = { b: 1 }
+  #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
   alias nested_under_indifferent_access with_indifferent_access
 end

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

@@ -1,54 +1,138 @@
 class Hash
+  # Return a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => { "NAME" => "Rob", "AGE" => "28" }
+  def transform_keys
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
   # Return a new hash with all keys converted to strings.
   #
-  #   { :name => 'Rob', :years => '28' }.stringify_keys
-  #   #=> { "name" => "Rob", "years" => "28" }
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   #=> { "name" => "Rob", "age" => "28" }
   def stringify_keys
-    dup.stringify_keys!
+    transform_keys{ |key| key.to_s }
   end
 
   # Destructively convert all keys to strings. Same as
   # +stringify_keys+, but modifies +self+.
   def stringify_keys!
-    keys.each do |key|
-      self[key.to_s] = delete(key)
-    end
-    self
+    transform_keys!{ |key| key.to_s }
   end
 
   # Return a new hash with all keys converted to symbols, as long as
   # they respond to +to_sym+.
   #
-  #   { 'name' => 'Rob', 'years' => '28' }.symbolize_keys
-  #   #=> { :name => "Rob", :years => "28" }
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   #=> { name: "Rob", age: "28" }
   def symbolize_keys
-    dup.symbolize_keys!
+    transform_keys{ |key| key.to_sym rescue key }
   end
+  alias_method :to_options,  :symbolize_keys
 
   # Destructively convert all keys to symbols, as long as they respond
   # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
   def symbolize_keys!
-    keys.each do |key|
-      self[(key.to_sym rescue key) || key] = delete(key)
-    end
-    self
+    transform_keys!{ |key| key.to_sym rescue key }
   end
-
-  alias_method :to_options,  :symbolize_keys
   alias_method :to_options!, :symbolize_keys!
 
-  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
-  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
-  # as keys, this will fail.
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising ArgumentError
+  # on a mismatch. Note that keys are NOT treated indifferently, meaning if you
+  # use strings for keys but assert symbols as keys, this will fail.
   #
-  # ==== Examples
-  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
-  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key: name"
-  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: name"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
   def assert_valid_keys(*valid_keys)
     valid_keys.flatten!
     each_key do |k|
-      raise(ArgumentError, "Unknown key: #{k}") unless valid_keys.include?(k)
+      raise ArgumentError.new("Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+
+  # Return a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #  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
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  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
+  end
+
+  # Return a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => { "person" => { "name" => "Rob", "age" => "28" } }
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Return 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.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => { person: { name: "Rob", age: "28" } }
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # 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.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
   end
 end

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

@@ -1,11 +1,11 @@
 class Hash
   # Merges the caller into +other_hash+. For example,
   #
-  #   options = options.reverse_merge(:size => 25, :velocity => 10)
+  #   options = options.reverse_merge(size: 25, velocity: 10)
   #
   # is equivalent to
   #
-  #   options = {:size => 25, :velocity => 10}.merge(options)
+  #   options = { size: 25, velocity: 10 }.merge(options)
   #
   # This is particularly useful for initializing an options hash
   # with default values.
@@ -18,6 +18,5 @@ class Hash
     # right wins if there is no left
     merge!( other_hash ){|key,left,right| left }
   end
-
   alias_method :reverse_update, :reverse_merge!
 end

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

@@ -3,7 +3,7 @@ class Hash
   # limiting an options hash to valid keys before passing to a method:
   #
   #   def search(criteria = {})
-  #     assert_valid_keys(:mass, :velocity, :time)
+  #     criteria.assert_valid_keys(:mass, :velocity, :time)
   #   end
   #
   #   search(options.slice(:mass, :velocity, :time))
@@ -13,17 +13,17 @@ class Hash
   #   valid_keys = [:mass, :velocity, :time]
   #   search(options.slice(*valid_keys))
   def slice(*keys)
-    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
-    hash = self.class.new
-    keys.each { |k| hash[k] = self[k] if has_key?(k) }
-    hash
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
   end
 
   # Replaces the hash with only the given keys.
-  # Returns a hash contained the removed key/value pairs
-  #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d => 4}
+  # Returns a hash containing the removed key/value pairs.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
   def slice!(*keys)
-    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
     omit = slice(*self.keys - keys)
     hash = slice(*keys)
     replace(hash)
@@ -31,10 +31,10 @@ class Hash
   end
 
   # Removes and returns the key/value pairs matching the given keys.
-  #   {:a => 1, :b => 2, :c => 3, :d => 4}.extract!(:a, :b) # => {:a => 1, :b => 2}
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
   def extract!(*keys)
-    result = {}
-    keys.each {|key| result[key] = delete(key) }
-    result
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
   end
 end

data/lib/active_support/core_ext/hash.rb

@@ -1,6 +1,5 @@
 require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/hash/deep_dup'
 require 'active_support/core_ext/hash/diff'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/hash/indifferent_access'

data/lib/active_support/core_ext/integer/inflections.rb

@@ -10,8 +10,20 @@ class Integer
   #  1003.ordinalize  # => "1003rd"
   #  -11.ordinalize   # => "-11th"
   #  -1001.ordinalize # => "-1001st"
-  #
   def ordinalize
     ActiveSupport::Inflector.ordinalize(self)
   end
+
+  # Ordinal returns the suffix used to denote the position
+  # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  #  1.ordinal     # => "st"
+  #  2.ordinal     # => "nd"
+  #  1002.ordinal  # => "nd"
+  #  1003.ordinal  # => "rd"
+  #  -11.ordinal   # => "th"
+  #  -1001.ordinal # => "st"
+  def ordinal
+    ActiveSupport::Inflector.ordinal(self)
+  end
 end