insensitive_hash 0.2.1 → 0.2.2

data/CHANGELOG.markdown

@@ -1,3 +1,9 @@
+### 0.2.2 / 2012/02/13
+* :underscore option added
+* `Insensitive::KeyClashError` added for safer operations
+* Bug fix: Preserve default/default_proc on merge/replace/insensitive
+* Subtle behavioral change in `Insensitive#replace` when called with an ordinary Hash
+
 ### 0.2.1 / 2012/02/10
 * Bug fix: Insensitive `fetch`
 

data/README.markdown

@@ -1,12 +1,15 @@
-# insensitive_hash
+insensitive_hash
+================
 Hash with case-insensitive, Symbol/String-indifferent key access.
 
-## Installation
+Installation
+------------
 ```
 gem install insensitive_hash
 ```
 
-## Examples
+Examples
+--------
 
 ### Instantiation
 ```ruby
@@ -69,6 +72,20 @@ db['Development']['ADAPTER']
 db[:production][:adapter]
 ```
 
+### Replacing spaces in String keys to underscores
+```ruby
+h = { 'A key with spaces' => true }
+
+ih = h.insensitive :underscore => true
+ih[:a_key_with_spaces]  # true
+
+# Or,
+ih = InsensitiveHash[ h ]
+ih.underscore = true
+ih.underscore?          # true
+ih[:a_key_with_spaces]  # true
+```
+
 ## Contributing to insensitive_hash
  
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet

data/lib/insensitive_hash.rb

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

data/lib/insensitive_hash/insensitive_hash.rb

@@ -1,5 +1,6 @@
 class InsensitiveHash < Hash
-  attr_reader :key_map
+  class KeyClashError < Exception
+  end
 
   def initialize default = nil, &block
     if block_given?
@@ -8,7 +9,31 @@ class InsensitiveHash < Hash
       super
     end
 
-    @key_map = {}
+    @key_map    = {}
+    @underscore = 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
   
   # Returns a normal, sensitive Hash
@@ -36,17 +61,15 @@ class InsensitiveHash < Hash
   end
 
   def []= key, value
-    ekey = encode key
-    if @key_map.has_key? ekey
-      delete @key_map[ekey]
-    end
-
-    @key_map[encode key] = key
-    super(lookup_key(key), InsensitiveHash.wrap(value))
+    delete key
+    ekey = encode key, @underscore
+    @key_map[ekey] = key
+    super key, wrap(value, underscore?)
   end
   alias store []=
 
   def merge! other_hash
+    detect_clash other_hash, underscore?
     other_hash.each do |key, value|
       self[key] = value
     end
@@ -55,7 +78,8 @@ class InsensitiveHash < Hash
   alias update! merge!
 
   def merge other_hash
-    InsensitiveHash[self].tap do |ih|
+    InsensitiveHash.new.tap do |ih|
+      ih.replace self
       ih.merge! other_hash
     end
   end
@@ -71,6 +95,16 @@ class InsensitiveHash < Hash
   end
 
   def replace other
+    # TODO
+    # What is the correct behavior of replace when the other hash is not an InsensitiveHash?
+    # underscore property precedence: other => self (FIXME)
+    us = other.respond_to?(:underscore?) ? other.underscore? : self.underscore?
+    detect_clash other, us
+
+    self.default      = other.default
+    self.default_proc = other.default_proc if other.default_proc
+    self.underscore   = us
+
     clear
     other.each do |k, v|
       self[k] = v
@@ -93,19 +127,21 @@ class InsensitiveHash < Hash
   end
 
 private
-  def self.wrap value
+  def wrap value, us
     case value
+    when InsensitiveHash
+      value.tap { |ih| ih.underscore = us || ih.underscore? }
     when Hash
-      value.class == InsensitiveHash ? value : InsensitiveHash[value]
+      InsensitiveHash[value].tap { |ih| ih.underscore = us }
     when Array
-      value.map { |v| InsensitiveHash.wrap v }
+      value.map { |v| wrap v, us }
     else
       value
     end
   end
 
   def lookup_key key, delete = false
-    ekey = encode key
+    ekey = encode key, @underscore
     if @key_map.has_key?(ekey)
       delete ? @key_map.delete(ekey) : @key_map[ekey]
     else
@@ -113,15 +149,24 @@ private
     end
   end
 
-  def encode key
+  def encode key, us
     case key
-    when String
-      key.downcase
-    when Symbol
-      key.to_s.downcase
+    when String, Symbol
+      key = key.to_s.downcase
+      if us
+        key.gsub(' ', '_')
+      else
+        key
+      end
     else
       key
     end
   end
+
+  def detect_clash hash, us
+    hash.keys.map { |k| encode k, us }.tap { |ekeys|
+      raise KeyClashError.new("Key clash detected") if ekeys != ekeys.uniq
+    }
+  end
 end
 

data/lib/insensitive_hash/version.rb

@@ -1,3 +1,3 @@
 class InsensitiveHash < Hash
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/test/test_insensitive_hash.rb

@@ -73,6 +73,60 @@ class TestInsensitiveHash < Test::Unit::TestCase
         end
       end
     end
+
+    # 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|
+      hash.default = d
+      assert_equal d, hash.insensitive.insensitive.insensitive[:anything]
+    end
+
+    # Preserving default_proc
+    hash2 = {}
+    hash2.replace hash
+    hash2.default_proc = proc { |h, k| h[k] = :default }
+
+    ihash2 = hash2.insensitive.insensitive.insensitive
+    assert !ihash2.has_key?(:anything)
+    assert_equal :default, ihash2[:anything]
+    assert ihash2.has_key?(:anything)
+
+    # 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 }
+
+    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, 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
+    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?
   end
 
   def test_delete
@@ -88,13 +142,36 @@ class TestInsensitiveHash < Test::Unit::TestCase
 
   def test_merge
     [:merge, :update].each do |method|
-      ih = InsensitiveHash[:a => 1]
+      ih = InsensitiveHash[:a => 1, 'hello world' => 2]
       ih2 = ih.send(method, :b => 2)
 
-      assert_equal [:a], ih.keys
-      assert_equal [:a, :b], ih2.keys
+      assert_equal [:a, 'hello world'], ih.keys
+      assert_equal [: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]
+
+      ih.default = nil
+      assert_nil ih.send(method, :b => 2)[:anything]
+
+      ih.default_proc = proc { |h, k| h[k] = :default }
+      mh = ih.send(method, :b => 2)
+      assert       !mh.has_key?(:anything)
+      assert_equal :default, mh[:anything]
+      assert        mh.has_key?(:anything)
+
       ih2.delete 'b'
       assert ih2.has_key?('B') == false
     end
@@ -114,6 +191,32 @@ class TestInsensitiveHash < Test::Unit::TestCase
     end
   end
 
+  def test_merge_clash
+    ih = InsensitiveHash.new
+    ih2 = InsensitiveHash.new
+    ih2.underscore = true
+
+    [:merge, :merge!, :update, :update!].each do |method|
+      [ih, ih2].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
+
+      ih.send(method, { :hello_world => 1, 'hello world' => 2})
+      assert_raise(InsensitiveHash::KeyClashError) {
+        ih2.send(method, { :hello_world => 1, 'hello world' => 2})
+      }
+    end
+
+    assert_raise(InsensitiveHash::KeyClashError) {
+      ih.merge({ :a => 1, :A => 1, 'A' => 1})
+    }
+  end
+
   def test_assoc
     h = InsensitiveHash[{
       "colors"  => ["red", "blue", "green"],
@@ -248,6 +351,41 @@ class TestInsensitiveHash < Test::Unit::TestCase
 
     assert !h.has_key?('A')
     assert h.has_key?('B')
+
+    # Default value
+    h.replace(Hash.new(5))
+    assert_equal 5, h[:anything]
+    assert_equal [], h.keys
+
+    # Default proc
+    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]
+
+    h = InsensitiveHash.new
+    assert_raise(InsensitiveHash::KeyClashError) {
+      h.replace({ 'a' => 1, :A => 2 })
+    }
+
+    # 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
@@ -278,5 +416,120 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_equal 3, h.fetch(:c) { 3 }
     assert_raise(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[
+      {
+        'Key with spaces' => {
+          'Another key with spaces' => 1
+        },
+        'Key 2 with spaces' =>
+          InsensitiveHash['Yet another key with spaces' => 2].tap { |ih| ih.underscore = true },
+        'Key 3 with spaces' =>
+          InsensitiveHash['Yet another key with spaces' => 3]
+      }
+    ]
+
+    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['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
+
+    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_equal [:hello_world, 'hello world'], h.keys
+    assert_equal 2, h['Hello World']
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: insensitive_hash
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-10 00:00:00.000000000 Z
+date: 2012-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
-  requirement: &2152981220 !ruby/object:Gem::Requirement
+  requirement: &2152875840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *2152981220
+  version_requirements: *2152875840
 description: Hash with case-insensitive, Symbol/String-indifferent key access
 email:
 - junegunn.c@gmail.com