insensitive_hash 0.3.1 → 0.3.2

data/CHANGELOG.markdown

@@ -1,14 +1,14 @@
-### 0.3.1
+### 0.3.2
 * Supports custom key encoder
+* Added `InsensitiveHash#merge_recursive!`
 
 ### 0.3.0
+* Now allowing underscores for spaces is by default on, and cannot be turned off.
 * "Inherited insensitivity" had been a great source of confusion,
   as it stores transformed version of the given Array of Hash.
   From 0.3.0, Hash values and descendant Hashes are converted to be insensitive
-  only on the initialization of InsensitiveHash or on `underscore=` call.
+  only on the initialization of InsensitiveHash.
   Refer to the following code
-* Now allowing underscores for spaces is by default on, and cannot be turned off.
-
 ```ruby
   ih = {}.insensitive
   ih[:a] = { :b => :c }
@@ -19,7 +19,6 @@
   ih2 = ih.insensitive
   ih2[:a]['B']           # :c
 ```
-* `:underscore` option is on by default
 
 ### 0.2.4
 * Bug fix: Invalid `dup`, `clone` behavior

data/README.markdown

@@ -76,9 +76,8 @@ ih.keys            # ['DEF']
 Inherited insensitivity
 -----------------------
 
-When InsensitiveHash is built from another Hash,
-descendant Hash values are recursively converted to be insensitive
-(Useful when processing YAML inputs)
+When an InsensitiveHash is built from another Hash,
+descendant Hash values are recursively converted to be insensitive.
 
 ```ruby
 
@@ -90,7 +89,7 @@ ih['one'].first.first.first['A']['b'][:C]  # 'd'
 ```
 
 However, once InsensitiveHash is initialized,
-descendant Hashes are not automatically converted.
+descendant Hashes (or Hashes in Arrays) are not automatically converted.
 
 ```ruby
 ih = {}.insensitive
@@ -99,7 +98,7 @@ ih[:abc] = { :def => true }
 ih['ABC']['DEF']     # nil
 ```
 
-Simply build a new InsensitiveHash again if you need recursive conversion.
+Simply build a new InsensitiveHash out of it if you need recursive conversion.
 
 ```ruby
 ih2 = ih.insensitive
@@ -107,6 +106,7 @@ ih2['ABC']['DEF']    # true
 ```
 
 ### Example: Processing case-insensitive YAML input
+
 ```ruby
 db = YAML.load(File.read 'database.yml').insensitive
 
@@ -118,7 +118,7 @@ db[:production][:adapter]
 Customizing insensitivity
 -------------------------
 
-You can provide a Proc object as the key encoder which determines the level of insensitivity.
+You can provide a `#call`-able object (duck-typing) as the key encoder which determines the level of insensitivity.
 
 ### Default encoder
 
@@ -139,13 +139,9 @@ InsensitiveHash::DEFAULT_ENCODER =
 ### Encoder examples
 
 ```ruby
-h1 = {}.insensitive(:encoder => proc { |key| key.to_s })
-h2 = {}.insensitive(:encoder => proc { |key| key.to_s.downcase })
-h3 = {}.insensitive(:encoder => proc { |key| key.to_s.downcase.gsub(/\s+/, '_') })
-
-# Without `insensitive` method
-h4 = InsensitiveHash.new
-h4.encoder = proc { |key| key.to_s }
+ih1 = {}.insensitive(:encoder => proc { |key| key.to_s })
+ih2 = {}.insensitive(:encoder => proc { |key| key.to_s.downcase })
+ih3 = {}.insensitive(:encoder => proc { |key| key.to_s.downcase.gsub(/\s+/, '_') })
 ```
 
 Enabling key-clash detection (Safe mode)

data/lib/insensitive_hash.rb

@@ -7,11 +7,13 @@ class Hash
   # @option options [Proc] :encoder Key encoding Proc
   # @return [InsensitiveHash]
   def insensitive options = {}
-    InsensitiveHash[self].tap do |ih|
+    InsensitiveHash.new.tap do |ih|
       ih.safe         = options[:safe] if options.has_key?(:safe)
       ih.encoder      = options[:encoder] if options.has_key?(:encoder)
       ih.default      = self.default
       ih.default_proc = self.default_proc if self.default_proc
+
+      ih.merge_recursive!(self)
     end
   end
 end

data/lib/insensitive_hash/insensitive_hash.rb

@@ -1,9 +1,11 @@
+# Insensitive Hash.
 # @author Junegunn Choi <junegunn.c@gmail.com>
 # @!attribute [r] encoder
-#   @return [Proc] Key encoding Proc
+#   @return [#call] Key encoder. Determines the level of insensitivity.
 class InsensitiveHash < Hash
   attr_reader :encoder
 
+  # Thrown when safe mode is on and another Hash with conflicting keys cannot be merged safely
   class KeyClashError < Exception
   end
 
@@ -42,10 +44,10 @@ class InsensitiveHash < Hash
     @safe
   end
 
-  # @param [Proc] prc Key encoding Proc
-  # @return [Proc]
+  # @param [#call] prc Key encoder. Determines the level of insensitivity.
+  # @return [#call]
   def encoder= prc
-    raise ArgumentError, "Proc object required" unless prc.is_a?(Proc)
+    raise ArgumentError, "Encoder must respond to :call" unless prc.respond_to?(:call)
 
     kvs = to_a
     clear
@@ -64,10 +66,11 @@ class InsensitiveHash < Hash
   end
   alias sensitive to_hash
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def self.[] *init
     h = Hash[*init]
     InsensitiveHash.new.tap do |ih|
-      ih.merge! h
+      ih.merge_recursive! h
     end
   end
 
@@ -79,6 +82,7 @@ class InsensitiveHash < Hash
     EVAL
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def []= key, value
     delete key
     ekey = encode key
@@ -87,15 +91,17 @@ class InsensitiveHash < Hash
   end
   alias store []=
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def merge! other_hash
     detect_clash other_hash
     other_hash.each do |key, value|
-      deep_set key, value
+      store key, value
     end
     self
   end
   alias update! merge!
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def merge other_hash
     InsensitiveHash.new.tap do |ih|
       ih.replace self
@@ -104,15 +110,30 @@ class InsensitiveHash < Hash
   end
   alias update merge
 
+  # Merge another hash recursively.
+  # @param [Hash|InsensitiveHash] other_hash
+  # @return [self]
+  def merge_recursive! other_hash
+    detect_clash other_hash
+    other_hash.each do |key, value|
+      deep_set key, value
+    end
+    self
+  end
+  alias update_recursive! merge_recursive!
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def delete key, &block
     super lookup_key(key, true), &block
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def clear
     @key_map.clear
     super
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def replace other
     super other
 
@@ -126,27 +147,32 @@ class InsensitiveHash < Hash
     end
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def shift
     super.tap do |ret|
       @key_map.delete_if { |k, v| v == ret.first }
     end
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def values_at *keys
     keys.map { |k| self[k] }
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def fetch *args, &block
     args[0] = lookup_key(args[0]) if args.first
     super *args, &block
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def dup
     super.tap { |copy|
       copy.instance_variable_set :@key_map, @key_map.dup
     }
   end
 
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
   def clone
     super.tap { |copy|
       copy.instance_variable_set :@key_map, @key_map.dup
@@ -162,9 +188,16 @@ private
   def wrap value
     case value
     when InsensitiveHash
-      value
+      value.tap { |ih|
+        ih.safe = safe?
+        ih.encoder = encoder
+      }
     when Hash
-      InsensitiveHash[value]
+      InsensitiveHash.new.tap { |ih|
+        ih.safe = safe?
+        ih.encoder = encoder
+        ih.merge_recursive!(value)
+      }
     when Array
       value.map { |v| wrap v }
     else

data/lib/insensitive_hash/version.rb

@@ -1,3 +1,3 @@
 class InsensitiveHash < Hash
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/test/test_insensitive_hash.rb

@@ -177,11 +177,16 @@ class TestInsensitiveHash < Test::Unit::TestCase
   def test_merge
     [:merge, :update].each do |method|
       ih = InsensitiveHash[:a => 1, 'hello world' => 2]
-      ih2 = ih.send(method, :b => 2)
+      nh = { :d => :e }
+      ih2 = ih.send(method, :b => 2, :c => nh)
 
       assert_keys [:a, 'hello world'], ih.keys
-      assert_keys [:a, 'hello world', :b], ih2.keys
+      assert_keys [:a, 'hello world', :b, :c], ih2.keys
       assert ih2.has_key?('B'), 'correctly merged another hash'
+      # No recursive merge
+      assert_equal :e, ih2[:c][:d]
+      assert_equal nil, ih2[:c][:D]
+      assert_equal nh.object_id, ih2[:c].object_id
 
       assert_equal 2, ih[:hello_world]
       assert_equal 2, ih.send(method, :b => 2)[:hello_world]
@@ -219,6 +224,25 @@ class TestInsensitiveHash < Test::Unit::TestCase
     end
   end
 
+  def test_merge_recursive!
+    [:merge_recursive!, :update_recursive!].each do |method|
+      ih = InsensitiveHash.new
+      ih[:a] = 1
+      ih[:b] = 2
+
+      nh = { 'b' => 3, :c => :d }
+      ih.send(method, nh)
+      assert_equal 3, ih[:b]
+      assert_equal :d, ih['C']
+
+      ih.safe = true
+      nh = { 'd' => 4, 'D' => 5 }
+      assert_raise(InsensitiveHash::KeyClashError) { ih.send(method, nh) }
+      ih.safe = false
+      ih.send(method, nh)
+    end
+  end
+
   def test_merge_clash_overwritten
     ih = InsensitiveHash.new
 
@@ -395,7 +419,7 @@ class TestInsensitiveHash < Test::Unit::TestCase
   def test_has_key_after_delete
     set = [:a, :A, 'a', 'A', :b, :B, 'b', 'B']
     h = InsensitiveHash[ :a => 1, :b => 2 ]
-    
+
     set.each { |s| assert h.has_key?(s) }
     h.delete_if { |k, v| true }
     set.each { |s| assert !h.has_key?(s) }
@@ -476,7 +500,7 @@ class TestInsensitiveHash < Test::Unit::TestCase
   end
 
   def test_underscore_inheritance
-    h = 
+    h =
       {
         'Key with spaces' => {
           'Another key with spaces' => 1
@@ -545,7 +569,12 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_equal true, a[:HELLO_WORLD]
 
     # Update again
-    a.encoder = proc { |key| key.to_s }
+    callable = Class.new {
+      def call key
+        key.to_s
+      end
+    }.new
+    a.encoder = callable
     assert_equal true, a[:"hello world"]
     assert_equal nil, a['HELLO WORLD']
     assert_equal nil, a[:hello_world]
@@ -576,5 +605,20 @@ class TestInsensitiveHash < Test::Unit::TestCase
     a[:key2] = 2
     assert_equal 2, a['key2']
   end
+
+  def test_encoder_nested
+    [ { :a => { :b => { :c => :d } } },
+      { :a => { :b => { :c => :d }.insensitive } },
+    ].each do |h|
+      ih = h.insensitive(:encoder => proc { |key| 1 })
+      assert ih.has_key?(:anything)
+      assert_equal :d, ih[:a][:b][:c]
+      assert_equal :b, ih[:any].keys.first
+      assert_equal :d, ih[:any][:any][:c]
+      assert_equal :d, ih[:any][:any][:C]
+      assert_instance_of InsensitiveHash, ih[:any][:any]
+      assert_equal :d, ih[:any][:any][:any]
+    end
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: insensitive_hash
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-20 00:00:00.000000000 Z
+date: 2013-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit