tofuhash 0.1.0

data/lib/tofuhash/tofuhash.rb

@@ -0,0 +1,159 @@
+# TofuHash 
+#
+# Links: 
+# * readme.txt[link:files/readme_txt.html]
+# * source: http://github.com/ghouston/tofuhash/tree/master
+#
+# A varient of Hash which can change the lookup behavior of keys.  
+# The default TofuHash will match Symbol and String without reguard
+# to case.  By subclassing TofuKey, this behavior can be changed.
+# 
+#
+# License:
+#
+# (The MIT License + Free Software Foundation Advertising Prohibition)
+#
+# Copyright (c) 2007 Gregory N. Houston
+#
+# 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.
+#
+# Except as contained in this notice, the name(s) of the above copyright holders
+# shall not be used in advertising or otherwise to promote the sale, use or other
+# dealings in this Software without prior written authorization.
+#
+class TofuHash < Hash
+    module Version
+      MAJOR = 0
+      MINOR = 1
+      REVISION = 0
+      STRING = [MAJOR, MINOR, REVISION].join('.')
+    end
+
+  # see Hash.new
+  def initialize ( default = nil )
+    if block_given?
+      if default
+        raise ArgumentError, "Can't initialize Hash with both a default value and a block"
+      end
+      super() { |hash,key| yield(hash, decode(key)) }
+    else
+      super
+    end
+  end
+
+  # see Hash#encode
+  def encode( key )
+    TofuKey.new(key)
+  end
+
+  # see Hash#decode
+  def decode( key )
+    key.decode
+  end
+
+  class << self
+    # see Hash.[]
+    def [](*args)
+      if args.size == 1 && args[0].instance_of?( Object::Hash )
+        h = TofuHash.new
+        args[0].each { |k,v| h.store( k,v ) }
+        h
+      elsif (args.size % 2 != 0)
+        raise ArgumentError, "odd number of arguments for TofuHash"
+      else
+        h = TofuHash.new
+        1.step( args.size, 2 ) { |i| h.store(args[i-1],args[i]) }
+        h
+      end
+    end
+  end
+
+  # see Hash#[]=
+  def []= key,value
+    super( encode(key), value )
+  end
+
+  alias :regular_each :each unless method_defined?(:regular_each)
+
+  # see Hash#each
+  def each &block
+    self.regular_each do |key, value|
+      block.call( decode(key), value )
+    end
+  end
+
+  # see Hash#store
+  def store key, value
+    super( encode(key), value )
+  end
+
+  # see Hash#[]
+  def [] key
+    super( encode(key) )
+  end
+
+  # see Hash#has_key?
+  def has_key? key
+    super( encode(key) )
+  end
+
+  # see Hash#keys
+  def keys
+    # collect will call each which decodes the key
+    self.collect { |k,v| k }
+  end
+
+  alias_method :regular_inspect, :inspect unless method_defined?(:regular_inspect)
+
+  # see Hash#values_at
+  def values_at( *args )
+    values = Array.new
+    args.each { |key| values << self[key] }
+    values
+  end
+
+  # see Hash#to_a
+  def to_a
+    aux = []
+    self.each do |key,value|
+      aux << [ key, value ]
+    end
+    aux
+  end
+
+  # see Hash#include?
+  def include?(key)
+    super(encode(key))
+  end
+
+  alias :regular_delete_if :delete_if
+
+  # see Hash#delete_if
+  def delete_if(&block)
+    self.regular_delete_if do |key, value|
+      block.call( decode(key), value)
+    end
+  end
+
+  # Deletes every key-value pair for which block evaluates to false.
+  def delete_unless #:yield:
+    delete_if{ |key, value| ! yield(key, value) }
+  end
+
+end # class TofuHash

data/lib/tofuhash/tofukey.rb

@@ -0,0 +1,90 @@
+# TofuKey
+# 
+# Links: 
+# * readme.txt[link:files/readme_txt.html]
+# * source: http://github.com/ghouston/tofuhash/tree/master
+#
+# For use with TofuHash.  A wrapper for the key of a Hash which will alter the behavior of keys.
+# The behavior provided by default is case-insensitive, and indifferent access for strings and symbols.
+# By subclassing TofuHash, you can create your own behavior.
+#
+# License:
+#
+# (The MIT License + Free Software Foundation Advertising Prohibition)
+#
+# Copyright (c) 2007 Gregory N. Houston
+#
+# 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.
+#
+# Except as contained in this notice, the name(s) of the above copyright holders
+# shall not be used in advertising or otherwise to promote the sale, use or other
+# dealings in this Software without prior written authorization.
+#
+class TofuKey
+  attr_reader :original_key, :coded_key
+
+  # preserve the key (Strings are cloned and frozen just like Hash's behavior); then encodes the key for fast comparison
+  def initialize( key )
+    if key.instance_of? String
+      @original_key = key.clone.freeze
+    else
+      @original_key = key
+    end
+    encode
+  end
+
+  # stores a @coded_key which is used for quick comparison and as the hash key.  the default encoding will
+  # convert Symbols to downcased strings; anything responding to downcase is converted via downcase.
+  def encode
+    if @original_key.instance_of? Symbol
+      @coded_key = @original_key.to_s.downcase
+    elsif @original_key.respond_to? :downcase
+      @coded_key = @original_key.downcase
+    else
+      @coded_key = @original_key
+    end
+  end
+
+  # returns the preserved key
+  def decode
+    @original_key
+  end
+
+  # get the hash of the key, which calls #hash on the encoded key. 
+  def hash
+    @coded_key.hash
+  end
+
+  # compares the encoded key to another object.  
+  # 
+  # given symbols are converted to downcase strings before comparison.
+  # given objects which respond to downcase are downcased before comparison.
+  # given TofuKey will compare the encoded keys.
+  def eql? obj
+    if obj.instance_of? Symbol
+      @coded_key.eql?( obj.to_s.downcase )
+    elsif obj.instance_of? TofuKey
+      @coded_key.eql?( obj.coded_key )
+    elsif obj.respond_to? :downcase
+      @coded_key.eql?( obj.downcase )
+    else
+      @coded_key.eql?( obj )
+    end
+  end
+end

data/lib/tofuhash.rb

@@ -0,0 +1,44 @@
+# TofuHash 
+#
+# Links: 
+# * readme.txt[link:files/readme_txt.html]
+# * source: http://github.com/ghouston/tofuhash/tree/master
+#
+# A varient of Hash which can change the lookup behavior of keys.  
+# The default TofuHash will match Symbol and String without reguard
+# to case.  By subclassing TofuKey, this behavior can be changed.
+#
+# License:
+#
+# (The MIT License + Free Software Foundation Advertising Prohibition)
+#
+# Copyright (c) 2007 Gregory N. Houston
+#
+# 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.
+#
+# Except as contained in this notice, the name(s) of the above copyright holders
+# shall not be used in advertising or otherwise to promote the sale, use or other
+# dealings in this Software without prior written authorization.
+#
+unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  $:.unshift(File.expand_path(File.dirname(__FILE__)))
+end
+
+require 'tofuhash/tofukey'
+require 'tofuhash/tofuhash'

data/readme.txt

@@ -0,0 +1,100 @@
+= TofuHash
+  by Gregory N. Houston
+  
+TofuHash makes it possible to use a Hash without having to
+worry about the differences between using String, Symbol,
+uppercase and downcase for the keys.
+TofuHash is both a case-insensitive Hash, and indifferent
+to access by String or Symbol.
+
+for Example:
+
+ require 'tofuhash'
+ h = TofuHash[ :aSymbol => "symbol", "MixedCaseString" => "string", 11 => "number" ]
+ puts h["asymbol"]         #=> "symbol"
+ puts h[:mixedCaseString]  #=> "string"
+ puts h[11]                #=> "number"
+
+Version:: 0.1.0 A useful and well tested subset of Hash methods is available.
+
+Tested to work with:
+Ruby 1.8.6
+Ruby 1.9.1
+
+How is TofuHash differenct 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
+  behavior can be changed by creating TofuHash and providing an alternative
+  version of TofuKey.
+
+* TofuHash adds the method TofuHash#delete_unless
+
+== Links:
+
+Start Here:: http://tofuhash.rubyforge.org
+
+Project:: http://rubyforge.org/projects/tofuhash
+Documents:: http://tofuhash.rubyforge.org
+RubyGems:: Install with: <b>gem install tofuhash</b>
+Download:: Download from RubyForge at http://rubyforge.org/projects/tofuhash/
+Authors Blog::   http://ghouston.blogspot.com
+Browse Source:: link:rcov/index.html
+Source code is hosted on Github at: http://github.com/ghouston/tofuhash/tree/master
+
+== LICENSE:
+
+(The MIT License + Free Software Foundation Advertising Prohibition)
+
+Copyright (c) 2007 Gregory N. Houston
+
+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.
+
+Except as contained in this notice, the name(s) of the above copyright holders
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization.
+
+The file test-tofuhash.rb is released under the Ruby License since it
+contains source code based on Ruby's released source.
+
+== Credits:
+
+Inspired by:
+* http://pastie.caboo.se/154304 and used with Stefan Rusterholz's permission;
+* HashWithIndifferentAccess in Rail's ActiveSupport.
+
+Contributors:
+* Greg Houston (http://ghouston.blogspot.com) original release and project maintainer
+* Nacho Caballero (http://github.com/nachocab/)  added #to_a, #delete_if, #delete_unless, #include?
+
+== Release History:
+
+Feb 28 2009 - 0.1.0 release on rubyforge.  Added gem, rdoc, rcov output.
+Added TofuHash::Version module
+
+Feb 15 2009 - 0.0.2 released on git hub.  Merged in pull request from 
+http://github.com/nachocab/tofuhash/tree/master [Thanks nachocab!]
+nachocab added to_a, delete_if, delete_unless, include? methods.  nachocab also
+updated the exception raised when TofuHash#initialize is called with both
+a default value and default block.  It now raises "wrong number of arguments"
+which matches the behavior of Hash. I (ghouston) tweaked the test cases to match
+the examples from Hash's ri documentation.
+
+Dec 12 2008 - 0.0.1 released on git hub.  Working solution, only more complete
+testing is needed.  Know issues: a) Hash doesn't know how to compare with TofuHash.

data/test/test-tofuhash.rb

@@ -0,0 +1,285 @@
+require 'test/unit'
+require 'pp'
+require 'lib/tofuhash'
+
+=begin rdoc
+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.
+
+License:
+
+tofuhash.rb is released under the MIT License + Free Software Foundation
+Advertising Prohibition.  see readme.txt 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
+
+module TofuHashTesting
+  class Test_TofuHash < Test::Unit::TestCase
+    def test_new
+      assert_raise ArgumentError do
+        h = TofuHash.new( :default ) { |hash,key| key }
+      end
+      
+      h = TofuHash.new
+      assert_equal( 0, h.size )
+      assert_equal( nil, h[:missing] )
+      
+      h = TofuHash.new( :default )
+      assert_equal( 0, h.size )
+      assert_equal( :default, h[:missing] )
+      
+      h = TofuHash.new do |hash,key|
+        assert_equal( :missing, key )
+        assert_same( h, hash )
+        hash[key] = :default_block
+      end
+      assert_equal( 0, h.size )
+      assert_equal( :default_block, h[:missing] )
+      assert_equal( 1, h.size )
+      assert_equal( [:missing], h.keys )
+      assert_equal( [:default_block], h.values )
+    end
+    
+    def test_values_at
+      h = TofuHash[21=>22,22=>24,23=>26,24=>28]
+      assert_equal([24,26], h.values_at( 22, 23 ))
+    end
+    
+    def test_keys
+      h = TofuHash["Alpha"=>2,:betA=>4,"gAmmA"=>6]
+      assert_equal( ["Alpha",:betA,"gAmmA"], h.keys.sort { |a,b| a.to_s <=> b.to_s } )
+    end
+
+    def test_square_bracket_initializer
+      h = TofuHash[:a=>:b, :c=>:d]
+      assert_equal( TofuHash, h.class )
+      assert_equal( :b, h[:a] )
+      assert_equal( :d, h[:c] )
+      assert_equal( 2, h.size )
+      
+      assert_raise ArgumentError do
+        h = TofuHash[1,2,3]
+      end
+      
+      h = TofuHash[:happy, :sad, :rich, :poor]
+      assert_equal( TofuHash, h.class )
+      assert_equal( :sad, h[:happy] )
+      assert_equal( :poor, h[:rich] )
+      assert_equal( 2, h.size )
+      h = TofuHash[]
+      assert_equal( 0, h.size )
+    end
+    
+    def test_store
+      h = TofuHash.new 
+      h.store('Alpha',1)
+      h.store(1,'ALPHA')
+      assert_equal( 1, h['AlPhA'] )
+      assert_equal( 'ALPHA', h[1] )
+      
+      h['Beta']=2
+      h[2] = 'Beta'
+      assert_equal( 2, h['bEtA'] )
+      assert_equal( 'Beta', h[2] )
+      
+      h[:Gamma]=3
+      h[3] = 'Gamma'
+      assert_equal( 3, h[:Gamma] )
+      assert_equal( 3, h['Gamma'] )
+      assert_equal( 3, h['gAmMA'] )
+      assert_equal( 3, h[:gAMMA] )
+    end
+    
+    def test_each
+      h = TofuHash[15,16, 11,12, 19,20, 17,18, 13,14]
+      h.each { |k,v| assert_equal( k+1, v ) }
+    end
+  end # class Test_TofuHash
+  
+  # copied from /ruby/src/ruby-1.8.6/test/ruby/test_hash.rb
+  # modified to use TofuHash instead of Hash
+  class TestHash < Test::Unit::TestCase
+    def test_hash
+      x = TofuHash[1=>2, 2=>4, 3=>6]
+      y = TofuHash[1, 2, 2, 4, 3, 6]
+      assert_equal(2, x[1])
+
+      assert(begin
+          for k,v in y
+            raise if k*2 != v
+          end
+          true
+        rescue
+          false
+        end)
+
+      assert_equal(3, x.length)
+      assert(x.has_key?(1))
+      assert(x.has_value?(4))
+      assert_equal([4,6], x.values_at(2,3))
+      assert_equal(TofuHash[1=>2, 2=>4, 3=>6], x)
+
+      z = y.keys.join(":")
+      assert_equal("1:2:3", z)
+
+      z = y.values.join(":")
+      assert_equal("2:4:6", z)
+      assert_equal(x, y)
+
+      y.shift
+      assert_equal(2, y.length)
+
+      z = [1,2]
+      y[z] = 256
+      assert_equal(256, y[z])
+
+      x = TofuHash.new(0)
+      x[1] = 1
+      assert_equal(1, x[1])
+      assert_equal(0, x[2])
+
+      x = TofuHash.new([])
+      assert_equal([], x[22])
+      assert_same(x[22], x[22])
+
+      x = TofuHash.new{[]}
+      assert_equal([], x[22])
+      assert_not_same(x[22], x[22])
+
+      x = TofuHash.new{|h,k| z = k; h[k] = k*2}
+      z = 0
+      assert_equal(44, x[22])
+      assert_equal(22, z)
+      z = 0
+      assert_equal(44, x[22])
+      assert_equal(0, z)
+      x.default = 5
+      assert_equal(5, x[23])
+
+      x = TofuHash.new
+      def x.default(k)
+        k = decode(k)
+        $z = k
+        self[k] = k*2
+      end
+      $z = 0
+      assert_equal(44, x[22])
+      assert_equal(22, $z)
+      $z = 0
+      assert_equal(44, x[22])
+      assert_equal(0, $z)
+    end
+
+    class MyClass
+      attr_reader :str
+      def initialize(str)
+        @str = str
+      end
+      def eql?(o)
+        o.is_a?(MyClass) && str == o.str
+      end
+      def hash
+        @str.hash
+      end
+    end
+
+    def test_ri_hash_code
+      a = MyClass.new("some string")
+      b = MyClass.new("some string")
+      assert( a.eql?( b ) )  #=> true
+
+      h = TofuHash.new #was: h={}
+
+      h[a] = 1
+      assert_equal( h[a],1 )      #=> 1
+      assert_equal( h[b],1 )      #=> 1
+
+      h[b] = 2
+      assert_equal( h[a],2 )      #=> 2
+      assert_equal( h[b],2 )      #=> 2
+    end
+
+    def test_ri_hash_new_code
+      h = TofuHash.new("Go Fish")
+      h["a"] = 100
+      h["b"] = 200
+      assert_equal( h["a"], 100 )           #=> 100
+      assert_equal( h["c"], "Go Fish" )           #=> "Go Fish"
+      # The following alters the single default object
+      assert_equal( h["c"].upcase!, "GO FISH" )   #=> "GO FISH"
+      assert_equal( h["d"], "GO FISH" )           #=> "GO FISH"
+      assert_equal( h.keys, ["a","b"] )           #=> ["a", "b"]
+
+      # While this creates a new default object each time
+      h = TofuHash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
+      assert_equal( h["c"], "Go Fish: c" )           #=> "Go Fish: c"
+      assert_equal( h["c"].upcase!, "GO FISH: C" )   #=> "GO FISH: C"
+      assert_equal( h["d"], "Go Fish: d" )           #=> "Go Fish: d"
+      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}
+    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_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_delete_if
+      h =  TofuHash["a" => 100, "b" => 200,  "c" => 300]
+      h.delete_if { |key,value| key >= 'b' }
+      assert_equal TofuHash['a' => 100], h
+    end
+
+    def test_delete_unless
+      hash =  TofuHash["a" => 2, "b" => 1]
+      hash.delete_unless { |k,v| k == 'b' }
+      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.
+
+    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
+    end
+  end # class TestHash
+end # module TofuHash

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+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
+summary: TofuHash, a Hash that is case-insensitive and treats symbols and strings as equals (customizable); always preserving the original key.
+require_paths: 
+- lib
+email: 
+homepage: http://tofuhash.rubyforge.org/
+rubyforge_project: tofuhash
+description: TofuHash, a Hash that is case-insensitive and treats symbols and strings as equals (customizable); always preserving the original key.
+autorequire: tofuhash
+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: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Gregory N. Houston
+files: 
+- lib/tofuhash/tofuhash.rb
+- lib/tofuhash/tofukey.rb
+- lib/tofuhash.rb
+- test/test-tofuhash.rb
+- readme.txt
+test_files: 
+- test/test-tofuhash.rb
+rdoc_options: 
+- --main
+- readme.txt
+- --title
+- TofuHash (rdoc)
+extra_rdoc_files: 
+- readme.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+