cicphash 1.1.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4fe93657198f00e131fef0523102674ee6e5be6d2befb4be55806402a5c04a0
+  data.tar.gz: bda72a57adfe99b16e557ac338d8e328eb7fd53364cdf6fb1fcc41cfbb34ddcb
+SHA512:
+  metadata.gz: b664f529e3e895191ea7499dad7d1957bf72551609aaedd0621a3f168fe9456b70d0d01b454c776a1a8c4c957a427bfa67ba47a0d662d8c89ae52995b4e63013
+  data.tar.gz: 101a4dc1918bbdbb3c16c6aa5554a1d9455bc653662af077f0318e7e8a01c1eb3ef73cb11746321494a1af4378706b54bb2c527ed381e85b3ee68c1ef864f590

data/CHANGELOG

@@ -0,0 +1,15 @@
+=== 2.0.0 (2020-12-10)
+
+* Support new Hash instance methods added in 1.9 - 3.0 (jeremyevans)
+
+* Make sure CICPHash has the same interface as Hash in all Ruby versions (jeremyevans)
+
+=== 1.1.0 (2012-09-04)
+
+* Support new Hash instance methods added in 1.9 (jeremyevans)
+
+* Fix dup and clone to return copies (jeremyevans)
+
+=== 1.0.0 (2007-08-13)
+
+* Initial release (jeremyevans)

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2007-2021 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 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.

data/README.rdoc

@@ -0,0 +1,44 @@
+= CICPHash
+
+ruby-cicphash is a library that adds the CICPHash class, which has the
+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 the value is updated to reflect the new value).
+
+Example:
+
+  require 'cicphash'
+  hash = CICPHash.new
+  hash[:AB] = 1
+  hash['ab'] # => 1
+  hash['ab']  = 2
+  hash # => {"ab"=>2}
+
+= Installation
+
+  gem install cicphash
+
+= Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/ruby-cicphash
+
+= Reporting Bugs
+
+The bug tracker is located at https://github.com/jeremyevans/ruby-cicphash/issues
+
+= License
+
+MIT
+
+= Authors
+
+Jeremy Evans <code@jeremyevans.net>

data/cicphash.rb

@@ -1,31 +1,6 @@
-# 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
+# CICPHash has the 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.
@@ -36,7 +11,7 @@
 # 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).
+# key (and 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.
@@ -166,7 +141,8 @@ class CICPHash
     elsif default.length == 1
       default.first
     else
-      raise IndexError, "key not found"
+      error_class = RUBY_VERSION < '1.9' ? IndexError : KeyError
+      raise error_class, "key not found"
     end
   end
   
@@ -186,7 +162,10 @@ class CICPHash
     def key(value)
       @name_hash[@hash.key(value)]
     end
-    alias index key
+
+    if RUBY_VERSION < '3'
+      alias index key
+    end
   else
     def index(value)
       @name_hash[@hash.index(value)]
@@ -304,10 +283,21 @@ class CICPHash
   def values_at(*keys)
     keys.collect{|key| self[key]}
   end
-  alias indexes values_at
-  alias indices values_at
+
+  if RUBY_VERSION < '1.9'
+    alias indexes values_at
+    alias indices values_at
+  end
 
   if RUBY_VERSION >= '1.9'
+    def compare_by_identity
+      raise TypeError, "CICPHash cannot compare by identity, use regular Hash"
+    end
+
+    def compare_by_identity?
+      false
+    end
+
     def assoc(obj)
       obj = convert_key(obj)
       each do |k, v|
@@ -355,7 +345,100 @@ class CICPHash
       self if mod
     end
   end
+
+  if RUBY_VERSION >= '2.0'
+    alias to_h to_hash
+  end
   
+  if RUBY_VERSION >= '2.3'
+    def >(other)
+      to_hash > other.to_hash
+    end
+
+    def >=(other)
+      to_hash >= other.to_hash
+    end
+
+    def <(other)
+      to_hash < other.to_hash
+    end
+
+    def <=(other)
+      to_hash <= other.to_hash
+    end
+
+    def dig(arg, *a)
+      h = self[arg]
+      if a.empty?
+        h
+      elsif !h.nil?
+        raise TypeError, "#{h.class} does not have #dig method" unless h.respond_to?(:dig)
+        h.dig(*a) 
+      end
+    end
+
+    def fetch_values(*a)
+      a.map{|x| fetch(x)}
+    end
+
+    def to_proc
+      lambda{|x| self[x]}
+    end
+  end
+
+  if RUBY_VERSION >= '2.4'
+    def compact
+      hash = dup
+      hash.compact!
+      hash
+    end
+
+    def compact!
+      hash = to_hash
+      replace(hash) if hash.compact!
+    end
+
+    def transform_values(&block)
+      dup.transform_values!(&block)
+    end
+
+    def transform_values!(&block)
+      replace(to_hash.transform_values!(&block))
+    end
+  end
+
+  if RUBY_VERSION >= '2.5'
+    def slice(*a)
+      h = self.class.new
+      a.each{|k| h[k] = self[k] if has_key?(k)}
+      h
+    end
+
+    def transform_keys(&block)
+      dup.transform_keys!(&block)
+    end
+
+    def transform_keys!(&block)
+      replace(to_hash.transform_keys!(&block))
+    end
+  end
+
+  if RUBY_VERSION >= '2.6'
+    alias filter! select!
+  end
+
+  if RUBY_VERSION >= '2.7'
+    alias deconstruct_keys to_hash
+  end
+
+  if RUBY_VERSION >= '3.0'
+    def except(*a)
+      h = dup
+      a.each{|k| h.delete(k)}
+      h
+    end
+  end
+
   private
 
   def convert_key(key)

data/test/test_cicphash.rb

@@ -1,14 +1,22 @@
-#!/usr/local/bin/ruby
-
 $: << File.dirname(File.dirname(File.expand_path(__FILE__)))
 require 'cicphash'
-require 'test/unit'
+ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
+require 'rubygems'
+gem 'minitest'
+require 'minitest/autorun'
 
-class CICPHashTest < Test::Unit::TestCase
+class CICPHashTest < Minitest::Test
   def setup
     @h = CICPHash[]
     @fh = CICPHash['AB'=>1, :cd=>2, 3=>4]
   end
+
+  def test_public_interface
+    cicphash_methods = CICPHash.public_instance_methods.sort
+    hash_methods = Hash.public_instance_methods.sort
+    assert_empty(cicphash_methods - hash_methods)
+    assert_empty(hash_methods - cicphash_methods)
+  end
   
   def test_constructors_and_equality
     # Test CICPHash.[]
@@ -17,7 +25,7 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal Hash[1=>2, 3=>4], CICPHash[1=>2, 3=>4]
     assert_equal Hash[1,2,3,4], CICPHash[1,2,3,4]
     assert_equal Hash[:ab,:c,:de,:f], CICPHash[:ab,:c,:de,:f]
-    assert_not_equal Hash[:AB,:c,:de,:f], CICPHash[:ab,:c,:de,:f]
+    refute_equal Hash[:AB,:c,:de,:f], CICPHash[:ab,:c,:de,:f]
     assert_raises(ArgumentError){CICPHash[1]}
     assert_raises(ArgumentError){CICPHash[1,2,3]}
     
@@ -53,7 +61,7 @@ class CICPHashTest < Test::Unit::TestCase
   end
   
   def test_store_and_retrieve
-    assert_equal nil, @h[1]
+    assert_nil  @h[1]
     @h[1] = 2
     assert_equal 2, @h[1]
     assert_equal 2, @h[:'1']
@@ -86,32 +94,32 @@ class CICPHashTest < Test::Unit::TestCase
   end
   
   def test_defaults
-    assert_equal nil, @fh.default
-    assert_equal nil, @fh.default_proc
-    assert_equal nil, @fh[55]
+    assert_nil  @fh.default
+    assert_nil  @fh.default_proc
+    assert_nil  @fh[55]
     assert_equal 3, CICPHash.new(3).default
-    assert_equal nil, CICPHash.new(3).default_proc
+    assert_nil  CICPHash.new(3).default_proc
     assert_equal 3, CICPHash.new(3)[1]
     
     @fh.default = 4
     assert_equal 4, @fh.default
-    assert_equal nil, @fh.default_proc
+    assert_nil  @fh.default_proc
     assert_equal 4, @fh[55]
     
     h = CICPHash.new(5)
     assert_equal 5, h.default
-    assert_equal nil, h.default_proc
+    assert_nil  h.default_proc
     assert_equal 5, h[55]
     
     h = CICPHash.new{|hash, key| 1234}
-    assert_equal nil, h.default
-    assert_not_equal nil, h.default_proc
+    assert_nil  h.default
+    refute_equal nil, h.default_proc
     assert_equal 1234, h[55]
     
     h = CICPHash.new{|hash, key| hash[key] = 1234; nil}
-    assert_equal nil, h.default
-    assert_not_equal nil, h.default_proc
-    assert_equal nil, h[55]
+    assert_nil  h.default
+    refute_equal nil, h.default_proc
+    assert_nil  h[55]
     assert_equal 1234, h[55]
   end
   
@@ -119,7 +127,7 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal 3, @fh.length
     assert_equal 1, @fh.delete(:ab)
     assert_equal 2, @fh.length
-    assert_equal nil, @fh.delete(:ab)
+    assert_nil  @fh.delete(:ab)
     assert_equal 2, @fh.length
   end
   
@@ -134,7 +142,7 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal Hash[3=>4], hash
     assert_equal 1, @fh.length
     assert_equal Hash[3=>4], @fh
-    assert_equal nil, @fh.reject!{|key, value| key.to_s.length >= 2}
+    assert_nil  @fh.reject!{|key, value| key.to_s.length >= 2}
     hash = @fh.reject!{|key, value| key.to_s.length == 1}
     assert_equal 0, hash.length
     assert_equal Hash[], hash
@@ -235,12 +243,14 @@ class CICPHashTest < Test::Unit::TestCase
     end
   end
   
-  def test_index
-    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)
+  if RUBY_VERSION < '3'
+    def test_index
+      assert_nil  @h.index(1)
+      assert_equal 'AB', @fh.index(1)
+      assert_equal :cd, @fh.index(2)
+      assert_nil  @fh.index(3)
+      assert_equal 3, @fh.index(4)
+    end
   end
   
   def test_inspect_and_to_s
@@ -258,7 +268,7 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal Hash[1=>2, 3=>4].invert, CICPHash[1=>2, 3=>4].invert
     assert_equal Hash[1,2,3,4].invert, CICPHash[1,2,3,4].invert
     assert_equal Hash[:ab,:c,:de,:f].invert, CICPHash[:ab,:c,:de,:f].invert
-    assert_not_equal Hash[:ab,:c,:de,:f].invert, CICPHash[:aB,:c,:de,:f].invert
+    refute_equal Hash[:ab,:c,:de,:f].invert, CICPHash[:aB,:c,:de,:f].invert
     assert [{2=>1},{2=>3}].include?(CICPHash[1,2,3,2].invert)
   end
   
@@ -325,10 +335,10 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal CICPHash['AB'=>1, :cd=>2, 3=>4, 'blah'=>23], @fh.rehash
     x.replace("DIFF")
     assert_equal 23, @fh['blah']
-    assert_equal nil, @fh['DIFF']
+    assert_nil  @fh['DIFF']
     assert_equal CICPHash['AB'=>1, :cd=>2, 3=>4, 'DIFF'=>23], @fh
     assert_equal CICPHash['AB'=>1, :cd=>2, 3=>4, 'DIFF'=>23], @fh.rehash
-    assert_equal nil, @fh['blah']
+    assert_nil  @fh['blah']
     assert_equal 23, @fh['DIFF']
   end
   
@@ -349,10 +359,10 @@ class CICPHashTest < Test::Unit::TestCase
   end
   
   def test_shift
-    assert_equal nil, @h.shift
+    assert_nil  @h.shift
     array = @fh.to_a
     i = 3
-    loop do
+    while true
       assert i >= 0
       kv = @fh.shift
       if kv.nil?
@@ -401,12 +411,27 @@ class CICPHashTest < Test::Unit::TestCase
     assert_equal [4, 2, nil, 1], @fh.values_at('3', 'CD', 32, :ab)
   end
 
+  if RUBY_VERSION < '1.9'
+    def test_indexes_indices
+      [:indexes, :indices].each do |meth|
+        assert_equal [], @h.send(meth)
+        assert_equal [nil], @h.send(meth, 1)
+        assert_equal [nil, nil], @h.send(meth, 1, 1)
+        assert_equal [], @fh.send(meth)
+        assert_equal [1], @fh.send(meth, :ab)
+        assert_equal [2, 1], @fh.send(meth, 'CD', :ab)
+        assert_equal [2, nil, 1], @fh.send(meth, 'CD', 32, :ab)
+        assert_equal [4, 2, nil, 1], @fh.send(meth, '3', 'CD', 32, :ab)
+      end
+    end
+  end
+
   if RUBY_VERSION >= '1.9'
     def test_assoc
-      assert_equal nil, @h.assoc(1)
+      assert_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_nil  @fh.assoc(4)
       assert_equal [3, 4], @fh.assoc('3')
     end
 
@@ -433,26 +458,200 @@ class CICPHashTest < Test::Unit::TestCase
     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)
+      assert_nil  @h.key(1)
+      assert_equal 'AB', @fh.key(1)
+      assert_equal :cd, @fh.key(2)
+      assert_nil  @fh.key(3)
+      assert_equal 3, @fh.key(4)
     end
 
     def test_rassoc
-      assert_equal nil, @h.rassoc(1)
+      assert_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_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_nil  @h.select!{|k, v| true}
+      assert_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
+
+    def test_compare_by_identity
+      assert_raises(TypeError){@fh.compare_by_identity}
+    end
+
+    def test_compare_by_identity?
+      assert_equal(false, @fh.compare_by_identity?)
+    end
+  end
+
+  if RUBY_VERSION >= '2.0'
+    def test_to_h
+      assert_equal Hash[], @h.to_h
+      assert_equal Hash[3,4,'AB',1,:cd,2], @fh.to_h
+    end
+  end
+
+  if RUBY_VERSION >= '2.3'
+    def test_gt
+      assert_equal(false, @fh > @fh)
+      assert_equal(true, @fh > CICPHash['AB'=>1, :cd=>2])
+      assert_equal(false, @fh > CICPHash['AB'=>1, :cd=>2, 3=>4, 5=>6])
+      assert_equal(false, @fh > CICPHash[:AB=>1, :cd=>2, 3=>4])
+      assert_equal(false, @fh > CICPHash[:AB=>1, :cd=>2])
+      assert_equal(false, @fh > CICPHash[:AB=>1, :cd=>2, 3=>4, 5=>6])
+    end
+
+    def test_gte
+      assert_equal(true, @fh >= @fh)
+      assert_equal(true, @fh >= CICPHash['AB'=>1, :cd=>2])
+      assert_equal(false, @fh >= CICPHash['AB'=>1, :cd=>2, 3=>4, 5=>6])
+      assert_equal(false, @fh >= CICPHash[:AB=>1, :cd=>2, 3=>4])
+      assert_equal(false, @fh >= CICPHash[:AB=>1, :cd=>2])
+      assert_equal(false, @fh >= CICPHash[:AB=>1, :cd=>2, 3=>4, 5=>6])
+    end
+
+    def test_lt
+      assert_equal(false, @fh < @fh)
+      assert_equal(false, @fh < CICPHash['AB'=>1, :cd=>2])
+      assert_equal(true, @fh < CICPHash['AB'=>1, :cd=>2, 3=>4, 5=>6])
+      assert_equal(false, @fh < CICPHash[:AB=>1, :cd=>2, 3=>4])
+      assert_equal(false, @fh < CICPHash[:AB=>1, :cd=>2])
+      assert_equal(false, @fh < CICPHash[:AB=>1, :cd=>2, 3=>4, 5=>6])
+    end
+
+    def test_lte
+      assert_equal(true, @fh <= @fh)
+      assert_equal(false, @fh <= CICPHash['AB'=>1, :cd=>2])
+      assert_equal(true, @fh <= CICPHash['AB'=>1, :cd=>2, 3=>4, 5=>6])
+      assert_equal(false, @fh <= CICPHash[:AB=>1, :cd=>2, 3=>4])
+      assert_equal(false, @fh <= CICPHash[:AB=>1, :cd=>2])
+      assert_equal(false, @fh <= CICPHash[:AB=>1, :cd=>2, 3=>4, 5=>6])
+    end
+
+    def test_dig
+      assert_equal(1, @fh.dig(:AB))
+      assert_equal(2, @fh.dig('cd'))
+      assert_equal(4, @fh.dig('3'))
+      assert_nil(@fh.dig(4))
+
+      assert_raises(TypeError){@fh.dig(:AB, 1)}
+      assert_raises(TypeError){@fh.dig('cd', 2)}
+      assert_raises(TypeError){@fh.dig('3', 3)}
+      assert_nil(@fh.dig(4, 5))
+
+      fh = CICPHash['AB'=>{1=>2}, 3=>CICPHash['CD'=>4]]
+      assert_equal(2, fh.dig(:AB, 1))
+      assert_nil(fh.dig(:AB, 2))
+      assert_raises(TypeError){fh.dig(:AB, 1, 3)}
+      assert_nil(fh.dig(:AB, 2, 3))
+
+      assert_equal(4, fh.dig('3', :cd))
+      assert_nil(fh.dig(3, 2))
+      assert_nil(fh.dig(4))
+    end
+
+    def test_fetch_values
+      assert_equal([1], @fh.fetch_values(:AB))
+      assert_equal([1, 2, 4], @fh.fetch_values(:AB, 'cd', '3'))
+      assert_raises(KeyError){@fh.fetch_values(:AB, 'cd', 4)}
+    end
+
+    def test_to_proc
+      pr = @fh.to_proc
+      assert_equal(1, pr[:AB])
+      assert_equal(2, pr['cd'])
+      assert_equal(4, pr['3'])
+      assert_nil(pr[4])
+    end
+  end
+
+  if RUBY_VERSION >= '2.4'
+    def test_compact
+      assert_equal(false, @fh.compact.equal?(@fh))
+      assert_equal(@fh, @fh.compact)
+      assert_equal(CICPHash['AB'=>1], CICPHash['AB'=>1, :cd=>nil].compact)
+    end
+
+    def test_compact!
+      fh = @fh.dup
+      assert_nil(@fh.compact!)
+      assert_equal(fh, @fh)
+
+      h = CICPHash['AB'=>1, :cd=>nil]
+      assert_equal(CICPHash['AB'=>1], h.compact!)
+      assert_equal(CICPHash['AB'=>1], h)
+    end
+
+    def test_transform_values
+      fh = @fh.transform_values{|v| v.to_s*2}
+      assert_equal(1, @fh[:AB])
+      assert_equal(CICPHash['AB'=>'11', :cd=>'22', 3=>'44'], fh)
+      assert_equal('11', fh[:AB])
+    end
+
+    def test_transform_values!
+      @fh.transform_values!{|v| v.to_s*2}
+      assert_equal('11', @fh[:AB])
+      assert_equal(CICPHash['AB'=>'11', :cd=>'22', 3=>'44'], @fh)
+      assert_equal('11', @fh[:AB])
+    end
+  end
+
+  if RUBY_VERSION >= '2.5'
+    def test_slice
+      assert_equal(CICPHash[:AB=>1, 'CD'=>2, '3'=>4], @fh.slice(:AB, 'CD', '3'))
+      assert_equal(CICPHash[:AB=>1, 'CD'=>2], @fh.slice(:AB, 'CD'))
+      assert_equal(1, @fh.slice(:AB, 'CD')['AB'])
+    end
+
+    def test_transform_keys
+      map = {'AB'=>:XY, :cd=>'DC', 3=>'5'}
+      dh = @fh.dup
+      fh = @fh.transform_keys{|k| map[k]}
+      assert_equal(dh, @fh)
+      assert_equal(1, fh['XY'])
+      assert_equal(2, fh[:dc])
+      assert_equal(4, fh[5])
+    end
+
+    def test_transform_keys!
+      map = {'AB'=>:XY, :cd=>'DC', 3=>'5'}
+      dh = @fh.dup
+      fh = @fh.transform_keys!{|k| map[k]}
+      assert_equal(false, dh == @fh)
+      assert_equal(1, @fh['XY'])
+      assert_equal(2, @fh[:dc])
+      assert_equal(4, @fh[5])
+    end
+  end
+
+  if RUBY_VERSION >= '2.6'
+    def test_filter!
+      assert_nil  @h.filter!{|k, v| true}
+      assert_nil  @fh.filter!{|k, v| true}
+      assert_equal @h, @fh.dup.filter!{|k, v| false}
+      assert_equal CICPHash["AB"=>1], @fh.filter!{|k, v| k == "AB"}
+    end
+  end
+
+  if RUBY_VERSION >= '2.7'
+    def test_deconstruct_keys
+      assert_equal(@fh.to_hash, @fh.deconstruct_keys)
+      assert_equal(Hash, @fh.deconstruct_keys.class)
+    end
+  end
+
+  if RUBY_VERSION >= '3.0'
+    def test_except
+      @fh = CICPHash['AB'=>1, :cd=>2, 3=>4]
+      assert_equal(@fh, @fh.except)
+      assert_equal(CICPHash[:cd=>2, 3=>4], @fh.except('AB', 5))
+      assert_equal(CICPHash['AB'=>1], @fh.except('CD', '3'))
+    end
   end
 end

metadata

@@ -1,47 +1,63 @@
 --- !ruby/object:Gem::Specification
 name: cicphash
 version: !ruby/object:Gem::Version
-  version: 1.1.0
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-04 00:00:00.000000000 Z
+date: 2021-12-10 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: code@jeremyevans.net
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.rdoc
+- CHANGELOG
+- MIT-LICENSE
 files:
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
 - cicphash.rb
 - test/test_cicphash.rb
-homepage: http://cicphash.rubyforge.org
-licenses: []
+homepage: http://ruby-cicphash.jeremyevans.net
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/ruby-cicphash/issues
+  changelog_uri: https://github.com/jeremyevans/ruby-cicphash/blob/master/CHANGELOG
+  documentation_uri: http://ruby-cicphash.jeremyevans.net
+  mailing_list_uri: https://github.com/jeremyevans/ruby-cicphash/discussions
+  source_code_uri: https://github.com/jeremyevans/ruby-cicphash
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- 'CICPHash: Case Insensitive Case Preserving Hash'
+- "--main"
+- README.rdoc
 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: []
-rubyforge_project: cicphash
-rubygems_version: 1.8.23
+rubygems_version: 3.2.32
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Case Insensitive Case Preserving Hash
 test_files:
 - test/test_cicphash.rb