insensitive_hash 0.1.0 → 0.2.0

data/CHANGELOG.markdown

@@ -1,3 +1,8 @@
+### 0.2.0 / 2012/02/01
+* Major rewrite
+ * Constructor syntaxes have been changed to match those of standard Hash (not backward-compatible)
+ * (Almost) Complete implementation of standard Hash spec.
+
 ### 0.1.0 / 2011/12/20
 * Can opt-out of monkey-patching Hash with `require 'insensitive_hash/minimal'`
 

data/README.markdown

@@ -13,17 +13,22 @@ gem install insensitive_hash
 require 'insensitive_hash'
 
 # Monkey-patched Hash#insensitive method
-{'abc' => 1, :def => 2}.insensitive
+ih = {'abc' => 1, :def => 2}.insensitive
 
 # Or,
-InsensitiveHash.new(:abc => 1, 'DEF' => 2)
+ih = InsensitiveHash[ :abc => 1, 'DEF' => 2 ]
+ih = InsensitiveHash[ :abc, 1, 'DEF', 2 ]
+
+# Revert to normal Hash
+h = ih.sensitive
+h = ih.to_hash
 ```
 
 If you don't like to have Hash#insensitive method, `require 'insensitive_hash/minimal'`
 
 ### Basic usage
 ```ruby
-ih = InsensitiveHash.new(:abc => 1, 'DEF' => 2)
+ih = InsensitiveHash[:abc => 1, 'DEF' => 2]
 
 # Case-insensitive, Symbol/String-indifferent access.
 ih['Abc']          # 1

data/insensitive_hash.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
+  s.add_development_dependency "test-unit", ">= 2.3.0"
   # s.add_runtime_dependency "rest-client"
 end

data/lib/insensitive_hash.rb

@@ -3,7 +3,7 @@ require 'insensitive_hash/insensitive_hash'
 
 class Hash
   def insensitive
-    InsensitiveHash.new self
+    InsensitiveHash[ self ]
   end
 end
 

data/lib/insensitive_hash/insensitive_hash.rb

@@ -1,36 +1,97 @@
 class InsensitiveHash < Hash
-  def initialize hash = {}
+  attr_reader :key_map
+
+  def initialize default = nil, &block
+    if block_given?
+      super &block
+    else
+      super
+    end
+
     @key_map = {}
+  end
+  
+  # Returns a normal, sensitive Hash
+  # @return [Hash]
+  def to_hash
+    {}.merge self
+  end
+  alias sensitive to_hash
 
-    hash.each do |key, value|
-      self[key] = value
+  def self.[] *init
+    h = Hash[*init]
+    InsensitiveHash.new.tap do |ih|
+      h.each do |key, value|
+        ih[key] = value
+      end
     end
   end
 
-  def [] key
-    super(@key_map[encode key])
+  %w[[] assoc has_key? include? key? member?].each do |symb|
+    class_eval <<-EVAL
+      def #{symb} key
+        super lookup_key(key)
+      end
+    EVAL
   end
 
   def []= key, value
-    delete key
+    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))
+  end
+  alias store []=
+
+  def merge! other_hash
+    other_hash.each do |key, value|
+      self[key] = value
+    end
+    self
+  end
+  alias update! merge!
 
-    super(key, InsensitiveHash.wrap(value))
+  def merge other_hash
+    InsensitiveHash[self].tap do |ih|
+      ih.merge! other_hash
+    end
+  end
+  alias update merge
+
+  def delete key, &block
+    super lookup_key(key, true), &block
+  end
+
+  def clear
+    @key_map.clear
+    super
+  end
+
+  def replace other
+    clear
+    other.each do |k, v|
+      self[k] = v
+    end
   end
 
-  def has_key? key
-    super @key_map[encode key]
+  def shift
+    super.tap do |ret|
+      @key_map.delete_if { |k, v| v == ret.first }
+    end
   end
 
-  def delete key
-    super @key_map[encode key]
+  def values_at *keys
+    keys.map { |k| self[k] }
   end
 
 private
   def self.wrap value
     case value
     when Hash
-      value.class == InsensitiveHash ? value : InsensitiveHash.new(value)
+      value.class == InsensitiveHash ? value : InsensitiveHash[value]
     when Array
       value.map { |v| InsensitiveHash.wrap v }
     else
@@ -38,6 +99,15 @@ private
     end
   end
 
+  def lookup_key key, delete = false
+    ekey = encode key
+    if @key_map.has_key?(ekey)
+      delete ? @key_map.delete(ekey) : @key_map[ekey]
+    else
+      key
+    end
+  end
+
   def encode key
     case key
     when String

data/lib/insensitive_hash/version.rb

@@ -1,3 +1,3 @@
 class InsensitiveHash < Hash
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/test_insensitive_hash.rb

@@ -1,41 +1,21 @@
 require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :development)
 require 'test/unit'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'insensitive_hash/minimal'
 
 class TestInsensitiveHash < Test::Unit::TestCase
-  def test_from_hash
-    hash = {
-      'a' => 1,
-      'B' => 2,
-      :c  => { :D => [ { 'e' => 3 } ] }
-    }
-
-    assert_raise(NoMethodError) {
-      hash.insensitive
-    }
-
-    require 'insensitive_hash'
-    [hash.insensitive, InsensitiveHash.new(hash)].each do |ih|
-      assert       ih.is_a?(Hash)
-      assert_equal InsensitiveHash, ih.class
-      ['c', 'C', :c, :C].each do |c|
-        assert_equal InsensitiveHash, ih[c].class
-
-        ['d', 'D', :d, :D].each do |d|
-          assert_equal InsensitiveHash, ih[c][d].first.class
-        end
-      end
-    end
-  end
-
   def test_has_key_set
     ih = InsensitiveHash.new
     ih['a'] = 1
-    ih['A'] = 2
+    ih.store 'A', 2
 
     ['a', 'A', :a, :A].each do |a|
       assert       ih.has_key?(a)
+      assert       ih.key?(a)
+      assert       ih.include?(a)
+      assert       ih.member?(a)
       assert_equal 2, ih[a]
     end
 
@@ -43,6 +23,7 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_equal [2], ih.values
 
     ih[:A] = 4
+    assert_equal ih.keys, [:A]
     assert_equal [:A], ih.keys
     assert_equal [4], ih.values
 
@@ -50,6 +31,7 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert          ih.keys.include?(:A)
     assert          ih.keys.include?(:b)
     assert_equal 2, ih.keys.length
+    assert_equal({ :c => 5 }, ih['B'])
     assert_equal 5, ih['B']['C']
 
     ih['c'] = [ { 'x' => 1 }, { :y => 2 } ]
@@ -68,12 +50,227 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_equal 50, ih[5]
   end
 
+  def test_from_hash
+    hash = {
+      'a' => 1,
+      'B' => 2,
+      :c  => { :D => [ { 'e' => 3 } ] }
+    }
+
+    assert_raise(NoMethodError) {
+      hash.insensitive
+    }
+
+    require 'insensitive_hash'
+    [hash.insensitive, InsensitiveHash[hash]].each do |ih|
+      assert       ih.is_a?(Hash)
+      assert_equal InsensitiveHash, ih.class
+      ['c', 'C', :c, :C].each do |c|
+        assert_equal InsensitiveHash, ih[c].class
+
+        ['d', 'D', :d, :D].each do |d|
+          assert_equal InsensitiveHash, ih[c][d].first.class
+        end
+      end
+    end
+  end
+
   def test_delete
-    ih = InsensitiveHash.new(:a => 1)
+    ih = InsensitiveHash[:a => 1]
     assert_equal [:a], ih.keys
     assert_equal [1], ih.values
 
+    assert_equal nil, ih.delete('B')
     assert_equal 1, ih.delete('A')
+    assert_equal :notfound, ih.delete('A') { |a| :notfound }
     assert_equal [], ih.keys
   end
+
+  def test_merge
+    [:merge, :update].each do |method|
+      ih = InsensitiveHash[:a => 1]
+      ih2 = ih.send(method, :b => 2)
+
+      assert_equal [:a], ih.keys
+      assert_equal [:a, :b], ih2.keys
+      assert ih2.has_key?('B'), 'correctly merged another hash'
+
+      ih2.delete 'b'
+      assert ih2.has_key?('B') == false
+    end
+  end
+
+  def test_merge!
+    [:merge!, :update!].each do |method|
+      ih = InsensitiveHash[:a => 1]
+      ih2 = ih.send(method, :b => 2)
+
+      assert_equal [:a, :b], ih.keys
+      assert_equal [:a, :b], ih2.keys
+      assert ih2.has_key?('B'), 'correctly merged another hash'
+
+      ih2.delete 'b'
+      assert ih2.has_key?('B') == false
+    end
+  end
+
+  def test_assoc
+    h = InsensitiveHash[{
+      "colors"  => ["red", "blue", "green"],
+      :Letters => ["a", "b", "c" ]
+    }]
+    assert_equal [:Letters, ["a", "b", "c"]], h.assoc("letters")
+    assert_equal ["colors", ["red", "blue", "green"]], h.assoc(:COLORS)
+  end
+
+  def test_clear_empty?
+    h = InsensitiveHash[:a, 1]
+    h.clear
+    assert_equal [], h.keys
+    assert h.empty?
+  end
+
+  def test_to_hash
+    h = InsensitiveHash[:a, 1, :b, {:c => 2}]
+    assert_equal 1, h[:A]
+    assert_equal 2, h['B']['C']
+
+    h = h.to_hash
+    assert_equal Hash, h.class
+    assert_equal nil, h[:A]
+    assert_equal 1, h[:a]
+    assert_equal 2, h[:b][:c]
+    pend("TBD: Recursive conversion") do
+      assert_equal nil, h[:b]['C']
+    end
+  end
+
+  def test_compare_by_identity
+    pend 'Not Implemented'
+
+    key = 'a'
+    key2 = 'a'.clone
+    h = InsensitiveHash.new
+    h[key] = 1
+    h[:b] = 2
+
+    assert !h.compare_by_identity?
+
+    assert_equal 1, h['A']
+    assert_equal 2, h[:b]
+    h.compare_by_identity
+
+    assert h.compare_by_identity?
+
+    assert_equal nil, h[key2]
+    assert_equal nil, h[key]
+    assert_equal 2,   h[:B]
+
+    h[key] = 3
+    assert_not_equal 'a'.object_id, key.object_id
+    assert_equal nil, h[key2]
+    assert_equal 3,   h[key]
+  end
+
+  def test_initializer
+    # Hash
+    h = InsensitiveHash[ { :a => 1 } ]
+    assert_equal 1, h['A']
+    assert_equal [:a], h.keys
+    assert_equal [1], h.values
+
+    # Pairs
+    h = InsensitiveHash[ 'a', 2, 3, 4 ]
+    assert_equal 2, h[:a]
+
+    # Wrong number of arguments
+    assert_raise(ArgumentError) { h = InsensitiveHash[ 'a', 2, 3 ] }
+  end
+
+  def test_default
+    h = InsensitiveHash.new
+    assert_nil h.default
+
+    h = InsensitiveHash.new 'a'
+    assert_equal 'a', h.default
+    assert_equal 'a', h[:not_there]
+
+    h = InsensitiveHash.new { |h, k| h[k] = k == :right ? :ok : nil }
+    assert_equal nil, h.default
+    assert_equal nil, h.default(:wrong)
+    assert_equal :ok, h.default(:right)
+  end
+
+  def test_delete_if
+    # FIXME: Test passes, but key_map not updated
+    h = InsensitiveHash[ :a => 100, :tmp_a => 200, :c => 300 ]
+    h.delete_if.each { |k, v| k == :tmp_a }
+    assert_equal [:a, :c], h.keys
+  end
+
+  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 { |e| true }
+    set.each { |s| assert !h.has_key?(s) }
+  end
+
+  def test_nil
+    h = InsensitiveHash.new(1)
+    h[nil] = 2
+    assert h.has_key?(nil)
+    assert !h.has_key?(:not_there)
+    assert_equal 1, h[:not_there]
+    assert_equal 2, h[nil]
+
+    h = InsensitiveHash[ nil => 1 ]
+    assert_equal :notfound, h.delete('a') { :notfound }
+    assert_equal 1, h.delete(nil) { :notfound }
+  end
+
+  def test_each
+    h = InsensitiveHash[{ :a => 1, :b => 2, :c => 3}]
+    assert_equal 3, h.each.count
+  end
+
+  def test_fetch
+    h = InsensitiveHash[{ :a => 1, :b => 2, :c => 3}]
+    assert_raise(KeyError) { h.fetch('D') }
+  end
+
+  def test_has_value
+    h = InsensitiveHash[{ :a => 1, :b => 2, :c => 3}]
+    assert h.value?(3)
+  end
+
+  def test_replace
+    h = InsensitiveHash[:a, 1]
+    assert h.has_key?('A')
+
+    h.replace({ :b => 2 })
+
+    assert !h.has_key?('A')
+    assert h.has_key?('B')
+  end
+
+  def test_rassoc
+    a = InsensitiveHash[{1=> "one", 2 => "two", 3 => "three", "ii" => "two"}]
+    assert_equal [2, "two"], a.rassoc("two")
+    assert_nil a.rassoc("four")
+  end
+
+  def test_shift
+    h = InsensitiveHash[{:a => 1, :b => 2}]
+    assert_equal [:a, 1], h.shift
+    assert !h.has_key?('A')
+    assert h.has_key?('B')
+  end
+
+  def test_values_at
+    h = InsensitiveHash[{:a => 1, :b => 2}]
+    assert_equal [2, 1], h.values_at('B', :A)
+  end
 end
+

metadata

@@ -1,66 +1,70 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: insensitive_hash
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.2.0
   prerelease: 
-  version: 0.1.0
 platform: ruby
-authors: 
-  - Junegunn Choi
+authors:
+- Junegunn Choi
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-12-20 00:00:00 Z
-dependencies: []
-
+date: 2012-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &2156362640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156362640
 description: Hash with case-insensitive, Symbol/String-indifferent key access
-email: 
-  - junegunn.c@gmail.com
+email:
+- junegunn.c@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - .gitignore
-  - CHANGELOG.markdown
-  - Gemfile
-  - LICENSE.txt
-  - README.markdown
-  - Rakefile
-  - insensitive_hash.gemspec
-  - lib/insensitive_hash.rb
-  - lib/insensitive_hash/insensitive_hash.rb
-  - lib/insensitive_hash/minimal.rb
-  - lib/insensitive_hash/version.rb
-  - test/test_insensitive_hash.rb
+files:
+- .gitignore
+- CHANGELOG.markdown
+- Gemfile
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- insensitive_hash.gemspec
+- lib/insensitive_hash.rb
+- lib/insensitive_hash/insensitive_hash.rb
+- lib/insensitive_hash/minimal.rb
+- lib/insensitive_hash/version.rb
+- test/test_insensitive_hash.rb
 homepage: https://github.com/junegunn/insensitive_hash
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: insensitive_hash
-rubygems_version: 1.8.11
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Case-insensitive Ruby Hash
-test_files: 
-  - test/test_insensitive_hash.rb
+test_files:
+- test/test_insensitive_hash.rb
+has_rdoc: