insensitive_hash 0.2.4 → 0.3.0

data/CHANGELOG.markdown

@@ -1,3 +1,23 @@
+### 0.3.0
+* "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.
+  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 }
+
+  ih[:a]['B']           # nil
+
+  # Initialize another InsensitiveHash
+  ih2 = ih.insensitive
+  ih2[:a]['B']           # :c
+```
+* `:underscore` option is on by default
+
 ### 0.2.4
 * Bug fix: Invalid `dup`, `clone` behavior
 * :safe setting from `Hash#insensitive`

data/README.markdown

@@ -17,9 +17,11 @@ Examples
 require 'insensitive_hash'
 
 ih = {}.insensitive
-ih = { 'abc' => 1, :def => 2 }.insensitive
-ih = { 'hello world' => true }.insensitive(:underscore => true)
-  # :underscore option allows ih[:hello_world]
+
+ih = { :abc => 1, 'hello world' => true }.insensitive
+
+ih['ABC']         # 1
+ih[:Hello_World]  # true
 ```
 
 ### Instantiation without monkey-patching Hash
@@ -31,13 +33,13 @@ require 'insensitive_hash/minimal'
 
 ih = InsensitiveHash.new
 ih = InsensitiveHash.new(:default_value)
-ih = InsensitiveHash.new { |h, k| :default_value_from_block }
+ih = InsensitiveHash.new { |ih, k| ih[k] = InsensitiveHash.new }
 
 ih = InsensitiveHash[ 'abc' => 1, :def => 2 ]
 ih = InsensitiveHash[ 'abc', 1, :def, 2 ]
 ih = InsensitiveHash[ [['abc', 1], [:def, 2]] ]
 
-ih = InsensitiveHash[ 'hello world' => true ].tap { |ih| ih.underscore = true }
+ih = InsensitiveHash[ 'hello world' => true ]
 ```
 
 ### Revert to normal Hash
@@ -49,7 +51,7 @@ h = ih.to_hash
 
 ### Basic usage
 ```ruby
-ih = InsensitiveHash[:abc => 1, 'DEF' => 2]
+ih = {:abc => 1, 'DEF' => 2}.insensitive
 
 # Case-insensitive, Symbol/String-indifferent access.
 ih['Abc']          # 1
@@ -70,17 +72,33 @@ 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)
+
 ```ruby
-# Hash values are recursively converted to be insensitive
-# (Useful when processing YAML inputs)
-ih = InsensitiveHash.new
-ih['kids'] = { :hello => [ { :world => '!!!' } ] }
+
+ih = { 'kids' => { :hello => [ { :world => '!!!' } ] } }.insensitive
 ih[:kids]['Hello'].first['WORLD']  # !!!
 
-ih['one'] = [ [ [ { :a => { :b => { :c => 'd' } } } ] ] ]
+ih = {:one => [ [ [ { :a => { :b => { :c => 'd' } } } ] ] ]}.insensitive
 ih['one'].first.first.first['A']['b'][:C]  # 'd'
 ```
 
+Once InsensitiveHash is initialized, you can convert its descendant Hash values by
+building a new InsensitiveHash from it.
+
+```ruby
+ih = {}.insensitive
+ih[:abc] = { :def => true }
+
+ih['ABC']['DEF']     # nil
+
+ih2 = ih.insensitive
+ih2['ABC']['DEF']    # true
+```
+
 ### Processing case-insensitive YAML input
 ```ruby
 db = YAML.load(File.read 'database.yml').insensitive
@@ -90,23 +108,10 @@ db['Development']['ADAPTER']
 db[:production][:adapter]
 ```
 
-### Replacing spaces in String keys to underscores
+### Enabling key-clash detection (Safe mode)
 ```ruby
-h = { 'A key with spaces' => true }
-
-ih = h.insensitive(:underscore => true)
-ih[:a_key_with_spaces]  # true
-
-# Or without Hash#insensitive,
-ih = InsensitiveHash[ h ].tap { |ih| ih.underscore = true }
-ih.underscore?          # true
-ih[:a_key_with_spaces]  # true
-```
-
-### Enabling key-clash detection
-```ruby
-ih = InsensitiveHash.new.tap { |ih| ih.safe = true }
-ih.safe?           # true
+ih = InsensitiveHash.new
+ih.safe = true
 
 # Will raise InsensitiveHash::KeyClashError
 h.merge!('hello world' => 1, :hello_world => 2)

data/lib/insensitive_hash.rb

@@ -4,10 +4,10 @@ require 'insensitive_hash/insensitive_hash'
 class Hash
   # @return [InsensitiveHash]
   def insensitive options = {}
-    InsensitiveHash.new.tap do |ih|
-      ih.replace self
-      ih.underscore = options[:underscore] if options.has_key?(:underscore)
-      ih.safe       = options[:safe]       if options.has_key?(:safe)
+    InsensitiveHash[self].tap do |ih|
+      ih.safe         = options[:safe] if options.has_key?(:safe)
+      ih.default      = self.default
+      ih.default_proc = self.default_proc if self.default_proc
     end
   end
 end

data/lib/insensitive_hash/insensitive_hash.rb

@@ -11,33 +11,9 @@ class InsensitiveHash < Hash
     end
 
     @key_map    = {}
-    @underscore = false
     @safe       = false
   end
 
-  # Sets whether to replace spaces in String keys to underscores
-  # @param [Boolean] us
-  # @return [Boolean]
-  def underscore= us
-    raise ArgumentError.new("Not true or false") unless [true, false].include?(us)
-
-    # Check key clash
-    detect_clash self, us
-
-    @underscore = us
-    @key_map    = {}
-    self.keys.each do |k|
-      self[k] = self.delete(k)
-    end
-
-    us
-  end
-
-  # @return [Boolean] Whether to replace spaces in String keys to underscores
-  def underscore?
-    @underscore
-  end
-
   # Sets whether to detect key clashes
   # @param [Boolean] 
   # @return [Boolean]
@@ -61,9 +37,7 @@ class InsensitiveHash < Hash
   def self.[] *init
     h = Hash[*init]
     InsensitiveHash.new.tap do |ih|
-      h.each do |key, value|
-        ih[key] = value
-      end
+      ih.merge! h
     end
   end
 
@@ -77,16 +51,16 @@ class InsensitiveHash < Hash
 
   def []= key, value
     delete key
-    ekey = encode key, @underscore
+    ekey = encode key
     @key_map[ekey] = key
-    super key, wrap(value, underscore?)
+    super key, value
   end
   alias store []=
 
   def merge! other_hash
-    detect_clash other_hash, underscore?
+    detect_clash other_hash
     other_hash.each do |key, value|
-      self[key] = value
+      deep_set key, value
     end
     self
   end
@@ -112,15 +86,11 @@ class InsensitiveHash < Hash
   def replace other
     super other
 
-    # TODO
-    # What is the correct behavior of replace when the other hash is not an InsensitiveHash?
-    # underscore property precedence: other => self (FIXME)
-    self.underscore = other.respond_to?(:underscore?) ? other.underscore? : self.underscore?
-    self.safe       = other.safe? if other.respond_to?(:safe?)
+    self.safe = other.respond_to?(:safe?) ? other.safe? : safe?
 
     @key_map.clear
     self.each do |k, v|
-      ekey = encode k, @underscore
+      ekey = encode k
       @key_map[ekey] = k
     end
   end
@@ -153,21 +123,26 @@ class InsensitiveHash < Hash
   end
 
 private
-  def wrap value, us
+  def deep_set key, value
+    wv = wrap value
+    self[key] = wv
+  end
+
+  def wrap value
     case value
     when InsensitiveHash
-      value.tap { |ih| ih.underscore = us || ih.underscore? }
+      value
     when Hash
-      InsensitiveHash[value].tap { |ih| ih.underscore = us }
+      InsensitiveHash[value]
     when Array
-      value.map { |v| wrap v, us }
+      value.map { |v| wrap v }
     else
       value
     end
   end
 
   def lookup_key key, delete = false
-    ekey = encode key, @underscore
+    ekey = encode key
     if @key_map.has_key?(ekey)
       delete ? @key_map.delete(ekey) : @key_map[ekey]
     else
@@ -175,22 +150,17 @@ private
     end
   end
 
-  def encode key, us
+  def encode key
     case key
     when String, Symbol
-      key = key.to_s.downcase
-      if us
-        key.gsub(' ', '_')
-      else
-        key
-      end
+      key.to_s.downcase.gsub(' ', '_')
     else
       key
     end
   end
 
-  def detect_clash hash, us
-    hash.keys.map { |k| encode k, us }.tap { |ekeys|
+  def detect_clash hash
+    hash.keys.map { |k| encode k }.tap { |ekeys|
       raise KeyClashError.new("Key clash detected") if ekeys != ekeys.uniq
     } if @safe
   end

data/lib/insensitive_hash/version.rb

@@ -1,3 +1,3 @@
 class InsensitiveHash < Hash
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 end

data/test/test_insensitive_hash.rb

@@ -3,7 +3,7 @@ require 'bundler'
 Bundler.setup(:default, :development)
 require 'test/unit'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'insensitive_hash/minimal'
+require 'insensitive_hash'
 
 class TestInsensitiveHash < Test::Unit::TestCase
   def eight?
@@ -44,18 +44,27 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert          ih.keys.include?(:b)
     assert_equal 2, ih.keys.length
     assert_equal({ :c => 5 }, ih['B'])
-    assert_equal 5, ih['B']['C']
+    assert_equal 5, ih['B'][:c]
+    assert_equal nil, ih['B']['C']
 
     ih['c'] = [ { 'x' => 1 }, { :y => 2 } ]
     assert       ih.keys.include?('c')
     assert_equal 3, ih.keys.length
+
+    assert_equal nil, ih[:c].first[:x]
+    assert_equal nil, ih[:c].last['Y']
+
+    ih = ih.insensitive
     assert_equal 1, ih[:c].first[:x]
     assert_equal 2, ih[:c].last['Y']
 
     # Deeeeeper nesting
     ih['c'] = [ [ [ { 'x' => 1 }, { :y => 2 } ] ] ]
+    assert_equal nil, ih[:c].first.first.last[:Y]
+    ih = ih.insensitive
     assert_equal 2, ih[:c].first.first.last[:Y]
-    ih['c'] = { 'a' => { 'a' => { 'a' => 100 } } }
+
+    ih['c'] = { 'a' => { 'a' => { 'a' => 100 } } }.insensitive
     assert_equal 100, ih[:C][:a][:A]['A']
 
     ih[5] = 50
@@ -69,11 +78,12 @@ class TestInsensitiveHash < Test::Unit::TestCase
       :c  => { :D => [ { 'e' => 3 } ] }
     }
 
-    assert_raise(NoMethodError) {
-      hash.insensitive
-    }
+    pend("TODO") do
+      assert_raise(NoMethodError) {
+        hash.insensitive
+      }
+    end
 
-    require 'insensitive_hash'
     [hash.insensitive, InsensitiveHash[hash]].each do |ih|
       assert       ih.is_a?(Hash)
       assert_equal InsensitiveHash, ih.class
@@ -86,15 +96,20 @@ class TestInsensitiveHash < Test::Unit::TestCase
       end
     end
 
+    # Changelog 0.3.0
+    ih = {}.insensitive
+    ih[:a] = { :b => :c }
+    assert_nil ih[:a]['B']
+    ih2 = ih.insensitive
+    assert_equal :c, ih2[:a]['B']
+
     # InsensitiveHash#insensitive
     ihash1 = hash.insensitive
     ihash1.default = :default
-    ihash1.underscore = true
     ihash2 = ihash1.insensitive.insensitive.insensitive
 
     assert_equal InsensitiveHash, ihash2.class
     assert_equal :default, ihash2.default
-    assert_equal true,     ihash2.underscore?
 
     # Preserving default
     [:default, nil].each do |d|
@@ -116,31 +131,23 @@ class TestInsensitiveHash < Test::Unit::TestCase
 
     # FIXME: test insensitive call with encoder
     h = InsensitiveHash[{'Key with spaces' => 1}]
-    h2 = h.insensitive :underscore => true
-    h3 = h.insensitive :underscore => false
-    assert_raise(ArgumentError) { h.insensitive :underscore => :wat }
+    h2 = h.insensitive
 
     assert_equal 1, h['key with spaces']
-    assert_nil      h[:key_with_spaces]
-    assert_equal 1, h3['key with spaces']
-    assert_nil      h3[:key_with_spaces]
+    assert_equal 1, h[:key_with_spaces]
     assert_equal 1, h2[:KEY_WITH_SPACES]
     assert_equal 1, h2[:Key_with_spaces]
 
     assert_equal ['Key with spaces'], h.keys
     assert_equal ['Key with spaces'], h2.keys
-    assert_equal ['Key with spaces'], h3.keys
 
     h = { 'A key with spaces' => true }
-    ih = h.insensitive :underscore => true
+    ih = h.insensitive
     assert ih[:a_key_with_spaces]
-    assert ih.underscore?
 
     # FIXME: from README
     ih = InsensitiveHash[ h ]
-    ih.underscore = true
     assert ih[:a_key_with_spaces]
-    assert ih.underscore?
 
     # :safe
     ih = {}.insensitive
@@ -176,17 +183,9 @@ class TestInsensitiveHash < Test::Unit::TestCase
       assert_keys [:a, 'hello world', :b], ih2.keys
       assert ih2.has_key?('B'), 'correctly merged another hash'
 
-      assert_nil ih[:hello_world]
-      assert_nil ih2[:hello_world]
-
-      ih.underscore = true
       assert_equal 2, ih[:hello_world]
       assert_equal 2, ih.send(method, :b => 2)[:hello_world]
 
-      ih.underscore = false
-      assert_nil ih[:hello_world]
-      assert_nil ih.send(method, :b => 2)[:hello_world]
-
       ih.default = 10
       assert_equal 10, ih.send(method, :b => 2)[:anything]
 
@@ -232,7 +231,6 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_equal 1, ih.length
 
     ih = InsensitiveHash.new
-    ih.underscore = true
     ih.merge!(:hello_world => 1, 'hello world' =>2)
     unless eight?
       assert_equal 2, ih.values.first
@@ -244,13 +242,9 @@ class TestInsensitiveHash < Test::Unit::TestCase
   def test_merge_clash
     ih = InsensitiveHash.new
     ih2 = InsensitiveHash.new
-    ih2.underscore = true
 
     sih = InsensitiveHash.new
     sih.safe = true
-    sih2 = InsensitiveHash.new
-    sih2.safe = true
-    sih2.underscore = true
 
     [:merge, :merge!, :update, :update!].each do |method|
       # No problem
@@ -259,18 +253,15 @@ class TestInsensitiveHash < Test::Unit::TestCase
         h.send(method, { 'a' => 1, 'A' => 1 })
       end
 
-      [sih, sih2].each do |h|
-        assert_raise(InsensitiveHash::KeyClashError) {
-          h.send(method, { :a => 1, :A => 1, 'A' => 1})
-        }
-        assert_raise(InsensitiveHash::KeyClashError) {
-          h.send(method, { 'a' => 1, 'A' => 1 })
-        }
-      end
+      assert_raise(InsensitiveHash::KeyClashError) {
+        sih.send(method, { :a => 1, :A => 1, 'A' => 1})
+      }
+      assert_raise(InsensitiveHash::KeyClashError) {
+        sih.send(method, { 'a' => 1, 'A' => 1 })
+      }
 
-      sih.send(method, { :hello_world => 1, 'hello world' => 2})
       assert_raise(InsensitiveHash::KeyClashError) {
-        sih2.send(method, { :hello_world => 1, 'hello world' => 2})
+        sih.send(method, { :hello_world => 1, 'hello world' => 2})
       }
       ih2.send(method, { :hello_world => 1, 'hello world' => 2})
     end
@@ -370,6 +361,30 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_equal :ok, h.default(:right)
   end
 
+  def test_default_proc_patch
+    h = InsensitiveHash.new { |h, k| k }
+    assert_equal 1, h[1]
+    assert_equal 2, h[2]
+
+    h = InsensitiveHash.new { |h, k| h[k] = [] }
+    h[:abc] << 1
+    h[:abc] << 2
+    h[:abc] << 3
+    assert_equal [1, 2, 3], h[:abc]
+
+    h = InsensitiveHash.new { |h, k| h[k] = {} }
+    h[:abc][:def] = 1
+    h[:abc][:ghi] = { :xyz => true }
+    assert_equal 1, h[:abc][:def]
+    assert_equal true, h[:abc][:ghi][:xyz]
+    assert_equal nil, h[:abc][:ghi][:XYZ] # This shouldn't work anymore from 0.3.0
+
+    h = InsensitiveHash.new
+    h[:abc] = arr = [1, 2, 3]
+    arr << 4
+    assert_equal [1, 2, 3, 4], h[:ABC]
+  end
+
   def test_delete_if
     # FIXME: Test passes, but key_map not updated
     h = InsensitiveHash[ :a => 100, :tmp_a => 200, :c => 300 ]
@@ -427,26 +442,6 @@ class TestInsensitiveHash < Test::Unit::TestCase
     h.replace(Hash.new { |h, k| h[k] = :default })
     assert_equal :default, h[:anything]
     assert_equal [:anything], h.keys
-
-    # underscore property of self
-    assert !h.underscore?
-    h.replace(InsensitiveHash['hello world' => 1].tap { |ih| ih.underscore = true })
-    assert h.underscore?
-    assert_equal 1, h[:hello_world]
-
-    # TODO: FIXME
-    # underscore property of other
-    h = InsensitiveHash.new
-    oh = InsensitiveHash[ 'hello world' => 1 ]
-    oh.underscore = true
-    assert !h.underscore?
-    h.replace(oh)
-    assert h.underscore?
-
-    oh.underscore = false
-    oh[:hello_world => 2]
-    h.replace(oh)
-    assert !h.underscore?
   end
 
   def test_rassoc
@@ -480,121 +475,28 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_raise(eight? ? IndexError : KeyError) { h.fetch('D') }
   end
 
-  def test_underscore
-    h = InsensitiveHash[{'Key with spaces' => 1}]
-
-    assert_equal 1, h['key with spaces']
-    assert_nil      h[:key_with_spaces]
-
-    test_keys = [
-      :KEY_WITH_SPACES,
-      :Key_with_spaces,
-      :key_with_spaces,
-      'key with_spaces',
-      'KEY_WITH spaces'
-    ]
-
-    10.times do
-      assert_raise(ArgumentError) { h.underscore = 'wat' }
-      assert !h.underscore?
-      h.underscore = true
-      assert h.underscore?
-
-      
-      test_keys.each do |k|
-        assert_equal 1, h[k]
-      end
-      assert_equal ['Key with spaces'], h.keys
-
-      h.underscore = false
-      assert !h.underscore?
-      assert_equal 1, h['KEY WITH SPACES']
-      test_keys.each do |k|
-        assert_nil h[k]
-      end
-      assert_equal ['Key with spaces'], h.keys
-    end
-
-    h.underscore = true
-    test_keys.each do |tk|
-      h[tk] = 1
-    end
-
-    assert_equal [test_keys.last], h.keys
-  end
-
   def test_underscore_inheritance
-    h = InsensitiveHash[
+    h = 
       {
         'Key with spaces' => {
           'Another key with spaces' => 1
         },
         'Key 2 with spaces' =>
-          InsensitiveHash['Yet another key with spaces' => 2].tap { |ih| ih.underscore = true },
+          InsensitiveHash['Yet another key with spaces' => 2],
         'Key 3 with spaces' =>
           InsensitiveHash['Yet another key with spaces' => 3]
-      }
-    ]
+      }.insensitive
 
     assert_equal 1,     h['key with spaces']['another key with spaces']
-    assert_equal false, h['key with spaces'].underscore?
-    assert_nil          h['key with spaces'][:another_key_with_spaces]
-    assert_nil          h[:key_with_spaces]
 
     assert_equal 2, h['key 2 with spaces']['yet another key with spaces']
     assert_equal 2, h['key 2 with spaces'][:yet_another_key_with_spaces]
-    assert_nil      h[:key_2_with_spaces]
 
     assert_equal 3, h['key 3 with spaces']['yet another key with spaces']
-    assert_nil      h['key 3 with spaces'][:yet_another_key_with_spaces]
-    assert_nil      h[:key_3_with_spaces]
 
-    h.underscore = true
-    assert_equal true, h[:key_with_spaces].underscore?
     assert_equal 1,    h[:key_with_spaces][:another_key_with_spaces]
-    assert_equal true, h[:key_2_with_spaces].underscore?
     assert_equal 2,    h[:key_2_with_spaces][:yet_another_key_with_spaces]
-    assert_equal true, h[:key_3_with_spaces].underscore?
     assert_equal 3,    h[:key_3_with_spaces][:yet_another_key_with_spaces]
-
-    h.underscore = false
-    assert_nil h[:key_with_spaces]
-    assert_nil h[:key_2_with_spaces]
-    assert_nil h[:key_3_with_spaces]
-
-    assert_equal false, h.underscore?
-    assert_equal true,  h['key 2 with spaces'].underscore?
-    assert_equal true,  h['key 3 with spaces'].underscore?
-  end
-
-  def test_underscore_clash
-    h = InsensitiveHash.new
-    h.safe = true
-
-    h['hello world'] = 1
-    h['HELLO_world'] = 2
-    assert_equal 1, h['HELLO WORLD']
-    assert_equal 2, h['HELLO_WORLD']
-    assert_equal ['hello world', 'HELLO_world'], h.keys unless eight? # Not order-preserving
-
-    assert_raise(InsensitiveHash::KeyClashError) { h.underscore = true }
-    h.delete('hello world')
-    h.underscore = true
-
-    assert_equal ['HELLO_world'], h.keys
-    assert_equal 2, h['HELLO WORLD']
-    assert_equal 2, h[:HELLO_WORLD]
-  end
-
-  def test_unset_underscore
-    h = InsensitiveHash.new
-    h.underscore = true
-    h[:hello_world] = 1
-    h.underscore = false
-    h['hello world'] = 2
-
-    assert_keys  [:hello_world, 'hello world'], h.keys
-    assert_equal 2, h['Hello World']
   end
 
   def test_constructor_default

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: insensitive_hash
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-12 00:00:00.000000000 Z
+date: 2012-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit