hashery 1.4.0 → 1.5.0

data/lib/hashery/static_hash.rb

@@ -1 +1,48 @@
-require 'hashery/statichash'
+# = StaticHash
+#
+# A Hash object which raises an error if any
+# previously-defined key attempts to be set again.
+#
+# == Synopsis
+#
+#   foo = StaticHash.new
+#   foo['name'] = 'Tom'    #=> 'Tom'
+#   foo['age']  = 30       #=> 30
+#   foo['name'] = 'Bob'
+#
+# _produces_
+#
+#   ArgumentError: Duplicate key for StaticHash -- 'name'
+#
+# == Credit
+#
+# StaticHash has it's orgins in Gavin Kistner's WriteOnceHash
+# class found in his +basiclibrary.rb+ script.
+
+class StaticHash < Hash
+
+  # Set a value for a key. Raises an error if that key already
+  # exists with a different value.
+
+  def []=(key, value)
+    if key?(key) && self[key] != value
+      raise ArgumentError, "Duplicate key for StaticHash -- #{key.inspect}"
+    end
+    super(key, value)
+  end
+
+  #
+  def update(hash)
+    dups = (keys | hash.keys)
+    if dups.empty?
+      super(hash)
+    else
+      raise ArgumentError, "Duplicate key for StaticHash -- #{dups.inspect}"
+    end
+  end
+
+  #
+  alias_method :merge!, :update
+
+end
+

data/lib/hashery/statichash.rb

@@ -1,48 +1 @@
-# = StaticHash
-#
-# A Hash object which raises an error if any
-# previously-defined key attempts to be set again.
-#
-# == Synopsis
-#
-#   foo = Hash::Static.new
-#   foo['name'] = 'Tom'    #=> 'Tom'
-#   foo['age']  = 30       #=> 30
-#   foo['name'] = 'Bob'
-#
-# _produces_
-#
-#   ArgumentError: Duplicate key for StaticHash -- 'name'
-#
-# == Credit
-#
-# StaticHash has it's orgins in Gavin Kistner's WriteOnceHash
-# class found in his +basiclibrary.rb+ script.
-
-class StaticHash < Hash
-
-  # Set a value for a key. Raises an error if that key already
-  # exists with a different value.
-
-  def []=(key, value)
-    if key?(key) && self[key] != value
-      raise ArgumentError, "Duplicate key for StaticHash -- #{key.inspect}"
-    end
-    super(key, value)
-  end
-
-  #
-  def update(hash)
-    dups = (keys | hash.keys)
-    if dups.empty?
-      super(hash)
-    else
-      raise ArgumentError, "Duplicate key for StaticHash -- #{dups.inspect}"
-    end
-  end
-
-  #
-  alias_method :merge!, :update
-
-end
-
+require 'hashery/static_hash'

data/qed/06_opencascade.rdoc

@@ -5,36 +5,36 @@ significant ways.
 
    require 'hashery/opencascade'
 
-The main reason this class is labeled "cascade", every internal
+The reason this class is labeled "cascade", is that every internal
 Hash is transformed into an OpenCascade dynamically upon access.
-This makes it easy to create "cascading" references.
+This makes it easy to create _cascading_ references.
 
     h = { :x => { :y => { :z => 1 } } }
     c = OpenCascade[h]
-    c.x.y.z.assert == 1
+    assert c.x.y.z == 1
 
 As soon as you access a node it automatically becomes an OpenCascade.
 
     c = OpenCascade.new
-    c.r.assert.is_a? OpenCascade
-    c.a.b.assert.is_a? OpenCascade
+    assert c.r.is_a?(OpenCascade)
+    assert c.a.b.is_a?(OpenCascade)
 
 But if you set a node, then that will be it's value.
 
     c.a.b = 4
-    c.a.b.assert == 4
+    assert c.a.b == 4
 
 To query a node without causing the auto-creation of an OpenCasade
 object, use the ?-mark.
 
-   c.a.z?.assert == nil
+   assert c.a.z? == nil
 
 OpenCascade also transforms Hashes within Arrays.
 
   h = { :x=>[ {:a=>1}, {:a=>2} ], :y=>1 }
   c = OpenCascade[h]
-  c.x.first.a.assert == 1
-  c.x.last.a.assert == 2
+  assert c.x.first.a == 1
+  assert c.x.last.a == 2
 
 Like OpenObject, OpenCascade allows you to insert entries as array
 pairs.
@@ -43,15 +43,15 @@ pairs.
    c << [:x,8]
    c << [:y,9]
 
-   c.x.assert == 8
-   c.y.assert == 9
+   assert c.x == 8
+   assert c.y == 9
 
 Finally, you can call methods ending in a !-mark to access the
 underlying hash (Note that these differ in behavior from the
 built-in !-methods).
 
    bk = c.map!{ |k,v| k.to_s.upcase }
-   bk.sort.assert ==  ['X', 'Y']
+   bk.sort.assert == ['X', 'Y']
 
 So you can see that for the most an OpenCascade is just like
 OpenObject, but it allows you to conveniently build open sub-layers. 

data/test/case_association.rb

@@ -1,27 +1,41 @@
+require 'lemon'
+require 'ae'
+
 require 'hashery/association'
 
-Case Association do
+testcase Association do
 
-  Unit :new do
-    Association.new(:A, :B)
+  class_method :new do
+    test do
+      Association.new(:A, :B)
+    end
   end
 
-  Unit :to_ary do
-    k,v = [],[]
-    ohash = [ 'A' >> '3', 'B' >> '2', 'C' >> '1' ]
-    ohash.each { |e1,e2| k << e1 ; v << e2 }
-    k.assert == ['A','B','C']
-    v.assert == ['3','2','1']
+  method :to_ary do
+    test do
+      k,v = [],[]
+      ohash = [ 'A' >> '3', 'B' >> '2', 'C' >> '1' ]
+      ohash.each { |e1,e2| k << e1 ; v << e2 }
+      k.assert == ['A','B','C']
+      v.assert == ['3','2','1']
+    end
   end
 
-  Unit :index do
-    complex = [ 'Drop Menu' >> [ 'Button 1', 'Button 2', 'Button 3' ], 'Help' ]
-    complex[0].index.assert == 'Drop Menu'
+  method :index do
+    test do
+      complex = [ 'Drop Menu' >> [ 'Button 1', 'Button 2', 'Button 3' ], 'Help' ]
+      complex[0].index.assert == 'Drop Menu'
+    end
   end
 
-  Unit :associations do
-    complex = [ :a >> :b, :a >> :c ]
-    :a.associations.assert == [ :b, :c ]
+end
+
+testcase Object do
+  method :associations do
+    test do
+      complex = [ :a >> :b, :a >> :c ]
+      :a.associations.assert == [ :b, :c ]
+    end
   end
 
 end

data/test/case_basicstruct.rb

@@ -0,0 +1,192 @@
+require 'lemon'
+require 'ae'
+require 'ae/legacy'
+
+require 'hashery/basic_struct'
+
+testcase BasicStruct do
+  include AE::Legacy::Assertions
+
+  method :respond_to? do
+    test do
+      o = BasicStruct.new
+      t = o.respond_to?(:key?)
+      assert t
+    end
+  end
+
+  method :is_a? do
+    test do
+      assert BasicStruct[{}].is_a?(Hash)
+      assert BasicStruct[{}].is_a?(BasicStruct)
+    end
+  end
+
+  method :[] do
+    test "subhash access" do
+      o = BasicStruct[:a=>1,:b=>{:x=>9}]
+      assert( o[:b][:x] == 9 )
+      assert( o.b[:x] == 9 )
+    end
+
+    test "indifferent key access" do
+      o = BasicStruct["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
+  end
+
+  method :[]= do
+    test "setting first entry" do
+      f0 = BasicStruct.new
+      f0[:a] = 1
+      assert( f0.to_h == {:a=>1} )
+    end
+
+    test "setting an additional entry" do
+      f0 = BasicStruct[:a=>1]
+      f0[:b] = 2
+      assert( f0.to_h == {:a=>1,:b=>2} )
+    end
+  end
+
+  method :method_missing do
+    test "reading entries" do
+      f0 = BasicStruct[:class=>1]
+      assert( f0.class  == 1 )
+    end
+
+    test "setting entries" do
+      fo = BasicStruct.new
+      9.times{ |i| fo.__send__("n#{i}=", 1) }
+      9.times{ |i|
+        assert( fo.__send__("n#{i}") == 1 )
+      }
+    end
+
+    test "using bang" do
+      o = BasicStruct.new
+      o.a = 10
+      o.b = 20
+      h = {}
+      o.each!{ |k,v| h[k] = v + 10 }
+      assert( h == {:a=>20, :b=>30} )
+    end
+  end
+
+  #method :as_hash do
+  #  test do
+  #    f0 = BasicStruct[:f0=>"f0"]
+  #    h0 = { :h0=>"h0" }
+  #    assert( BasicStruct[:f0=>"f0", :h0=>"h0"] == f0.as_hash.merge(h0) )
+  #    assert(  {:f0=>"f0", :h0=>"h0"} == h0.merge(f0) )
+  #  end
+  #end
+
+  method :as_hash do
+    test do
+      f1 = BasicStruct[:f1=>"f1"]
+      h1 = { :h1=>"h1" }
+      f1.as_hash.update(h1)
+      assert( f1 == BasicStruct[:f1=>"f1", :h1=>"h1"] )
+    end
+  end
+
+  #method :as_hash do
+  #  test do
+  #    f1 = BasicStruct[:f1=>"f1"]
+  #    h1 = { :h1=>"h1" }
+  #    f1.as_hash.update(h1)
+  #    h1.update(f1)
+  #    assert( f1 == BasicStruct[:f1=>"f1", :h1=>"h1"] )
+  #    assert( h1 == {:f1=>"f1", :h1=>"h1"} )
+  #  end
+  #end
+
+  method :<< do
+    test "passing a hash" do
+      fo = BasicStruct.new
+      fo << {:a=>1,:b=>2}
+      assert( fo.to_h == {:a=>1, :b=>2} )
+    end
+
+    test "passing a pair" do
+      fo = BasicStruct.new
+      fo << [:a, 1]
+      fo << [:b, 2]
+      assert( fo.to_h == {:a=>1, :b=>2} )
+    end
+  end
+
+  method :to_h do
+    test do
+      ho = {}
+      fo = BasicStruct.new
+      5.times{ |i| ho["n#{i}".to_sym] = 1 }
+      5.times{ |i| fo.__send__("n#{i}=", 1) }
+      assert( fo.to_h == ho )
+    end
+    test "BasicStruct within BasicStruct" do
+      o = BasicStruct.new
+      o.a = 10
+      o.b = 20
+      o.x = BasicStruct.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
+  end
+
+  method :to_proc do
+    test do
+      #p = Proc.new{ |x| x.word = "Hello" }
+      o = BasicStruct[:a=>1,:b=>2]
+      assert( Proc === o.to_proc )
+    end
+  end
+
+end
+
+TestCase Hash do
+
+  method :to_basicstruct do
+    test do
+      h = {'a'=>1, 'b'=>2}
+      o = h.to_basicstruct
+      assert( o.a == 1 )
+      assert( o.b == 2 )
+    end
+  end
+
+  method :update do
+    test "by BasicStruct" do
+      raise NotImplementedError, "Ruby 1.8 does not know #to_hash."
+
+      h1 = { :h1=>"h1" }
+      f1 = BasicStruct[:f1=>"f1"]
+      h1.update(f1)
+      assert( h1 == {:f1=>"f1", :h1=>"h1"} )
+    end
+  end
+
+end
+
+=begin
+TestCase Proc do
+
+  method :to_basicstruct do
+    test do
+      p = lambda { |x| x.word = "Hello" }
+      o = p.to_basicstruct
+      assert( o.word == "Hello" )
+    end
+  end
+
+end
+=end
+

data/test/case_dictionary.rb

@@ -1,141 +1,181 @@
-require 'hashery/dictionary.rb'
+require 'lemon'
+require 'ae'
 require 'ae/legacy'
 
-TestCase Dictionary do
+require 'hashery/dictionary'
 
-  Unit :create do
-    d = Dictionary['z', 1, 'a', 2, 'c', 3]
-    assert_equal( ['z','a','c'], d.keys )
+testcase Dictionary do
+  include AE::Legacy::Assertions
+
+  class_method :[] do
+    test do
+      d = Dictionary['z', 1, 'a', 2, 'c', 3]
+      assert_equal( ['z','a','c'], d.keys )
+    end
+  end
+
+  class_method :new do
+    test "with default" 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
   end
 
-  Unit :[]= do
-    d = Dictionary.new
-    d['z'] = 1
-    d['a'] = 2
-    d['c'] = 3
-    assert_equal( ['z','a','c'], d.keys )
+  method :[] do
+    test do
+      d = Dictionary['a', 1]
+      d['a'].assert == 1
+    end
   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 )
+  method :[]= do
+    test do
+      d = Dictionary.new
+      d['z'] = 1
+      d['a'] = 2
+      d['c'] = 3
+      assert_equal( ['z','a','c'], d.keys )
+    end
   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 )
+  method :[]= do
+    test 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
   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 )
+  method :push do
+    test 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
   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) )
+  method :insert do
+    test "front" do
+      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 )
+    end
+    test "back" do
+      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
   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 )
+  method :update do
+    test "with other orderred hash" do
+      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 )
+    end
+    test "with other hash" do
+      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
   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 )
+  method :merge do
+    test "with other orderred hash" do
+      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) )
+    end
+    test "with other hash" do
+      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
   end
 
-  Unit :reverse! do
-    d = Dictionary['z', 1, 'a', 2, 'c', 3]
-    d.reverse!
-    assert_equal( ['c','a','z'], d.keys )
+  method :order_by do
+    test 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
   end
 
-  Unit :enumerable do
-    d = Dictionary[]
-    d[:a] = "a"
-    d[:c] = "b"
-    assert_equal( ["A","B"], d.collect{|k,v| v.capitalize} )
+  method :reverse! do
+    test do
+      d = Dictionary['z', 1, 'a', 2, 'c', 3]
+      d.reverse!
+      assert_equal( ['c','a','z'], d.keys )
+    end
   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)
+  method :collect do
+    test "enumerable method" do
+      d = Dictionary[]
+      d[:a] = "a"
+      d[:c] = "b"
+      r = d.collect{|k,v| v.capitalize}
+      r.assert == ["A","B"]
+    end
   end
 
-  Unit :dup => "with array values" do
-    d = Dictionary.new
-    d.dup
-    d[:a]=['t',5]
-    assert_equal(d, d.dup)
+  method :dup do
+    test "with array values" do
+      d = Dictionary.new
+      d.dup
+      d[:a]=['t',5]
+      assert_equal(d, d.dup)
+    end
   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) )
+  method :first do
+    test do
+      d = Dictionary[]
+      d[:a] = "a"
+      d[:b] = "b"
+      d[:c] = "c"
+      d.first.assert == "a"
+      d.first(0).assert == []
+      assert_equal ["a"]       , d.first(1)
+      assert_equal ["a", "b"]  , d.first(2)
+    end
   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) )
+  method :last do
+    test do
+      d = Dictionary[]
+      d[:a] = "a"
+      d[:b] = "b"
+      d[:c] = "c"
+      d.last.assert == "c"
+      d.last(0).assert == []
+      d.last(1).assert == ["c"]
+      d.last(2).assert == ["b", "c"]
+    end
   end
 
 end