hashery 1.0.0

data/meta/authors

@@ -0,0 +1,3 @@
+Thomas Sawyer
+Jan Molic
+George Moschovitis

data/meta/created

@@ -0,0 +1 @@
+2010-04-21

data/meta/description

@@ -0,0 +1,5 @@
+The Facets Hashery is collection of Hash-like classes, spun-off
+from the original Ruby Facets library. Included are the widely
+used OrderedHash, the related but more featured Dictionary
+class, a number of _open_ classes, similiar to the standard 
+OpenStruct and variations on the standard Hash.

data/meta/homepage

@@ -0,0 +1 @@
+http://rubyworks.github.com/hashery

data/meta/license

@@ -0,0 +1 @@
+MIT

data/meta/name

@@ -0,0 +1 @@
+hashery

data/meta/release

@@ -0,0 +1 @@
+2009-06-26

data/meta/repository

@@ -0,0 +1 @@
+git://github.com/rubyworks/hashery.git

data/meta/suite

@@ -0,0 +1 @@
+rubyworks

data/meta/summary

@@ -0,0 +1 @@
+Facets bread collection of Hash-like classes.

data/meta/version

@@ -0,0 +1 @@
+1.0.0

data/test/case_dictionary.rb

@@ -0,0 +1,142 @@
+require 'hashery/dictionary.rb'
+require 'ae/legacy'
+
+TestCase Dictionary do
+
+  Unit :create do
+    d = Dictionary['z', 1, 'a', 2, 'c', 3]
+    assert_equal( ['z','a','c'], d.keys )
+  end
+
+  Unit :[]= do
+    d = Dictionary.new
+    d['z'] = 1
+    d['a'] = 2
+    d['c'] = 3
+    assert_equal( ['z','a','c'], d.keys )
+  end
+
+  Unit :push do
+    d = Dictionary['a', 1, 'c', 2, 'z', 3]
+    assert( d.push('end', 15) )
+    assert_equal( 15, d['end'] )
+    assert( ! d.push('end', 30) )
+    assert( d.unshift('begin', 50) )
+    assert_equal( 50, d['begin'] )
+    assert( ! d.unshift('begin', 60) )
+    assert_equal( ["begin", "a", "c", "z", "end"], d.keys )
+    assert_equal( ["end", 15], d.pop )
+    assert_equal( ["begin", "a", "c", "z"], d.keys )
+    assert_equal( ["begin", 50], d.shift )
+  end
+
+  Unit :insert do
+    # front
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
+    assert_equal( 4, d.insert(0,'d',4) )
+    assert_equal( r, d )
+    # back
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( 4, d.insert(-1,'d',4) )
+    assert_equal( r, d )
+  end
+
+  Unit :update do
+    # with other orderred hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = Dictionary['d', 4]
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.update(c) )
+    assert_equal( r, d )
+    # with other hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = { 'd' => 4 }
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.update(c) )
+    assert_equal( r, d )
+  end
+
+  Unit :merge do
+    # with other orderred hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = Dictionary['d', 4]
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.merge(c) )
+    # with other hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = { 'd' => 4 }
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.merge(c) )
+  end
+
+  Unit :order_by do
+    d = Dictionary['a', 3, 'b', 2, 'c', 1]
+    d.order_by{ |k,v| v }
+    assert_equal( [1,2,3], d.values )
+    assert_equal( ['c','b','a'], d.keys )
+  end
+
+  Unit :[]= do
+    d = Dictionary[]
+    d[:a] = 1
+    d[:c] = 3
+    assert_equal( [1,3], d.values )
+    d[:b,1] = 2
+    assert_equal( [1,2,3], d.values )
+    assert_equal( [:a,:b,:c], d.keys )
+  end
+
+  Unit :reverse! do
+    d = Dictionary['z', 1, 'a', 2, 'c', 3]
+    d.reverse!
+    assert_equal( ['c','a','z'], d.keys )
+  end
+
+  Unit :enumerable do
+    d = Dictionary[]
+    d[:a] = "a"
+    d[:c] = "b"
+    assert_equal( ["A","B"], d.collect{|k,v| v.capitalize} )
+  end
+
+  Unit :autohash do
+    d = Dictionary.new{ |hash,key| hash[key] = 0 }
+    d[:a] = 0
+    d[:b] += 1
+    assert_equal([0, 1], d.values)
+    assert_equal([:a,:b], d.keys)
+  end
+
+  Unit :dup => "with array values" do
+    d = Dictionary.new
+    d.dup
+    d[:a]=['t',5]
+    assert_equal(d, d.dup)
+  end
+
+  Unit :first do
+    d = Dictionary[]
+    d[:a] = "a"
+    d[:b] = "b"
+    d[:c] = "c"
+    assert_equal( "a"         , d.first )
+    assert_equal( []          , d.first(0) )
+    assert_equal( ["a"]       , d.first(1) )
+    assert_equal( ["a", "b"]  , d.first(2) )
+  end
+
+  Unit :last do
+    d = Dictionary[]
+    d[:a] = "a"
+    d[:b] = "b"
+    d[:c] = "c"
+    assert_equal( "c"         , d.last )
+    assert_equal( []          , d.last(0) )
+    assert_equal( ["c"]       , d.last(1) )
+    assert_equal( ["b", "c"]  , d.last(2) )
+  end
+
+end
+

data/test/case_opencascade.rb

@@ -0,0 +1,68 @@
+require 'hashery/opencascade'
+require 'ae/legacy' # bacause imitation BasicObject sucks
+
+TestCase OpenCascade do
+
+  Unit :new do
+    o = OpenCascade.new(:a=>1)
+    assert_equal(OpenCascade.new, o.assert)
+  end
+
+  Unit :[] => "initialization" do
+    o = OpenCascade[:a=>1,:b=>2]
+    assert_equal(1, o.a)
+    assert_equal(2, o.b)
+  end
+
+  Unit :[] => "mutlt-depth lookup" do
+    o = OpenCascade[:a=>1,:b=>2,:c=>{:x=>9}]
+    assert_equal(9, o.c.x)
+  end
+
+  Unit :[] => "basic assignment" do
+    o = OpenCascade.new
+    o[:a] = 1
+    assert_equal(1, o.a)
+  end
+
+  Unit :[] => "basic assignment with primed OpenCascade" do
+    o = OpenCascade[:a=>1]
+    o[:b] = 2
+    assert_equal({:a=>1,:b=>2}, o.to_h)
+  end
+
+  Unit :to_a do
+    o = OpenCascade[:a=>1,:b=>2]
+    assert_equal([[:a,1], [:b,2]], o.to_a)
+  end
+
+  Unit :to_h do
+    o = OpenCascade[:a=>1]
+    assert_equal({:a=>1}, o.to_h)
+  end
+
+  Unit :merge! do
+    o = OpenCascade[:f0=>"f0"]
+    h = { :h0=>"h0" }
+    r = OpenCascade[:f0=>"f0", :h0=>"h0"]
+    assert_equal(r, o.merge!(h))
+    assert_equal({:f0=>"f0", :h0=>"h0"}, h.merge(o))
+  end
+
+  Unit :update! do
+    o = OpenCascade[:f1=>"f1"]
+    h = { :h1=>"h1" }
+    o.update!(h)
+    h.update(o)
+    assert_equal(OpenCascade[:f1=>"f1", :h1=>"h1"], o)
+    assert_equal({:f1=>"f1", :h1=>"h1"}, h)
+  end
+
+  Unit :method_missing => "writer and reader" do
+    o = OpenCascade.new
+    10.times{ |i| o.__send__("n#{i}=", 1 ) }
+    10.times{ |i| assert_equal(1, o.__send__("n#{i}")) }
+  end
+
+end
+

data/test/case_openhash.rb

@@ -0,0 +1,18 @@
+require 'hashery/openhash'
+
+TestCase OpenHash do
+
+  Unit :new do
+    o = OpenHash.new(:a=>1, :b=>2)
+    o.a.assert == 1
+    o.b.assert == 2
+  end
+
+  Unit :new do
+    o = OpenHash.new(:a=>1, :b=>2)
+    o.a.assert == 1
+    o.b.assert == 2
+  end
+
+end
+

data/test/case_openobject.rb

@@ -0,0 +1,130 @@
+require 'hashery/openobject'
+
+TestCase OpenObject do
+
+  Unit :respond_to? do
+    o = OpenObject.new
+    assert{ o.respond_to?(:key?) }
+  end
+
+  Unit :is_a? do
+    assert OpenObject[{}].is_a?(Hash)
+    assert OpenObject[{}].is_a?(OpenObject)
+  end
+
+  Unit :[] => "subhash access" do
+    o = OpenObject[:a=>1,:b=>{:x=>9}]
+    assert{ o[:b][:x] == 9 }
+    assert{ o.b[:x] == 9 }
+  end
+
+  Unit :[] => "indifferent key access" do
+    o = OpenObject["a"=>1,"b"=>{:x=>9}]
+    assert{ o["a"] == 1 }
+    assert{ o[:a] == 1 }
+    assert{ o["b"] == {:x=>9} }
+    assert{ o[:b] == {:x=>9} }
+    assert{ o["b"][:x] == 9 }
+    assert{ o[:b]["x"] == nil }
+  end
+
+  Unit :[]= => "setting first entry" do
+    f0 = OpenObject.new
+    f0[:a] = 1
+    assert{ f0.to_h == {:a=>1} }
+  end
+
+  Unit :[]= => "setting an additional entry" do
+    f0 = OpenObject[:a=>1]
+    f0[:b] = 2
+    assert{ f0.to_h == {:a=>1,:b=>2} }
+  end
+
+  Unit :method_missing => "reading entries" do
+    f0 = OpenObject[:class=>1]
+    assert{ f0.class  == 1 }
+  end
+
+  Unit :method_missing => "setting entries" do
+    fo = OpenObject.new
+    9.times{ |i| fo.__send__("n#{i}=", 1) }
+    9.times{ |i|
+      assert( fo.__send__("n#{i}") == 1 )
+    }
+  end
+
+  Unit :method_missing => "using bang" do
+    o = OpenObject.new
+    o.a = 10
+    o.b = 20
+    h = {}
+    o.each!{ |k,v| h[k] = v + 10 }
+    assert( h == {:a=>20, :b=>30} )
+  end
+
+  #Unit :as_hash do
+  #  f0 = OpenObject[:f0=>"f0"]
+  #  h0 = { :h0=>"h0" }
+  #  assert{ OpenObject[:f0=>"f0", :h0=>"h0"] == f0.as_hash.merge(h0) }
+  #  assert{  {:f0=>"f0", :h0=>"h0"} == h0.merge(f0) }
+  #end
+
+  Unit :as_hash do
+    f1 = OpenObject[:f1=>"f1"]
+    h1 = { :h1=>"h1" }
+    f1.as_hash.update(h1)
+    h1.update(f1)
+    assert{ f1 == OpenObject[:f1=>"f1", :h1=>"h1"] }
+    assert{ h1 == {:f1=>"f1", :h1=>"h1"} }
+  end
+
+  Unit :<< => "passing a hash" do
+    fo = OpenObject.new
+    fo << {:a=>1,:b=>2}
+    assert{ fo.to_h == {:a=>1, :b=>2} }
+  end
+
+  Unit :<< => "passing a pair" do
+    fo = OpenObject.new
+    fo << [:a, 1]
+    fo << [:b, 2]
+    assert( fo.to_h == {:a=>1, :b=>2} )
+  end
+
+  Unit :to_h do
+    ho = {}
+    fo = OpenObject.new
+    5.times{ |i| ho["n#{i}".to_sym] = 1 }
+    5.times{ |i| fo.__send__("n#{i}=", 1) }
+    assert{ fo.to_h == ho  }
+  end
+
+  Unit :to_h => "OpenObject within OpenObject" do
+    o = OpenObject.new
+    o.a = 10
+    o.b = 20
+    o.x = OpenObject.new
+    o.x.a = 100
+    o.x.b = 200
+    o.x.c = 300
+    assert{ o.to_h == {:a=>10, :b=>20, :x=>{:a=>100, :b=>200, :c=>300}} }
+  end
+
+  Unit :to_proc do
+    p = lambda { |x| x.word = "Hello" }
+    o = OpenObject[:a=>1,:b=>2]
+    assert{ Proc === o.to_proc }
+  end
+
+end
+
+TestCase Proc do
+
+  Unit :to_openobject do
+    p = lambda { |x| x.word = "Hello" }
+    o = p.to_openobject
+    assert{ o.word == "Hello" }
+  end
+
+end
+

data/test/case_stash.rb

@@ -0,0 +1,131 @@
+require 'hashery/stash'
+
+TestCase Stash do
+
+  Unit :[] => 'class level fetch' do
+    s = Stash[:a=>1, :b=>2]
+    assert(s)
+  end
+
+  Unit :[] => 'instance level fetch' do
+    s = Stash[:a=>1, :b=>2]
+    s[:a].assert == 1
+    s[:b].assert == 2
+    s['a'].assert == 1
+    s['b'].assert == 2
+  end
+
+  Unit :[]= => '' do
+    s = Stash.new
+    s[:a] = 1
+    s[:b] = 2
+    s[:a].assert == 1
+    s[:b].assert == 2
+    s['a'].assert == 1
+    s['b'].assert == 2
+  end
+
+  Unit :initialize do
+    s = Stash.new
+    assert(s)
+  end
+
+  Unit :to_hash do
+    s = Stash[:a=>1, :b=>2]
+    s.to_hash.assert == {'a'=>1, 'b'=>2}
+  end
+
+  Unit :to_h do
+    s = Stash[:a=>1, :b=>2]
+    s.to_h.assert == {'a'=>1, 'b'=>2}
+  end
+
+  Unit :replace do
+    s = Stash.new
+    s.replace(:a=>1, :b=>2)
+    s.to_h.assert == {'a'=>1, 'b'=>2}
+  end
+
+  Unit :delete do
+    s = Stash[:a=>1, :b=>2]
+    s.delete(:a)
+    s.to_h.assert == {'b'=>2}
+  end
+
+  Unit :each do
+    s = Stash[:a=>1, :b=>2]
+    s.each do |k,v|
+      String.assert === k
+    end
+  end
+
+  Unit :store => '' do
+    s = Stash.new
+    s.store(:a, 1)
+    s.to_h.assert == {'a'=>1}
+  end
+
+  Unit :update => '' do
+    s1 = Stash[:a=>1,:b=>2]
+    s2 = Stash[:c=>3,:d=>4]
+    s1.update(s2)
+    s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
+  end
+
+  Unit :rekey => '' do
+    s = Stash[:a=>1,:b=>2,:c=>3]
+    x = s.rekey{ |k| k.upcase }
+    x.to_h.assert == {'A'=>1,'B'=>2,'C'=>3}
+  end
+
+  Unit :rekey! => '' do
+    s = Stash[:a=>1,:b=>2,:c=>3]
+    s.rekey!{ |k| k.upcase }
+    s.to_h.assert == {'A'=>1,'B'=>2,'C'=>3}
+  end
+
+  Unit :key? => '' do
+    s = Stash[:a=>1]
+    s.assert.key?(:a)
+    s.assert.key?('a')
+  end
+
+  Unit :has_key? => '' do
+    s = Stash[:a=>1]
+    s.assert.has_key?(:a)
+    s.assert.has_key?('a')
+  end
+
+  Unit :<< => '' do
+    s = Stash.new
+    s << [:a, 1]
+    s << [:b, 2]
+    s.to_h.assert == {'a'=>1, 'b'=>2}
+  end
+
+  Unit :merge! => '' do
+    s1 = Stash[:a=>1,:b=>2]
+    s2 = Stash[:c=>3,:d=>4]
+    s1.merge!(s2)
+    s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
+  end
+
+  Unit :values_at => '' do
+    s = Stash[:a=>1,:b=>2,:c=>3]
+    s.values_at(:a, :b).assert == [1,2]
+    s.values_at('a','b').assert == [1,2]
+  end
+
+  Unit :fetch => '' do
+    s = Stash[:a=>1,:b=>2,:c=>3]
+    s.fetch(:a).assert == 1
+    s.fetch('a').assert == 1
+  end
+
+  Unit :convert_key => '' do
+    s = Stash.new
+    s.pry.convert_key(:a).assert == 'a'
+  end
+
+end
+