tofuhash 0.1.0 → 1.0.0

data/lib/tofuhash/tofuhash.rb

@@ -39,8 +39,8 @@
 #
 class TofuHash < Hash
     module Version
-      MAJOR = 0
-      MINOR = 1
+      MAJOR = 1
+      MINOR = 0
       REVISION = 0
       STRING = [MAJOR, MINOR, REVISION].join('.')
     end
@@ -51,7 +51,13 @@ class TofuHash < Hash
       if default
         raise ArgumentError, "Can't initialize Hash with both a default value and a block"
       end
-      super() { |hash,key| yield(hash, decode(key)) }
+      super() do |hash,key| 
+        if key.is_a? TofuKey then 
+          yield(hash, decode(key))
+        else
+          yield(hash, key)
+        end
+      end
     else
       super
     end
@@ -89,15 +95,36 @@ class TofuHash < Hash
     super( encode(key), value )
   end
 
-  alias :regular_each :each unless method_defined?(:regular_each)
+  alias :regular_each_pair :each_pair unless method_defined?(:regular_each_pair)
 
   # see Hash#each
   def each &block
-    self.regular_each do |key, value|
-      block.call( decode(key), value )
+    self.regular_each_pair do |key, value|
+      block.call( [decode(key), value] )
     end
   end
 
+  # see Hash#each_key
+  def each_key &block
+    self.regular_each_pair do |key, value|
+      block.call(decode(key))
+    end
+  end
+  
+  # executes the block on each key as it is stored with TofuHash (e.g. the TofuKey)
+  def each_key_encoded
+    self.regular_each_pair do |key, value|
+      yield key
+    end
+  end
+  
+  # see Hash#each_pair
+  def each_pair &block
+    self.regular_each_pair do |key,value|
+      block.call( decode(key), value )
+    end
+  end
+  
   # see Hash#store
   def store key, value
     super( encode(key), value )
@@ -109,10 +136,14 @@ class TofuHash < Hash
   end
 
   # see Hash#has_key?
+  # also aliased as include?, key?, and member?
   def has_key? key
     super( encode(key) )
   end
-
+  alias_method 'include?', 'has_key?'
+  alias_method 'key?', 'has_key?'
+  alias_method 'member?', 'has_key?'
+  
   # see Hash#keys
   def keys
     # collect will call each which decodes the key
@@ -137,11 +168,6 @@ class TofuHash < Hash
     aux
   end
 
-  # see Hash#include?
-  def include?(key)
-    super(encode(key))
-  end
-
   alias :regular_delete_if :delete_if
 
   # see Hash#delete_if
@@ -156,4 +182,159 @@ class TofuHash < Hash
     delete_if{ |key, value| ! yield(key, value) }
   end
 
+  # see Hash#default
+  def default(key = nil)
+    super
+  end
+  
+  # see Hash#delete
+  def delete(key, &block)
+    if block_given? then
+      super(encode(key)) {|e| yield e.decode }
+    else
+      super(encode(key))
+    end
+  end
+  
+  alias :regular_fetch :fetch
+  class Missing; end # used to mark a missing argument
+
+  # see Hash#fetch
+  def fetch( key, default = Missing )
+    if block_given? then
+      if default == Missing then
+        super(encode(key)) {|e| yield e.decode }
+      else
+        super(encode(key),default) {|e| yield e.decode }
+      end
+    else
+      if default == Missing then
+        super(encode(key))
+      else
+        super(encode(key),default)
+      end
+    end
+  end
+  
+  # see Hash#index
+  def index( value )
+    result = super
+    return decode(result) if result.is_a? TofuKey
+    return result
+  end
+  
+  # see Hash#replace
+  def replace( other_hash )
+    self.clear
+    other_hash.each_pair do |key, value|
+      self[key]=value
+    end
+  end
+  
+  # see Hash#select
+  def select
+    if RUBY_VERSION >= "1.9"
+      result = {}
+      each_pair do |key,value|
+        result[key]=value if yield(key,value)
+      end
+      return result
+    else
+      result = []
+      each_pair do |key,value|
+        result << [key,value] if yield key,value
+      end
+      return result
+    end
+  end
+  
+  # see Hash#shift
+  def shift
+    result = super
+    result[0] = decode(result[0])
+    return result
+  end
+  
+  # see Hash#sort
+  # when called with a block, the keys passed to the block will be the original keys.
+  def sort
+    return super if RUBY_VERSION >= "1.9"
+    if block_given?
+      result = super {|kv1,kv2| yield( [decode(kv1[0]),kv1[1]], [decode(kv2[0]),kv2[1]] ) }
+    else
+      result = super
+    end
+    result.collect {|a| [a[0].decode, a[1]] }
+  end
+  
+  # see Hash#==
+  # comparison will use TofuKey comparison to retain the desired behavior.
+  def == obj
+    return false unless obj.is_a? Hash
+    obj.each_pair do |key, value|
+      return false unless (v = fetch( key ) {|k| Missing }).eql? value
+    end
+    return true
+  end
+  
+  # see Hash#merge
+  def merge( other_hash, &block )
+    self.dup.merge!(other_hash, &block)
+  end
+  
+  #see Hash#merge!
+  # see Hash#update
+  def merge!( other_hash )
+    other_hash.each_pair do |key,value|
+      if block_given? then
+        if self.has_key? key then
+          self[key] = yield( key, self[key], value )
+        else
+          self[key] = value
+        end
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+  alias_method 'update', 'merge!'
+  
+  #see Hash#reject
+  def reject( &block )
+    self.dup.delete_if(&block)
+  end
+  
+  alias_method 'regular_reject!','reject!'
+  #see Hash#reject!
+  def reject!( &block )
+    self.regular_reject! do |key, value|
+      block.call( decode(key), value)
+    end
+  end
+  
+  #see Hash#to_hash
+  def to_hash
+    result = Hash.new
+    self.each_pair do |key, value|
+      result[key]=value
+    end
+    result
+  end
+  
+  #see Hash#to_s
+  def to_s
+    self.to_hash.to_s
+  end
+  
+  # see Hash#try_convert (ruby 1.9.x +)
+  def TofuHash.try_convert( obj )
+    h = super obj
+    return nil if h.nil?
+    result = TofuHash.new
+    h.each_pair do |key,value|
+      result[key] = value
+    end
+    return result
+  end
 end # class TofuHash

data/lib/tofuhash/tofukey.rb

@@ -87,4 +87,20 @@ class TofuKey
       @coded_key.eql?( obj )
     end
   end
+  
+  def == obj
+    self.eql? obj
+  end
+  
+  def <=> obj
+    if obj.instance_of? Symbol
+      @coded_key <=> obj.to_s.downcase
+    elsif obj.instance_of? TofuKey
+      @coded_key <=> obj.coded_key
+    elsif obj.respond_to? :downcase
+      @coded_key <=> obj.downcase
+    else
+      @coded_key <=> obj
+    end
+  end
 end

data/readme.txt

@@ -15,13 +15,13 @@ for Example:
  puts h[:mixedCaseString]  #=> "string"
  puts h[11]                #=> "number"
 
-Version:: 0.1.0 A useful and well tested subset of Hash methods is available.
+Version:: 1.0.0 A well tested, complete version which support all Hash methods.
 
 Tested to work with:
 Ruby 1.8.6
 Ruby 1.9.1
 
-How is TofuHash differenct than Hash?
+How is TofuHash different than Hash?
 * TofuHash wraps the key into a TofuKey which is used internally inside TofuHash.
   The TofuKey defines new behavior for handling the key.  By
   default it will treat Symbol, String, and uppercase vs downcase as the same. This
@@ -30,6 +30,11 @@ How is TofuHash differenct than Hash?
 
 * TofuHash adds the method TofuHash#delete_unless
 
+* TofuHash.compare_by_identity (ruby 1.9 or later) is useless because TofuHash encodes the key into a TofyKey,
+therefore when compare_by_identity is used TofuHash will never match the given key.  This matches
+the behavior of Hash with strings for keys.  The string is cloned, so compare_by_identity is also
+useless for that situation.
+
 == Links:
 
 Start Here:: http://tofuhash.rubyforge.org
@@ -85,6 +90,9 @@ Contributors:
 
 == Release History:
 
+April 4 2009 - 1.0.0 release on rubyforge and git hub.  Completed testing the entire Hash interface!
+Added all missing or misbehaving methods from Hash.  Tested against both ruby 1.8.6 and 1.9.1.
+
 Feb 28 2009 - 0.1.0 release on rubyforge.  Added gem, rdoc, rcov output.
 Added TofuHash::Version module
 

data/test/test-tofuhash.rb

@@ -1,25 +1,32 @@
+require 'tofuhash'
 require 'test/unit'
 require 'pp'
-require 'lib/tofuhash'
+require 'yaml'
 
-=begin rdoc
+=begin
 test-tofuhash.rb
 
 Test cases for TofuHash.  This includes modified versions of Ruby's unit tests
 for Hash, and Ruby's Hash examples in the ri documentation.  Plus some custom
 tests to validate similarities between Hash and TofuHash.
 
-Version: see readme.txt for details.
+Version: see tofuhash.rb for details.
 
 License:
 
 tofuhash.rb is released under the MIT License + Free Software Foundation
-Advertising Prohibition.  see readme.txt file for details.
+Advertising Prohibition.  see that file for details.
 
 test-tofuhash.rb (this file) is released under the Ruby License since it
 contains source code based on Ruby's released source.
 =end
 
+#
+# Note, when asserting a Hash vs a TofuHash; the TofuHash must appear as the
+# left argument.  This is because Hash doesn't know how to compare to a TofuHash
+# in this release.
+#
+
 module TofuHashTesting
   class Test_TofuHash < Test::Unit::TestCase
     def test_new
@@ -206,6 +213,11 @@ module TofuHashTesting
       assert_equal( h[b],2 )      #=> 2
     end
 
+    def test_ri_hash_square_bracket_code
+      assert_equal( TofuHash["a", 100, "b", 200], {"a"=>100, "b"=>200} )       #=> {"a"=>100, "b"=>200}
+      assert_equal( TofuHash["a" => 100, "b" => 200], {"a"=>100, "b"=>200} )    #=> {"a"=>100, "b"=>200}
+    end
+
     def test_ri_hash_new_code
       h = TofuHash.new("Go Fish")
       h["a"] = 100
@@ -225,32 +237,99 @@ module TofuHashTesting
       assert_equal( h.keys, ["c","d"] )           #=> ["c", "d"]
     end
 
-    def test_ri_hash_square_bracket_code
-      assert_equal( TofuHash["a", 100, "b", 200], {"a"=>100, "b"=>200} )       #=> {"a"=>100, "b"=>200}
-      assert_equal( TofuHash["a" => 100, "b" => 200], {"a"=>100, "b"=>200} )    #=> {"a"=>100, "b"=>200}
+    def test_ri_hash_equality
+=begin
+    TODO: KNOWN ISSUE, Hash doesn't know how to compare to TofuHash.
+=end
+      h1 = TofuHash[ "a" => 1, "c" => 2 ]
+      h2 = { 7 => 35, "c" => 2, "a" => 1 }
+      h3 = TofuHash[ "a" => 1, "c" => 2, 7 => 35 ]
+      h4 = TofuHash[ "a" => 1, "d" => 2, "f" => 35 ]
+      assert_equal( h1 == h2, false )   #=> false
+#    assert_equal( h2 == h3, true )   #=> true; however see issue
+      assert_equal( h3 == h4, false )   #=> false
     end
+    
+    def test_ri_element_reference
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert_equal( h["a"], 100 )
+      assert_equal( h["b"], 200 )
+      
+      # case-insensitive access...
+      assert_equal( h["A"], 100 )
+      assert_equal( h["B"], 200 )
 
-    def test_to_a
-      hash = TofuHash["a" => 2, "b" => 1]
-      assert_equal [["a",2],["b",1]], hash.to_a
+      # indifferent access...
+      assert_equal( h[:a], 100 )
+      assert_equal( h[:b], 200 )
+      
+      # both
+      assert_equal( h[:A], 100 )
+      assert_equal( h[:B], 200 )
     end
+    
+    def test_ri_element_assignment
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h["a"] = 9
+      h["c"] = 4
+      
+      # tofu examples...
+      h[:a] = 10
+      h["D"] = 5
+      h[:e] = 6
+      h[:F] = 7
+      assert_equal( h, {"a"=>10, "b"=>200, "c"=>4, "d"=>5, "e"=>6, "f"=>7} )
+      assert_equal( h, {:a=>10, "b"=>200, "c"=>4, "D"=>5, :e=>6, :F=>7} )
+    end
+    
+    def test_ri_clear
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.clear
+      assert_equal( h, {} )
+    end
+    
+    def test_ri_default_access
+      h = TofuHash.new
+      assert_nil( h.default )
+      assert_nil( h.default(2) )
+      
+      h = TofuHash.new("cat")
+      assert_equal( h.default, "cat" )
+      assert_equal( h.default(2), "cat" )
 
-    def test_ri_to_a
-      h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
-      result = h.to_a
-      sorted = h.to_a.sort { |a,b| a[0] <=> b[0] }
-      assert_equal( [['a',100],['c',300],['d',400]], sorted )
+      h = TofuHash.new {|hash,key| hash[key] = key.to_i*10}
+      assert_equal( h.default, 0 )
+      assert_equal( h.default(2), 20 )
     end
     
-    def test_include?
-      hash =  TofuHash["a" => 2, "b" => 1]
-      assert( hash.include?( 'a' ))
+    def test_ri_default_assignment
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.default = "Go fish"
+      assert_equal( 100, h["a"] )
+      assert_equal( "Go fish", h["z"] )
+      h.default = proc do |hash, key|
+        hash[key] = key + key
+      end
+      assert( h[2].is_a?( Proc ))
+      assert( h["cat"].is_a?( Proc ))
+      assert_same( h[2], h["cat"] )
     end
     
-    def test_ri_include?
-      h = { "a" => 100, "b" => 200 }
-      assert( h.has_key?("a") )
-      assert_equal( false, h.has_key?("z"))
+    def test_ri_default_proc
+      h = TofuHash.new {|h,k| h[k] = k*k }
+      p = h.default_proc
+      assert( p.is_a?( Proc ))
+      a = []
+      p.call( a, 2 )
+      assert_equal( [nil, nil, 4], a )
+    end
+
+    def test_ri_delete
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert_equal( h.delete("a"), 100 )
+      assert_equal( h.delete("z"), nil )
+      assert_equal( h.delete("z") { |el| "#{el} not found" }, "z not found" )
+      assert_equal( h, { "b" => 200 } )
     end
 
     def test_ri_delete_if
@@ -265,21 +344,365 @@ module TofuHashTesting
       assert_equal TofuHash['b' => 1], hash
     end
 
-    def test_ri_hash_equality
-=begin
-    TODO: KNOWN ISSUE, Hash doesn't know how to compare to TofuHash.
+    def test_ri_each
+      results = []
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.each {|key, value| results << "#{key} is #{value}" }
+      assert_equal( ["a is 100", "b is 200"], results) 
+      
+      results = []
+      h.each {|x| results << x}
+      assert_equal( [["a", 100], ["b", 200]], results )
+    end
+    
+    def test_ri_each_key
+      results = []
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.each_key {|key| results << key }
+      assert_equal( ["a", "b"], results) 
+    end
+    
+    def test_ri_each_pair
+      results = []
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.each_pair {|key, value| results << "#{key} is #{value}" }
+      assert_equal( ["a is 100", "b is 200"], results) 
+    end
+    
+    def test_ri_each_value
+      results = []
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.each_value {|value| results << value }
+      assert_equal( [100,200], results) 
+    end
+    
+    def test_ri_empty?
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( !h.empty? )
+      h = TofuHash[]
+      assert( h.empty? )
+    end
+    
+    def test_ri_fetch
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert_equal( 100, h.fetch("a"))
+      assert_equal( "go fish", h.fetch("z", "go fish"))
+      assert_equal( "go fish, z", h.fetch("z") { |el| "go fish, #{el}"})
+      # supress expected warning message from clutter test output
+      old_VERBOSE = $VERBOSE
+      $VERBOSE = nil
+      #note, this will generate a warning "block supersedes default value argument"
+      assert_equal( "go fish, z", h.fetch("z", 99) { |el| "go fish, #{el}"})
+      $VERBOSE = old_VERBOSE
+      if RUBY_VERSION >= "1.9" then
+        assert_raise( KeyError ) do
+          h.fetch("z")
+        end
+      else
+        assert_raise( IndexError ) do
+          h.fetch("z")
+        end
+      end
+    end
+    
+    def test_ri_has_key
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( h.has_key?( "a" ) )
+      assert( h.has_key?( :a ) )
+      assert( h.has_key?( "A" ) )
+      assert( h.has_key?( :A ) )
+      assert( !h.has_key?( "z" ) )
+    end
+    
+    def test_ri_include
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( h.include?( "a" ) )
+      assert( h.include?( :a ) )
+      assert( h.include?( "A" ) )
+      assert( h.include?( :A ) )
+      assert( !h.include?( "z" ) )
+    end
 
-    h1 = TofuHash[ "a" => 1, "c" => 2 ]
-    h2 = { 7 => 35, "c" => 2, "a" => 1 }
-    h3 = TofuHash[ "a" => 1, "c" => 2, 7 => 35 ]
-    h4 = TofuHash[ "a" => 1, "d" => 2, "f" => 35 ]
-    puts "h1"
-    assert_equal( h1 == h2, false )   #=> false
-    puts "h2"
-    assert_equal( h2 == h3, true )   #=>
-    puts "h3"
-    assert_equal( h3 == h4, false )   #=> false
-=end
+    def test_include?
+      hash =  TofuHash["a" => 2, "b" => 1]
+      assert( hash.include?( 'a' ))
+    end
+    
+    def test_ri_include?
+      h = { "a" => 100, "b" => 200 }
+      assert( h.has_key?("a") )
+      assert_equal( false, h.has_key?("z"))
+    end
+
+    def test_ri_key_question
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( h.key?( "a" ) )
+      assert( h.key?( :a ) )
+      assert( h.key?( "A" ) )
+      assert( h.key?( :A ) )
+      assert( !h.key?( "z" ) )
+    end
+    
+    def test_ri_member_question
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( h.member?( "a" ) )
+      assert( h.member?( :a ) )
+      assert( h.member?( "A" ) )
+      assert( h.member?( :A ) )
+      assert( !h.member?( "z" ) )
+    end
+    
+    def test_ri_has_value
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( h.has_value?( 100 ))
+      assert( !h.has_value?( 999 ))
+    end
+
+    def test_ri_value_question
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert( h.value?( 100 ))
+      assert( !h.value?( 999 ))
+    end
+    
+    def test_ri_index
+      old_VERBOSE = $VERBOSE
+      $VERBOSE = nil
+      # supress deprecated warning message (1.9)
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      assert_equal( "b", h.index( 200 ))
+      assert_equal( nil, h.index( 999 ))
+      $VERBOSE = old_VERBOSE
+    end
+    
+    def test_ri_replace
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h2 = {"c" => 300, "d" => 400 }
+      h.replace( h2 )
+      assert_equal( h, h2 )
+      h2["c"] = 999
+      assert_equal( 300, h["c"] )
+      h.each_key_encoded do |key|
+        assert_instance_of( TofuKey, key )
+      end
+    end
+
+    def test_ri_invert
+      h = TofuHash[ "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 ]
+      if RUBY_VERSION >= "1.9" then
+        assert_equal( h.invert, {0=>"a", 100=>"m", 200=>"d", 300=>"y"} )
+      else
+        assert_equal( h.invert, {0=>"a", 100=>"n", 200=>"d", 300=>"y"} )
+      end
+    end
+    
+    def test_ri_keys
+      h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
+      assert_equal( ["a", "b", "c", "d"], h.keys )
+    end
+    
+    def test_ri_length_and_size
+      h = TofuHash[ "d" => 100, "a" => 200, "v" => 300, "e" => 400 ]
+      assert_equal( 4, h.length )
+      assert_equal( 4, h.size )
+      assert_equal( 200, h.delete("a") )
+      assert_equal( 3, h.length )
+      assert_equal( 3, h.size )
+    end
+
+    def test_ri_merge
+      h1 = TofuHash[ "a" => 100, "b" => 200 ]
+      h2 = { "b" => 254, "c" => 300 }
+      result = h1.merge(h2)
+      assert_equal( result, {"a"=>100, "b"=>254, "c"=>300} )
+      result.regular_each_pair do | key, value |
+        assert_instance_of( TofuKey, key )
+      end
+      assert_equal( h1, {"a"=>100, "b" => 200 })
+      
+      result = h1.merge(h2) do |key,old_val,new_val|
+        assert_equal( "b", key )
+        assert_equal( 200, old_val )
+        assert_equal( 254, new_val )
+        :happy
+      end
+      assert_equal( result, {"a"=>100, "b"=>:happy, "c"=>300} )
+      result.regular_each_pair do | key, value |
+        assert_instance_of( TofuKey, key )
+      end
+      assert_equal( h1, {"a"=>100, "b" => 200 })
+    end
+    
+    def test_ri_merge!
+      h1 = TofuHash[ "a" => 100, "b" => 200 ]
+      h2 = { "b" => 254, "c" => 300 }
+      result = h1.merge!(h2)
+      assert_equal( result, {"a"=>100, "b"=>254, "c"=>300} )
+      assert_equal( h1, result)
+    end
+    
+    def test_ri_update
+      h1 = TofuHash[ "a" => 100, "b" => 200 ]
+      h2 = { "b" => 254, "c" => 300 }
+      result = h1.update(h2)
+      assert_equal( result, {"a"=>100, "b"=>254, "c"=>300} )
+      assert_equal( h1, result)
+    end
+    
+    def test_ri_rehash
+      a = [ "a", "b" ]
+      c = [ "c", "d" ]
+      h = TofuHash[ a => 100, c => 300 ]
+      assert_equal( 100, h[a] )
+      a[0] = "z"
+      assert_equal( nil, h[a] )
+      assert_equal( h.rehash, {["z", "b"]=>100, ["c", "d"]=>300} )
+      assert_equal( 100, h[a] )
+    end
+    
+    def test_ri_reject
+      h =  TofuHash["a" => 100, "b" => 200,  "c" => 300]
+      result = h.reject { |key,value| key >= 'b' }
+      assert_equal TofuHash['a' => 100], result
+      assert_equal TofuHash["a" => 100, "b" => 200,  "c" => 300], h
+    end
+    
+    def test_ri_reject!
+      h =  TofuHash["a" => 100, "b" => 200,  "c" => 300]
+      result = h.reject! { |key,value| key >= 'b' }
+      assert_equal TofuHash['a' => 100], result
+      assert_equal TofuHash["a" => 100], h
+      
+      result = h.reject! { |key,value| key >= 'b' }
+      assert_equal nil, result
+      assert_equal TofuHash["a" => 100], h
+    end
+    
+    def test_ri_select
+      h = TofuHash[ "a" => 100, "b" => 200, "c" => 300 ]
+      if RUBY_VERSION < "1.9" then
+        assert_equal( [["b", 200], ["c", 300]], h.select {|k,v| k > "a"} )
+        assert_equal( [["a", 100]], h.select {|k,v| v < 200} )
+      else
+        assert_equal( {"b"=> 200,"c"=>300}, h.select {|k,v| k > "a"} )
+        assert_equal( {"a"=> 100}, h.select {|k,v| v < 200} )
+      end
+    end
+    
+    def test_ri_shift
+      h = TofuHash[ 1 => "a", 2 => "b", 3 => "c" ]
+      assert_equal( [1,"a"], h.shift )
+      assert_equal( h, {2 => "b", 3 => "c"} )
+    end
+    
+    def test_ri_sort
+      h = TofuHash[ "a" => 20, "b" => 30, "c" => 10  ]
+      assert_equal( [["a", 20], ["b", 30], ["c", 10]], h.sort )
+      assert_equal( [["c", 10], ["a", 20], ["b", 30]], h.sort {|a,b| a[1]<=>b[1]} )
+    end
+
+    def test_ri_store
+      h = TofuHash[ "a" => 100, "b" => 200 ]
+      h.store("a",9)
+      h.store("c",4)
+      
+      # tofu examples...
+      h.store(:a,10)
+      h.store("D",5)
+      h.store(:e,6)
+      h.store(:F,7)
+      assert_equal( h, {"a"=>10, "b"=>200, "c"=>4, "d"=>5, "e"=>6, "f"=>7} )
+      assert_equal( h, {:a=>10, "b"=>200, "c"=>4, "D"=>5, :e=>6, :F=>7} )
+    end
+    
+    def test_to_a
+      hash = TofuHash["a" => 2, "b" => 1]
+      assert_equal [["a",2],["b",1]], hash.to_a
+    end
+
+    def test_ri_to_a
+      h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
+      result = h.to_a
+      sorted = h.to_a.sort { |a,b| a[0] <=> b[0] }
+      assert_equal( [['a',100],['c',300],['d',400]], sorted )
+    end
+    
+    def test_ri_to_hash
+      h = TofuHash["a" => 2, "b" => 1]
+      hash = h.to_hash
+      assert_same( Hash, hash.class )
+      assert_equal( {"a" => 2, "b" => 1}, hash )
+    end
+    
+    def test_ri_to_s
+      # note this was modified from 1.8.6 in expectation of 1.9 which should preserve insert order.
+      h = TofuHash[ "a" => 100, "c" => 300, "d" => 400 ]
+      if RUBY_VERSION < "1.9"
+        assert_equal( h.to_s, "a100c300d400" )
+      else
+        assert_equal( h.to_s, '{"a"=>100, "c"=>300, "d"=>400}' )
+      end
+    end
+    
+    def test_ri_to_yaml
+      h = TofuHash[ :a => 100, "c" => 300, "d" => 400 ]
+      serialized = h.to_yaml
+      new_obj = YAML::load(serialized)
+      assert_equal( h, new_obj )
+    end
+    
+    def test_ri_values
+        h = TofuHash[ "a" => 100, "b" => 200, "c" => 300 ]
+        assert_equal( [100, 200, 300], h.values )
+    end
+    
+    def test_ri_values_at
+      h = TofuHash[ "cat" => "feline", "dog" => "canine", "cow" => "bovine" ]
+      assert_equal( ["bovine", "feline"], h.values_at("cow", "cat"))
+      assert_equal( ["bovine", "feline"], h.values_at("Cow", "cAt"))
+      assert_equal( ["bovine", "feline"], h.values_at(:cow, :cAt))
+    end
+    
+    def test_compare_by_identity
+      return if RUBY_VERSION < "1.9"
+      # adapted from http://eigenclass.org/hiki.rb?Changes+in+Ruby+1.9#l85
+      h1 = TofuHash[ "a" => 100, "b" => 200, :c => "c" ]
+      assert_same(h1.compare_by_identity, h1)
+      assert( h1.compare_by_identity? )
+      assert_equal( nil, h1["a"] )        # => nil  # different objects.
+      assert_equal( nil, h1[:c] )         # => nil  # note Hash would return "c" since same symbols are all same.  But TofuHash duplicates the key (just like a string key in Hash).
+    end
+    
+    def test_try_convert
+      return if RUBY_VERSION < "1.9"
+      assert_equal( nil, TofuHash.try_convert( [:a,:b] ) )
+      result = TofuHash.try_convert( {:a => :b} )
+      assert_instance_of( TofuHash, result )
+      assert_equal( result, {:a=>:b} )
     end
   end # class TestHash
+  
+  class TestTofuKey < Test::Unit::TestCase
+    def test_eql?
+      k = TofuKey.new :happy
+      assert_equal( k, :HAPPY )
+      
+      k = TofuKey.new 123
+      assert_equal( k, 123 )
+    end
+    
+    def test_compare
+      k = TofuKey.new :happy
+      assert_equal( 1, k <=> :Angry )
+      assert_equal( 1, k <=> "angRY" )
+      assert_equal( 0, k <=> :HAPPY )
+      assert_equal( 0, k <=> "Happy" )
+      assert_equal( -1, k <=> :Sad )
+      assert_equal( -1, k <=> "sad" )
+      
+      k = TofuKey.new 123
+      assert_equal( 1, k <=> 122 )
+      assert_equal( 0, k <=> 123 )
+      assert_equal( -1, k <=> 124 )
+    end
+  end
 end # module TofuHash

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: tofuhash
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2009-02-28 00:00:00 -06:00
+  version: 1.0.0
+date: 2009-04-04 00:00:00 -05:00
 summary: TofuHash, a Hash that is case-insensitive and treats symbols and strings as equals (customizable); always preserving the original key.
 require_paths: 
 - lib