deep_hash_transform 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 538a3d6cd8c8b0d3c8b7625395514c097f9a047b
+  data.tar.gz: 456d6517d42225594a5a928db69c37d643f548f2
+SHA512:
+  metadata.gz: 2286c0194b9bb0a9699e5ea6d542bd64992c4aac32f404457cef1c03b40b22bd259f85320d24d3fab662ac83cf32d9be068a6f816dd4590b5784419a059145e2
+  data.tar.gz: ca69c276a74b53d8ce7caa67b652afb8cfc9af9a847a9630ba8b58a3fd92ab22f3734d17815f27ec01330824bd930fff2091ed217bf4b49412d2d8cfcf09d91b

data/lib/deep_hash_transform.rb

@@ -0,0 +1,135 @@
+# These features are available in Rails 4.0+
+#
+# Prefer Active Support's implementation when available.
+#
+# This allows libraries which support multiple Rails versions to depend on
+# `deep_hash_transform` without worrying about implementation collision.
+# This lib will step aside if it sees its work is done.
+begin
+  require 'active_support/core_ext/hash/keys'
+rescue LoadError
+  # No worries if Active Support isn't present. Can be used in isolation.
+end
+
+class Hash
+  # Returns 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 unless method_defined?(:transform_keys)
+
+  # 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 unless method_defined?(:transform_keys!)
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => { "name" => "Rob", "age" => "28" }
+  def stringify_keys
+    transform_keys { |key| key.to_s }
+  end unless method_defined?(:stringify_keys)
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys! { |key| key.to_s }
+  end unless method_defined?(:stringify_keys!)
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => { name: "Rob", age: "28" }
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end unless method_defined?(: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!
+    transform_keys! { |key| key.to_sym rescue key }
+  end unless method_defined?(:symbolize_keys!)
+
+  # 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.
+  #
+  #  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 unless method_defined?(:deep_transform_keys)
+
+  # 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 unless method_defined?(:deep_transform_keys!)
+
+  # Returns 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 unless method_defined?(:deep_stringify_keys)
+
+  # 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 unless method_defined?(:deep_stringify_keys!)
+
+  # 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.
+  #
+  #   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 unless method_defined?(:deep_symbolize_keys)
+
+  # 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 unless method_defined?(:deep_symbolize_keys!)
+end

data/test/active_support_stub/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,14 @@
+STUBBED_ACTIVE_SUPPORT_HASH_KEYS_EXTENSIONS = true
+
+class Hash
+  STUBS = [
+    :transform_keys, :transform_keys!,
+    :stringify_keys, :stringify_keys!,
+    :symbolize_keys, :symbolize_keys!,
+    :deep_transform_keys, :deep_transform_keys!,
+    :deep_stringify_keys, :deep_stringify_keys!,
+    :deep_symbolize_keys, :deep_symbolize_keys! ]
+
+  def rofl; :trololo end
+  STUBS.each { |stub| alias_method stub, :rofl }
+end

data/test/deep_hash_transform_test.rb

@@ -0,0 +1,233 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'minitest/autorun'
+$VERBOSE = true
+
+require 'deep_hash_transform'
+
+class TransformTest < Minitest::Test
+  def setup
+    @strings = { 'a' => 1, 'b' => 2 }
+    @nested_strings = { 'a' => { 'b' => { 'c' => 3 } } }
+    @symbols = { :a  => 1, :b  => 2 }
+    @nested_symbols = { :a => { :b => { :c => 3 } } }
+    @mixed   = { :a  => 1, 'b' => 2 }
+    @nested_mixed   = { 'a' => { :b => { 'c' => 3 } } }
+    @fixnums = {  0  => 1,  1  => 2 }
+    @nested_fixnums = {  0  => { 1  => { 2 => 3} } }
+    @illegal_symbols = { [] => 3 }
+    @nested_illegal_symbols = { [] => { [] => 3} }
+    @upcase_strings = { 'A' => 1, 'B' => 2 }
+    @nested_upcase_strings = { 'A' => { 'B' => { 'C' => 3 } } }
+  end
+
+  def test_transform_keys
+    assert_equal @upcase_strings, @strings.transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @symbols.transform_keys { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, @mixed.transform_keys { |key| key.to_s.upcase }
+  end
+
+  def test_transform_keys_not_mutates
+    transformed_hash = @mixed.dup
+    transformed_hash.transform_keys { |key| key.to_s.upcase }
+    assert_equal @mixed, transformed_hash
+  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_deep_transform_keys_not_mutates
+    transformed_hash = deep_dup(@nested_mixed)
+    transformed_hash.deep_transform_keys { |key| key.to_s.upcase }
+    assert_equal @nested_mixed, transformed_hash
+  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_transform_keys_with_bang_mutates
+    transformed_hash = @mixed.dup
+    transformed_hash.transform_keys! { |key| key.to_s.upcase }
+    assert_equal @upcase_strings, transformed_hash
+    assert_equal @mixed, { :a => 1, "b" => 2 }
+  end
+
+  def test_deep_transform_keys!
+    assert_equal @nested_upcase_strings, deep_dup(@nested_symbols).deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, deep_dup(@nested_strings).deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, deep_dup(@nested_mixed).deep_transform_keys! { |key| key.to_s.upcase }
+  end
+
+  def test_deep_transform_keys_with_bang_mutates
+    transformed_hash = deep_dup(@nested_mixed)
+    transformed_hash.deep_transform_keys! { |key| key.to_s.upcase }
+    assert_equal @nested_upcase_strings, transformed_hash
+    assert_equal @nested_mixed, { 'a' => { :b => { 'c' => 3 } } }
+  end
+
+  def test_symbolize_keys
+    assert_equal @symbols, @symbols.symbolize_keys
+    assert_equal @symbols, @strings.symbolize_keys
+    assert_equal @symbols, @mixed.symbolize_keys
+  end
+
+  def test_symbolize_keys_not_mutates
+    transformed_hash = @mixed.dup
+    transformed_hash.symbolize_keys
+    assert_equal @mixed, transformed_hash
+  end
+
+  def test_deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_symbols.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_strings.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_mixed.deep_symbolize_keys
+  end
+
+  def test_deep_symbolize_keys_not_mutates
+    transformed_hash = deep_dup(@nested_mixed)
+    transformed_hash.deep_symbolize_keys
+    assert_equal @nested_mixed, transformed_hash
+  end
+
+  def test_symbolize_keys!
+    assert_equal @symbols, @symbols.dup.symbolize_keys!
+    assert_equal @symbols, @strings.dup.symbolize_keys!
+    assert_equal @symbols, @mixed.dup.symbolize_keys!
+  end
+
+  def test_symbolize_keys_with_bang_mutates
+    transformed_hash = @mixed.dup
+    transformed_hash.deep_symbolize_keys!
+    assert_equal @symbols, transformed_hash
+    assert_equal @mixed, { :a => 1, "b" => 2 }
+  end
+
+  def test_deep_symbolize_keys!
+    assert_equal @nested_symbols, deep_dup(@nested_symbols).deep_symbolize_keys!
+    assert_equal @nested_symbols, deep_dup(@nested_strings).deep_symbolize_keys!
+    assert_equal @nested_symbols, deep_dup(@nested_mixed).deep_symbolize_keys!
+  end
+
+  def test_deep_symbolize_keys_with_bang_mutates
+    transformed_hash = deep_dup(@nested_mixed)
+    transformed_hash.deep_symbolize_keys!
+    assert_equal @nested_symbols, transformed_hash
+    assert_equal @nested_mixed, { 'a' => { :b => { 'c' => 3 } } }
+  end
+
+  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized
+    assert_equal @illegal_symbols, @illegal_symbols.symbolize_keys
+    assert_equal @illegal_symbols, @illegal_symbols.dup.symbolize_keys!
+  end
+
+  def test_deep_symbolize_keys_preserves_keys_that_cant_be_symbolized
+    assert_equal @nested_illegal_symbols, @nested_illegal_symbols.deep_symbolize_keys
+    assert_equal @nested_illegal_symbols, deep_dup(@nested_illegal_symbols).deep_symbolize_keys!
+  end
+
+  def test_symbolize_keys_preserves_fixnum_keys
+    assert_equal @fixnums, @fixnums.symbolize_keys
+    assert_equal @fixnums, @fixnums.dup.symbolize_keys!
+  end
+
+  def test_deep_symbolize_keys_preserves_fixnum_keys
+    assert_equal @nested_fixnums, @nested_fixnums.deep_symbolize_keys
+    assert_equal @nested_fixnums, deep_dup(@nested_fixnums).deep_symbolize_keys!
+  end
+
+  def test_stringify_keys
+    assert_equal @strings, @symbols.stringify_keys
+    assert_equal @strings, @strings.stringify_keys
+    assert_equal @strings, @mixed.stringify_keys
+  end
+
+  def test_stringify_keys_not_mutates
+    transformed_hash = @mixed.dup
+    transformed_hash.stringify_keys
+    assert_equal @mixed, transformed_hash
+  end
+
+  def test_deep_stringify_keys
+    assert_equal @nested_strings, @nested_symbols.deep_stringify_keys
+    assert_equal @nested_strings, @nested_strings.deep_stringify_keys
+    assert_equal @nested_strings, @nested_mixed.deep_stringify_keys
+  end
+
+  def test_deep_stringify_keys_not_mutates
+    transformed_hash = deep_dup(@nested_mixed)
+    transformed_hash.deep_stringify_keys
+    assert_equal @nested_mixed, transformed_hash
+  end
+
+  def test_stringify_keys!
+    assert_equal @strings, @symbols.dup.stringify_keys!
+    assert_equal @strings, @strings.dup.stringify_keys!
+    assert_equal @strings, @mixed.dup.stringify_keys!
+  end
+
+  def test_stringify_keys_with_bang_mutates
+    transformed_hash = @mixed.dup
+    transformed_hash.stringify_keys!
+    assert_equal @strings, transformed_hash
+    assert_equal @mixed, { :a => 1, "b" => 2 }
+  end
+
+  def test_deep_stringify_keys!
+    assert_equal @nested_strings, deep_dup(@nested_symbols).deep_stringify_keys!
+    assert_equal @nested_strings, deep_dup(@nested_strings).deep_stringify_keys!
+    assert_equal @nested_strings, deep_dup(@nested_mixed).deep_stringify_keys!
+  end
+
+  def test_deep_stringify_keys_with_bang_mutates
+    transformed_hash = deep_dup(@nested_mixed)
+    transformed_hash.deep_stringify_keys!
+    assert_equal @nested_strings, transformed_hash
+    assert_equal @nested_mixed, { 'a' => { :b => { 'c' => 3 } } }
+  end
+
+  private
+    def deep_dup(hash)
+      Marshal.load(Marshal.dump(hash))
+    end
+end
+
+# Put a fake Active Support implementation in the load path to verify that
+# we defer to its Hash extensions when they're already defined.
+class ForwardCompatibilityTest < Minitest::Test
+  def setup;    expunge_loaded_features end
+  def teardown; expunge_loaded_features end
+
+  def test_check_for_active_support_implementation_before_providing_our_own
+    assert_equal [], $LOADED_FEATURES.grep(/hash\/keys/)
+
+    with_stubbed_active_support_in_load_path do
+      require 'deep_hash_transform'
+    end
+
+    assert defined?(::STUBBED_ACTIVE_SUPPORT_HASH_KEYS_EXTENSIONS)
+
+    Hash::STUBS.each do |stub|
+      assert_equal :trololo, Hash.new.send(stub)
+    end
+  end
+
+  private
+  def expunge_loaded_features
+    $LOADED_FEATURES.delete_if { |feature| feature =~ /deep_hash_transform/ }
+  end
+
+  def with_stubbed_active_support_in_load_path
+    $LOAD_PATH.unshift File.expand_path('../active_support_stub', __FILE__)
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+    $LOAD_PATH.shift
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: deep_hash_transform
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Rails Backport
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+description: 
+email: support@basecamp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/deep_hash_transform.rb"
+- "./test/active_support_stub/active_support/core_ext/hash/keys.rb"
+- "./test/deep_hash_transform_test.rb"
+homepage: https://github.com/basecamp/deep_hash_transform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Re-key a nested Hash to all-Symbol or -String keys
+test_files:
+- "./test/active_support_stub/active_support/core_ext/hash/keys.rb"
+- "./test/deep_hash_transform_test.rb"