diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 017174234704727a859df8aba335990c7766232d..62b8a789c70dd6633c9b8cbb164b5d93bae585a3 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,6 +1,6 @@
 ## Rails 4.0.0 (unreleased) ##
 
-*   Add `Hash#transform_keys` and `Hash#transform_keys!`. *Mark McSpadden*
+*   Add `Hash#transform_keys`, `Hash#transform_keys!`, `Hash#deep_transform_keys`, and `Hash#deep_transform_keys!`. *Mark McSpadden*
 
 *   Changed xml type `datetime` to `dateTime` (with upper case letter `T`). *Angelo Capilleri*
 
diff --git a/activesupport/lib/active_support/core_ext/hash/keys.rb b/activesupport/lib/active_support/core_ext/hash/keys.rb
index 5eb861934d91f3c4fbad7a88b45e0fd01efd4f4c..362d584ba139b1891fead2ea304c1b1756f7b5d9 100644
--- a/activesupport/lib/active_support/core_ext/hash/keys.rb
+++ b/activesupport/lib/active_support/core_ext/hash/keys.rb
@@ -65,47 +65,56 @@ def assert_valid_keys(*valid_keys)
     end
   end
 
-  # Return a new hash with all keys converted to strings.
+  # 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.
-  def deep_stringify_keys
+  #
+  #  { :person => { :name => 'Rob', :years => '28' } }.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => { "PERSON" => { "NAME" => "Rob", "YEARS" => "28" } }
+  def deep_transform_keys(&block)
     result = {}
     each do |key, value|
-      result[key.to_s] = value.is_a?(Hash) ? value.deep_stringify_keys : value
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
     end
     result
   end
 
-  # Destructively convert all keys to strings.
+  # Destructively convert all keys by using the block operation.
   # This includes the keys from the root hash and from all
   # nested hashes.
-  def deep_stringify_keys!
+  def deep_transform_keys!(&block)
     keys.each do |key|
-      val = delete(key)
-      self[key.to_s] = val.is_a?(Hash) ? val.deep_stringify_keys! : val
+      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.
+  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
+
   # 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!
-    keys.each do |key|
-      val = delete(key)
-      self[(key.to_sym rescue key)] = val.is_a?(Hash) ? val.deep_stringify_keys! : val
-    end
-    self
+    deep_transform_keys!{ |key| key.to_sym rescue key }
   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.
   def deep_symbolize_keys
-    result = {}
-    each do |key, value|
-      result[(key.to_sym rescue key)] = value.is_a?(Hash) ? value.deep_symbolize_keys : value
-    end
-    result
+    deep_transform_keys{ |key| key.to_sym rescue key }
   end
 end
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index e68733db8bb77cef4e2598756dd3859e20e7f2fa..f13fff43d4f9e019db5dc177534eb17bffc84893 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -32,14 +32,17 @@ def setup
     @fixnums = {  0  => 1,  1  => 2 }
     @nested_fixnums = {  0  => { 1  => { 2 => 3} } }
     @illegal_symbols = { [] => 3 }
-    @upcase_strings = { 'A' => 1, 'B' => 2 }
     @nested_illegal_symbols = { [] => { [] => 3} }
+    @upcase_strings = { 'A' => 1, 'B' => 2 }
+    @nested_upcase_strings = { 'A' => { 'B' => { 'C' => 3 } } }
   end
 
   def test_methods
     h = {}
     assert_respond_to h, :transform_keys
     assert_respond_to h, :transform_keys!
+    assert_respond_to h, :deep_transform_keys
+    assert_respond_to h, :deep_transform_keys!
     assert_respond_to h, :symbolize_keys
     assert_respond_to h, :symbolize_keys!
     assert_respond_to h, :deep_symbolize_keys
@@ -58,12 +61,24 @@ def test_transform_keys
     assert_equal @upcase_strings, @mixed.transform_keys{ |key| key.to_s.upcase }
   end
 
+  def test_deep_transform_keys
+    assert_equal @nested_upcase_strings, @nested_symbols.deep_transform_keys{ |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_strings.deep_transform_keys{ |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_mixed.deep_transform_keys{ |key| key.to_s.upcase }
+  end
+
   def test_transform_keys!
     assert_equal @upcase_strings, @symbols.dup.transform_keys!{ |key| key.to_s.upcase }
     assert_equal @upcase_strings, @strings.dup.transform_keys!{ |key| key.to_s.upcase }
     assert_equal @upcase_strings, @mixed.dup.transform_keys!{ |key| key.to_s.upcase }
   end
 
+  def test_deep_transform_keys!
+    assert_equal @nested_upcase_strings, @nested_symbols.deep_transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_strings.deep_transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, @nested_mixed.deep_transform_keys!{ |key| key.to_s.upcase }
+  end  
+
   def test_symbolize_keys
     assert_equal @symbols, @symbols.symbolize_keys
     assert_equal @symbols, @strings.symbolize_keys
diff --git a/guides/source/active_support_core_extensions.textile b/guides/source/active_support_core_extensions.textile
index e2118e8f618626c3f102a6bd6bbe4c336577e8dd..587f65529e521281ce69250e3ae32ad7b1d5dfa4 100644
--- a/guides/source/active_support_core_extensions.textile
+++ b/guides/source/active_support_core_extensions.textile
@@ -2579,6 +2579,13 @@ end
 
 There's also the bang variant +transform_keys!+ that applies the block operations to keys in the very receiver.
 
+Besides that, one can use +deep_transform_keys+ and +deep_transform_keys!+ to perform the block operation on all the keys in the given hash and all the hashes nested into it. An example of the result is:
+
+<ruby>
+{nil => nil, 1 => 1, :nested => {:a => 3, 5 => 5}}.deep_transform_keys{ |key| key.to_s.upcase }
+# => {""=>nil, "1"=>1, "NESTED"=>{"A"=>3, "5"=>5}}
+</ruby>
+
 NOTE: Defined in +active_support/core_ext/hash/keys.rb+.
 
 h5. +stringify_keys+ and +stringify_keys!+