cicphash 1.0.0 → 1.1.0

data/cicphash.rb

@@ -1,288 +1,364 @@
-# Copyright (c) 2007 Jeremy Evans
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-# Case Insensitive, Case Preserving Hash
-#
-# CICPHash has the exact same interface as Hash, but is case insensitive
-# and case preserving.  Any value can be used as a key.  However, you
-# cannot have two keys in the same CICPHash that would be the same if when
-# converted to strings would be equal or differing only in case.
-#
-# For example, all of the following keys would be considered equalivalent:
-# 'ab', 'Ab', 'AB', 'aB', :ab, :Ab, :AB, :aB, ['A', :b], [nil, :A, nil, 'b'].
-#
-# CICPHash uses a last match wins policy.  If an key-value pair is added to
-# a CICPHash and a case insensitive variant of the key is already in the hash
-# the instance of the key in the hash becomes the same the most recently added
-# key (and obviously the value is updated to reflect the new value).
-#
-# You can change the rules determining which keys are equal by modifying the
-# private convert_key method.  By default, it is set to key.to_s.downcase.
-# This method should produce the same output for any keys that you want to
-# consider equal.  For example, if you want :a and :A to be equal but :a to be
-# different than "a", maybe key.inspect.downcase would work for you.
-class CICPHash
-  include Enumerable
-  
-  def self.[](*items)
-    if items.length % 2 != 0
-      if items.length == 1 && items.first.is_a?(Hash)
-        new.merge(items.first)
-      else
-        raise ArgumentError, "odd number of arguments for CICPHash"
-      end
-    else
-      hash = new
-      loop do
-        break if items.length == 0
-        key = items.shift
-        value = items.shift
-        hash[key] = value
-      end
-      hash
-    end
-  end
-  
-  def initialize(*default, &block)
-    if default.length > 1 || default.length == 1 && block_given?
-      raise ArgumentError, "wrong number of arguments"
-    end
-    @name_hash = {}
-    @hash = {}
-    @default = default.first unless block_given?
-    @default_proc = Proc.new(&block) if block_given?
-  end
-  
-  def ==(hash)
-    to_hash == hash.to_hash
-  end
-  
-  def [](key)
-    new_key = convert_key(key)
-    if @hash.include?(new_key)
-      @hash[new_key]
-    elsif @default_proc
-      @default_proc.call(self, key)
-    else
-      @default
-    end
-  end
-
-  def []=(key, value)
-    new_key = convert_key(key)
-    @name_hash[new_key] = key
-    @hash[new_key] = value
-  end
-  alias store :[]=
-  
-  def clear
-    @name_hash.clear
-    @hash.clear
-  end
-  
-  def default
-    @default
-  end
-  
-  def default=(value)
-    @default = value
-  end
-  
-  def default_proc
-    @default_proc
-  end
-  
-  def delete(key)
-    new_key = convert_key(key)
-    @name_hash.delete(new_key)
-    @hash.delete(new_key)
-  end
-  
-  def delete_if(&block)
-    hash = CICPHash.new
-    each{|key, value| block.call(key, value) ? delete(key) : (hash[key] = value)}
-    hash
-  end
-  
-  def each
-    @hash.each{|key, value| yield @name_hash[key], value }
-  end
-  alias each_pair each
-  
-  def each_key
-    @hash.each_key{|key| yield @name_hash[key] }
-  end
-  
-  def each_value
-    @hash.each_value{|value| yield value }
-  end
-  
-  def empty?
-    @hash.empty?
-  end
-  
-  def fetch(key, *default, &block)
-    raise ArgumentError, "wrong number of arguments (#{default.length+1} for 2)" if default.length > 1
-    if include?(key)
-      self[key]
-    elsif block_given?
-      block.call(key)
-    elsif default.length == 1
-      default.first
-    else
-      raise IndexError, "key not found"
-    end
-  end
-  
-  def has_key?(key)
-    @hash.has_key?(convert_key(key))
-  end
-  alias include? has_key?
-  alias key? has_key?
-  alias member? has_key?
-  
-  def has_value?(value)
-    @hash.has_value?(value)
-  end
-  alias value? has_value?
-  
-  def index(value)
-    @name_hash[@hash.index(value)]
-  end
-  
-  def inspect
-    to_hash.inspect
-  end
-  
-  def invert
-    hash = CICPHash.new
-    each{|key, value| hash[value] = key}
-    hash
-  end
-  
-  def keys
-    @name_hash.values
-  end
-  
-  def length
-    @hash.length
-  end
-  alias size length
-  
-  def merge(hash, &block)
-    new_hash = CICPHash.new.merge!(self)
-    hash.each do |key, value| 
-      new_hash[key] = if block_given? && new_hash.include?(key)
-        block.call(key, new_hash[key], hash[key])
-      else 
-        value
-      end
-    end
-    new_hash
-  end
-  
-  def rehash
-    @name_hash.keys.each do |key|
-      new_key = @name_hash[key].to_s.downcase 
-      if new_key != key
-        @name_hash[new_key] = @name_hash.delete(key)
-        @hash[new_key] = @hash.delete(key)
-      end
-    end
-    self
-  end
-  
-  def reject(&block)
-    hash = CICPHash.new
-    each{|key, value| hash[key] = self[key] unless block.call(key, value)}
-    hash
-  end
-  
-  def reject!(&block)
-    hash = CICPHash.new
-    changes = false
-    each{|key, value| block.call(key, value) ? (changes = true; delete(key)) : (hash[key] = value)}
-    changes ? hash : nil
-  end
-    
-  def replace(hash)
-    clear
-    update(hash)
-  end
-  
-  def select(&block)
-    array = []
-    each{|key, value| array << [key, value] if block.call(key, value)}
-    array
-  end
-  
-  def shift
-    return nil if @name_hash.length == 0
-    key, value = @name_hash.shift
-    [value, @hash.delete(key)]
-  end
-  
-  def sort(&block)
-    block_given? ? to_a.sort(&block) : to_a.sort
-  end
-  
-  def to_a
-    array = []
-    each{|key, value| array << [key, value]}
-    array
-  end
-  
-  def to_hash
-    hash = {}
-    each{|key, value| hash[key] = value}
-    hash
-  end
-  
-  def to_s
-    to_a.join
-  end
-  
-  def update(hash, &block)
-    hash.each do |key, value| 
-      self[key] = if block_given? && include?(key)
-        block.call(key, self[key], hash[key])
-      else 
-        value
-      end
-    end
-    self
-  end
-  alias merge! update
-  
-  def values
-    @hash.values
-  end
-  
-  def values_at(*keys)
-    keys.collect{|key| self[key]}
-  end
-  alias indexes values_at
-  alias indices values_at
-  
-  private
-    def convert_key(key)
-      key.to_s.downcase
-    end
-end
+# CICPHash is a case insensitive case preserving hash for ruby.
+#
+# * RDoc: http://cicphash.rubyforge.org
+# * Source: http://github.com/jeremyevans/ruby-cicphash
+#
+# Copyright (c) 2007, 2012 Jeremy Evans
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Case Insensitive Case Preserving Hash
+#
+# CICPHash has the exact same interface as Hash, but is case insensitive
+# and case preserving.  Any value can be used as a key.  However, you
+# cannot have two keys in the same CICPHash that would be the same if when
+# converted to strings would be equal or differing only in case.
+#
+# For example, all of the following keys would be considered equalivalent:
+# 'ab', 'Ab', 'AB', 'aB', :ab, :Ab, :AB, :aB
+#
+# CICPHash uses a last match wins policy.  If an key-value pair is added to
+# a CICPHash and a case insensitive variant of the key is already in the hash
+# the instance of the key in the hash becomes the same the most recently added
+# key (and obviously the value is updated to reflect the new value).
+#
+# You can change the rules determining which keys are equal by modifying the
+# private convert_key method.  By default, it is set to key.to_s.downcase.
+# This method should produce the same output for any keys that you want to
+# consider equal.  For example, if you want :a and :A to be equal but :a to be
+# different than "a", maybe key.inspect.downcase would work for you.
+class CICPHash
+  include Enumerable
+  
+  def self.[](*items)
+    if items.length % 2 != 0
+      if items.length == 1 && items.first.is_a?(Hash)
+        new.merge(items.first)
+      else
+        raise ArgumentError, "odd number of arguments for CICPHash"
+      end
+    else
+      hash = new
+      loop do
+        break if items.length == 0
+        key = items.shift
+        value = items.shift
+        hash[key] = value
+      end
+      hash
+    end
+  end
+  
+  def initialize(*default, &block)
+    if default.length > 1 || default.length == 1 && block_given?
+      raise ArgumentError, "wrong number of arguments"
+    end
+    @name_hash = {}
+    @hash = {}
+    @default = default.first unless block_given?
+    @default_proc = Proc.new(&block) if block_given?
+  end
+  
+  def ==(hash)
+    to_hash == hash.to_hash
+  end
+  
+  def [](key)
+    new_key = convert_key(key)
+    if @hash.include?(new_key)
+      @hash[new_key]
+    elsif @default_proc
+      @default_proc.call(self, key)
+    else
+      @default
+    end
+  end
+
+  def []=(key, value)
+    new_key = convert_key(key)
+    @name_hash[new_key] = key
+    @hash[new_key] = value
+  end
+  alias store :[]=
+  
+  def clear
+    @name_hash.clear
+    @hash.clear
+  end
+  
+  def clone
+    s = super
+    s.instance_variable_set(:@hash, @hash.clone)
+    s.instance_variable_set(:@name_hash, @name_hash.clone)
+    s
+  end
+  
+  def default
+    @default
+  end
+  
+  def default=(value)
+    @default = value
+  end
+  
+  def default_proc
+    @default_proc
+  end
+  
+  def delete(key)
+    new_key = convert_key(key)
+    @name_hash.delete(new_key)
+    @hash.delete(new_key)
+  end
+  
+  def delete_if(&block)
+    hash = CICPHash.new
+    each{|key, value| block.call(key, value) ? delete(key) : (hash[key] = value)}
+    hash
+  end
+
+  def dup
+    s = super
+    s.instance_variable_set(:@hash, @hash.dup)
+    s.instance_variable_set(:@name_hash, @name_hash.dup)
+    s
+  end
+  
+  def each
+    @hash.each{|key, value| yield @name_hash[key], value }
+  end
+  alias each_pair each
+  
+  def each_key
+    @hash.each_key{|key| yield @name_hash[key] }
+  end
+  
+  def each_value
+    @hash.each_value{|value| yield value }
+  end
+  
+  def empty?
+    @hash.empty?
+  end
+  
+  def fetch(key, *default, &block)
+    raise ArgumentError, "wrong number of arguments (#{default.length+1} for 2)" if default.length > 1
+    if include?(key)
+      self[key]
+    elsif block_given?
+      block.call(key)
+    elsif default.length == 1
+      default.first
+    else
+      raise IndexError, "key not found"
+    end
+  end
+  
+  def has_key?(key)
+    @hash.has_key?(convert_key(key))
+  end
+  alias include? has_key?
+  alias key? has_key?
+  alias member? has_key?
+  
+  def has_value?(value)
+    @hash.has_value?(value)
+  end
+  alias value? has_value?
+  
+  if RUBY_VERSION >= '1.9'
+    def key(value)
+      @name_hash[@hash.key(value)]
+    end
+    alias index key
+  else
+    def index(value)
+      @name_hash[@hash.index(value)]
+    end
+  end
+  
+  def inspect
+    to_hash.inspect
+  end
+  
+  def invert
+    hash = CICPHash.new
+    each{|key, value| hash[value] = key}
+    hash
+  end
+  
+  def keys
+    @name_hash.values
+  end
+  
+  def length
+    @hash.length
+  end
+  alias size length
+  
+  def merge(hash, &block)
+    new_hash = CICPHash.new.merge!(self)
+    hash.each do |key, value| 
+      new_hash[key] = if block_given? && new_hash.include?(key)
+        block.call(key, new_hash[key], hash[key])
+      else 
+        value
+      end
+    end
+    new_hash
+  end
+  
+  def rehash
+    @name_hash.keys.each do |key|
+      new_key = @name_hash[key].to_s.downcase 
+      if new_key != key
+        @name_hash[new_key] = @name_hash.delete(key)
+        @hash[new_key] = @hash.delete(key)
+      end
+    end
+    self
+  end
+  
+  def reject(&block)
+    hash = CICPHash.new
+    each{|key, value| hash[key] = self[key] unless block.call(key, value)}
+    hash
+  end
+  
+  def reject!(&block)
+    hash = CICPHash.new
+    changes = false
+    each{|key, value| block.call(key, value) ? (changes = true; delete(key)) : (hash[key] = value)}
+    changes ? hash : nil
+  end
+    
+  def replace(hash)
+    clear
+    update(hash)
+  end
+  
+  def select(&block)
+    array = []
+    each{|key, value| array << [key, value] if block.call(key, value)}
+    array
+  end
+  
+  def shift
+    return nil if @name_hash.length == 0
+    key, value = @name_hash.shift
+    [value, @hash.delete(key)]
+  end
+  
+  def sort(&block)
+    block_given? ? to_a.sort(&block) : to_a.sort
+  end
+  
+  def to_a
+    array = []
+    each{|key, value| array << [key, value]}
+    array
+  end
+  
+  def to_hash
+    hash = {}
+    each{|key, value| hash[key] = value}
+    hash
+  end
+  
+  def to_s
+    to_a.join
+  end
+  
+  def update(hash, &block)
+    hash.each do |key, value| 
+      self[key] = if block_given? && include?(key)
+        block.call(key, self[key], hash[key])
+      else 
+        value
+      end
+    end
+    self
+  end
+  alias merge! update
+  
+  def values
+    @hash.values
+  end
+  
+  def values_at(*keys)
+    keys.collect{|key| self[key]}
+  end
+  alias indexes values_at
+  alias indices values_at
+
+  if RUBY_VERSION >= '1.9'
+    def assoc(obj)
+      obj = convert_key(obj)
+      each do |k, v|
+        if convert_key(k) == obj
+          return [k, v]
+        end
+      end
+      nil
+    end
+
+    attr_writer :default_proc
+
+    def flatten(*a)
+      if a.empty?
+        to_a.flatten(1)
+      else
+        to_a.flatten(*a)
+      end
+    end
+
+    def keep_if(&block)
+      to_a.each do |k, v|
+        delete(k) unless yield(k, v)
+      end
+      self
+    end
+
+    def rassoc(obj)
+      each do |k, v|
+        if v == obj
+          return [k, v]
+        end
+      end
+      nil
+    end
+
+    def select!(&block)
+      mod = false
+      to_a.each do |k, v|
+        unless yield(k, v)
+          mod = true
+          delete(k)
+        end
+      end
+      self if mod
+    end
+  end
+  
+  private
+
+  def convert_key(key)
+    key.to_s.downcase
+  end
+end

data/test/test_cicphash.rb

@@ -1,5 +1,6 @@
 #!/usr/local/bin/ruby
 
+$: << File.dirname(File.dirname(File.expand_path(__FILE__)))
 require 'cicphash'
 require 'test/unit'
 
@@ -57,13 +58,11 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal 2, @h[1]
     assert_equal 2, @h[:'1']
     assert_equal 2, @h['1']
-    assert_equal 2, @h[[1]]
     @h['a'] = 3
     assert_equal 3, @h['a']
     assert_equal 3, @h['A']
     assert_equal 3, @h[:a]
     assert_equal 3, @h[:A]
-    assert_equal 3, @h[[:A]]
     @h['AB'] = 5
     assert_equal 5, @h['ab']
     assert_equal 5, @h['AB']
@@ -73,18 +72,10 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal 5, @h[:AB]
     assert_equal 5, @h[:aB]
     assert_equal 5, @h[:Ab]
-    assert_equal 5, @h[[:ab]]
-    @h[[['A'],[:b],[[['cD']]]]] = 6
-    assert_equal 6, @h['abcd']
-    assert_equal 6, @h['ABCD']
-    assert_equal 6, @h[:AbCd]
-    assert_equal 6, @h[:aBcD]
-    assert_equal 6, @h[[[:A],['b'],:C,[[['d']]]]]
     @h.store(7, 8)
     assert_equal 8, @h[7]
     assert_equal 8, @h[:'7']
     assert_equal 8, @h['7']
-    assert_equal 8, @h[[7]]
   end
   
   def test_clear
@@ -150,6 +141,17 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal 0, @fh.length
     assert_equal Hash[], @fh
   end
+
+  def test_dup_and_clone
+    def @h.foo; 1; end
+    h2 = @h.dup
+    h3 = @h.clone
+    h2[1] = 2
+    h3[1] = 2
+    assert_equal CICPHash[], @h
+    assert_raises NoMethodError do h2.foo end
+    assert_equal 1, h3.foo
+  end
   
   def test_each
     i = 0
@@ -205,8 +207,8 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal 6, @h.fetch(2, 3){|k| k*3}
     assert_equal 1, @fh.fetch(:ab)
     assert_equal 2, @fh.fetch(:CD, 3)
-    assert_equal 4, @fh.fetch([3], 3){8}
-    assert_equal 4, @fh.fetch([3], 3){|k| k*3}
+    assert_equal 4, @fh.fetch("3", 3){8}
+    assert_equal 4, @fh.fetch("3", 3){|k| k*3}
     assert_raises(IndexError){CICPHash.new{34}.fetch(1)}
   end
   
@@ -218,7 +220,7 @@ class CICPHashTest < Test::Unit::TestCase
       assert @fh.send(meth,3)
       assert @fh.send(meth,:ab)
       assert @fh.send(meth,'CD')
-      assert @fh.send(meth,[[[3]]])
+      assert @fh.send(meth,'3')
       assert !@fh.send(meth,1)
     end
   end
@@ -303,12 +305,12 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal Hash[:ab,2], @h
     assert_equal Hash['AB',2], @h.update({'AB'=>2})
     assert_equal Hash['AB',2], @h
-    assert_equal Hash[[:a,:B],3,4,5], @h.update([:a,:B]=>3, 4=>5) do |k,ov,nv| 
-      asset_equal [:a,:B], k
+    assert_equal Hash[:aB,3,4,5], @h.update(:aB=>3, 4=>5) do |k,ov,nv| 
+      asset_equal :aB, k
       asset_equal 2, ov
       asset_equal 3, nv
     end
-    assert_equal Hash[[:a,:B],3,4,5], @h
+    assert_equal Hash[:aB,3,4,5], @h
   end
   
   def test_rehash
@@ -340,7 +342,7 @@ class CICPHashTest < Test::Unit::TestCase
   def test_select
     assert_equal [], @h.select{true}
     assert_equal [], @h.select{false}
-    assert_equal [[3,4], ['AB',1], [:cd,2]], @fh.select{true}.sort_by{|x| x.to_s}
+    assert_equal [[3, 4], ["AB", 1], [:cd, 2]], @fh.select{true}.sort_by{|k,v| k.to_s}
     assert_equal [], @fh.select{false}
     assert_equal [[:cd,2]], @fh.select{|k,v| k.is_a?(Symbol)}
     assert_equal [[3,4]], @fh.select{|k,v| v == 4}
@@ -370,12 +372,12 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal [], @h.sort
     assert_equal [], @h.sort{|a,b| a.to_s<=>b.to_s}
     assert_equal [['AB',1], ['CD',4], ['EF',2]], CICPHash['CD',4,'AB',1,'EF',2].sort
-    assert_equal [[3,4], ['AB',1], [:cd,2]], @fh.sort{|a,b| a.to_s<=>b.to_s}
+    assert_equal [[3,4], ['AB',1], [:cd,2]], @fh.sort{|(ak,av),(bk,bv)| ak.to_s<=>bk.to_s}
   end
   
   def test_to_a
     assert_equal [], @h.to_a
-    assert_equal [[3,4], ['AB',1], [:cd,2]], @fh.to_a.sort{|a,b| a.to_s<=>b.to_s}
+    assert_equal [[3,4], ['AB',1], [:cd,2]], @fh.to_a.sort_by{|k,v| k.to_s}
   end
   
   def test_to_hash
@@ -396,6 +398,61 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal [1], @fh.values_at(:ab)
     assert_equal [2, 1], @fh.values_at('CD', :ab)
     assert_equal [2, nil, 1], @fh.values_at('CD', 32, :ab)
-    assert_equal [4, 2, nil, 1], @fh.values_at([[[3]],''], 'CD', 32, :ab)
+    assert_equal [4, 2, nil, 1], @fh.values_at('3', 'CD', 32, :ab)
+  end
+
+  if RUBY_VERSION >= '1.9'
+    def test_assoc
+      assert_equal nil, @h.assoc(1)
+      assert_equal ['AB', 1], @fh.assoc(:Ab)
+      assert_equal [:cd, 2], @fh.assoc('CD')
+      assert_equal nil, @fh.assoc(4)
+      assert_equal [3, 4], @fh.assoc('3')
+    end
+
+    def test_default_proc=
+      @h.default_proc = proc{|h, k| k * 2}
+      assert_equal 'aa', @h['a']
+      @h[:a] = 2
+      assert_equal 2, @h['a']
+    end
+
+    def test_flatten
+      assert_equal [], @h.flatten
+      assert_equal ['AB', 1, :cd, 2, 3, 4], @fh.flatten
+      @fh[:X] = [5, 6]
+      assert_equal ['AB', 1, :cd, 2, 3, 4, :X, [5, 6]], @fh.flatten
+      assert_equal ['AB', 1, :cd, 2, 3, 4, :X, 5, 6], @fh.flatten(2)
+    end
+
+    def test_keep_if
+      assert_equal @h, @h.keep_if{|k, v| true}
+      assert_equal @fh, @fh.keep_if{|k, v| true}
+      assert_equal @h, @fh.dup.keep_if{|k, v| false}
+      assert_equal CICPHash["AB"=>1], @fh.keep_if{|k, v| k == "AB"}
+    end
+
+    def test_key
+      assert_equal nil, @h.index(1)
+      assert_equal 'AB', @fh.index(1)
+      assert_equal :cd, @fh.index(2)
+      assert_equal nil, @fh.index(3)
+      assert_equal 3, @fh.index(4)
+    end
+
+    def test_rassoc
+      assert_equal nil, @h.rassoc(1)
+      assert_equal ['AB', 1], @fh.rassoc(1)
+      assert_equal [:cd, 2], @fh.rassoc(2)
+      assert_equal nil, @fh.rassoc(3)
+      assert_equal [3, 4], @fh.rassoc(4)
+    end
+
+    def test_select!
+      assert_equal nil, @h.select!{|k, v| true}
+      assert_equal nil, @fh.select!{|k, v| true}
+      assert_equal @h, @fh.dup.select!{|k, v| false}
+      assert_equal CICPHash["AB"=>1], @fh.select!{|k, v| k == "AB"}
+    end
   end
 end

metadata

@@ -1,46 +1,47 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
+--- !ruby/object:Gem::Specification
 name: cicphash
-version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2007-08-12 00:00:00 -07:00
-summary: Case Insensitive Cash Preserving Hash
-require_paths: 
-- .
-email: code@jeremyevans.net
-homepage: 
-rubyforge_project: 
-description: 
-autorequire: cicphash
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
-authors: 
+authors:
 - Jeremy Evans
-files: 
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-04 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: code@jeremyevans.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
 - cicphash.rb
-test_files: 
 - test/test_cicphash.rb
+homepage: http://cicphash.rubyforge.org
+licenses: []
+post_install_message: 
 rdoc_options: []
-
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths:
+- .
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-dependencies: []
-
+rubyforge_project: cicphash
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Case Insensitive Case Preserving Hash
+test_files:
+- test/test_cicphash.rb