From 2b5b60fc3c4251536b837937391ebdd028892b15 Mon Sep 17 00:00:00 2001 From: Mark McSpadden Date: Wed, 23 May 2012 12:31:35 -0500 Subject: Add Hash#deep_transform_keys and Hash#deep_transform_keys! Also convert deep_*_keys to use deep_transform_keys. --- activesupport/CHANGELOG.md | 2 +- .../lib/active_support/core_ext/hash/keys.rb | 43 +++++++++++++--------- activesupport/test/core_ext/hash_ext_test.rb | 17 ++++++++- 3 files changed, 43 insertions(+), 19 deletions(-) (limited to 'activesupport') diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md index 0171742347..62b8a789c7 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 5eb861934d..362d584ba1 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 @@ class Hash 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 e68733db8b..f13fff43d4 100644 --- a/activesupport/test/core_ext/hash_ext_test.rb +++ b/activesupport/test/core_ext/hash_ext_test.rb @@ -32,14 +32,17 @@ class HashExtTest < ActiveSupport::TestCase @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 @@ class HashExtTest < ActiveSupport::TestCase 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 -- cgit v1.2.3