facets 2.2.1 → 2.3.0

data/lib/{more → class}/facets/cachedelegator.rb

@@ -88,3 +88,6 @@ class Cache
   end
 
 end
+
+CacheDelegator = Cache
+

data/lib/{more → class}/facets/coroutine.rb

@@ -118,59 +118,3 @@ class Coroutine
 
 end
 
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_Coroutine < Test::Unit::TestCase
-
-    def test_run
-      assert_nothing_raised {
-
-        count = 100
-        input = (1..count).map { (rand * 10000).round.to_f / 100 }
-
-        @producer = Coroutine.new do |me|
-          loop do
-            1.upto(6) do
-              me[:last_input] = input.shift
-              me.resume(@printer)
-            end
-            input.shift  # discard every seventh input number
-          end
-        end
-
-        @printer = Coroutine.new do |me|
-          loop do
-            1.upto(8) do
-              me.resume(@producer)
-              if @producer[:last_input]
-                @producer[:last_input] = nil
-              end
-              me.resume(@controller)
-            end
-          end
-        end
-
-        @controller = Coroutine.new do |me|
-          until input.empty? do
-            me.resume(@printer)
-          end
-        end
-        @controller.run
-
-      }
-    end
-
-  end
-
-=end

data/lib/{more → class}/facets/infinity.rb

@@ -181,49 +181,3 @@ Inf = INFINITY
 PosInf = +INFINITY
 NegInf = -INFINITY
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class GeneralTest < Test::Unit::TestCase
-
-    def test_pos
-      assert_equal((1.0/0), INFINITY.to_f)
-      assert_equal(1, INFINITY<=>5)
-      assert_equal(1, INFINITY<=>"a")
-      assert_equal("PosInf", INFINITY.to_s)
-    end
-
-    def test_neg
-      assert_equal((-1.0/0), -INFINITY.to_f)
-      assert_equal(-1, -INFINITY<=>5)
-      assert_equal(-1, -INFINITY<=>"a")
-      assert_equal("NegInf", (-INFINITY).to_s)
-    end
-
-    def test_ord
-      assert_equal((-1.0/0), -INFINITY.to_f)
-      assert_equal(-1, 5<=>INFINITY)
-      assert_equal(1, 5<=>-INFINITY)
-    end
-
-    def test_eq
-      assert_equal(Inf, Inf)
-      assert_equal(-Inf, -Inf)
-      assert_equal(PosInf, PosInf)
-      assert_equal(NegInf, NegInf)
-      assert_not_equal(NaN, NaN)
-    end
-
-  end
-
-=end
-

data/lib/{more → class}/facets/linkedlist.rb

@@ -212,45 +212,3 @@ class LinkedList
 
 end
 
-
-
-=begin test
-
-  require 'test/unit'
-
-  class TC_LinkedList < Test::Unit::TestCase
-
-      @cache
-
-      def test_all
-          ll = nil
-          assert_nothing_raised('Failed while creating an LinkedList object.') { ll = LinkedList.new }
-          assert_kind_of(LinkedList,ll,'Strangely, the created object does not appear to be an LinkedList.')
-
-          assert_nothing_raised('Failed while pushing a value onto the linked list.') { ll.push 'a' }
-          ll.push 'b'
-          assert_nothing_raised('Failed while assigning a key/value to the linked list.') { ll['c'] = 3 }
-          assert_equal(3,ll.first, 'First element in the linked list appears to be the wrong one.')
-          assert_equal('b',ll.last, 'Last element in the linked list appears to be the wrong one.')
-          assert_nothing_raised('Failed while unshifting a value onto the linked list.') { ll.unshift 'd' }
-          assert_equal('d',ll.first, 'The prior unshift apparently failed.')
-          assert_equal('a',ll['a'], 'Accessing an element by key failed.')
-          assert_equal(4,ll.length, 'The length of the linked list appears to be incorrect.')
-          d = nil
-          assert_nothing_raised('Failed while deleting an element from the middle of the list.') { d = ll.delete('a') }
-          assert_equal('a',d, 'The prior delete returned the wrong value for the deleted object.')
-          assert_equal(3,ll.length, 'The length of the linked list appears to be incorrect following the prior deletion.')
-          assert_nothing_raised('Failed while popping an element from the end of the list.') { d = ll.pop }
-          assert_equal('b',d, 'The prior pop returned the wrong value.')
-          assert_equal(2,ll.length, 'The length of the linked list appears to be incorrect following the prior pop.')
-          assert_equal(['d','c'],ll.queue, 'The queue of keys for the list is incorrect.')
-          assert_equal(['d',3],ll.to_a, 'Converting the list to an array (of values) seems to have failed.')
-          expected = [['c',3],['d','d']]
-          ll.each do |k,v|
-              e = expected.pop
-              assert_equal(e,[k,v], 'While iterates over the list via each(), the value from this iteration is not what was expected.')
-          end
-      end
-  end
-
-=end

data/lib/{more → class}/facets/lrucache.rb

@@ -154,26 +154,3 @@ class LRUCache < Hash
 
 end
 
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-# TODO
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_LRUCache < Test::Unit::TestCase
-
-    def test_01
-    end
-
-  end
-
-=end

data/lib/{more → class}/facets/opencascade.rb

@@ -90,73 +90,3 @@ class OpenCascade < OpenObject
 
 end
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TestOpenCascade1 < Test::Unit::TestCase
-
-    def test_1_01
-      o = OpenCascade[:a=>1,:b=>2]
-      assert_equal( 1, o.a )
-      assert_equal( 2, o.b )
-    end
-
-    def test_1_02
-      o = OpenCascade[:a=>1,:b=>2,:c=>{:x=>9}]
-      assert_equal( 9, o.c.x )
-    end
-
-    def test_1_03
-      f0 = OpenCascade.new
-      f0[:a] = 1
-      assert_equal( [[:a,1]], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-
-    def test_1_04
-      f0 = OpenCascade[:a=>1]
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-  end
-
-  class TestOpenCascade2 < Test::Unit::TestCase
-
-    def test_02_001
-      f0 = OpenCascade[:f0=>"f0"]
-      h0 = { :h0=>"h0" }
-      assert_equal( OpenCascade[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-
-    def test_02_002
-      f1 = OpenCascade[:f1=>"f1"]
-      h1 = { :h1=>"h1" }
-      f1.send(:update, h1)
-      h1.update( f1 )
-      assert_equal( OpenCascade[:f1=>"f1", :h1=>"h1"], f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-  end
-
-  class TestOpenCascade3 < Test::Unit::TestCase
-
-    def test_01_001
-      fo = OpenCascade.new
-      99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
-      99.times{ |i|
-        assert_equal( 1, fo.__send__( "n#{i}" ) )
-      }
-    end
-  end
-
-=end

data/lib/class/facets/openhash.rb

@@ -0,0 +1,41 @@
+# TITLE:
+#
+#   OpenHash
+#
+# SYNOPSIS:
+#
+# OpenHash is akin to an OpenStruct or an OpenObject,
+# but it is much simplier in nature. It is a hash with
+# an method_missing definition that routes to [] and []=.
+#
+# AUTHOR:
+#   - Trans
+
+# = OpenHash
+#
+# OpenHash is akin to an OpenStruct or an OpenObject,
+# but it is much simplier in nature. It is a hash with
+# an method_missing definition that routes to [] and []=.
+
+class OpenHash < Hash
+
+  # New OpenHash.
+
+  def initialize(data)
+    super()
+    update(data)
+  end
+
+  # Route get and set calls.
+
+  def method_missing(s, *a)
+    if s =~ /=$/
+      self[s] = a[0]
+    elsif a.empty?
+      self[s]
+    else
+      super
+    end
+  end
+
+end

data/lib/{more → class}/facets/openobject.rb

@@ -239,124 +239,3 @@ class Proc
   end
 end
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TestOpenObject1 < Test::Unit::TestCase
-
-    def test_1_01
-      o = OpenObject.new
-      assert( o.respond_to?(:key?) )
-    end
-
-    def test_1_02
-      assert_instance_of( OpenObject, OpenObject[{}] )
-    end
-
-    def test_1_03
-      f0 = OpenObject.new
-      f0[:a] = 1
-      #assert_equal( [1], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-
-    def test_1_04
-      f0 = OpenObject[:a=>1]
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-
-    def test_1_05
-      f0 = OpenObject[:class=>1]
-      assert_equal( 1, f0.class )
-    end
-  end
-
-  class TestOpenObject2 < Test::Unit::TestCase
-
-    def test_2_01
-      f0 = OpenObject[:f0=>"f0"]
-      h0 = { :h0=>"h0" }
-      assert_equal( OpenObject[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-
-    def test_2_02
-      f1 = OpenObject[:f1=>"f1"]
-      h1 = { :h1=>"h1" }
-      f1.send(:update,h1)
-      h1.update( f1 )
-      assert_equal( OpenObject[:f1=>"f1", :h1=>"h1"], f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-
-    def test_2_03
-      o = OpenObject[:a=>1,:b=>{:x=>9}]
-      assert_equal( 9, o[:b][:x] )
-      assert_equal( 9, o.b[:x] )
-    end
-
-    def test_2_04
-      o = OpenObject["a"=>1,"b"=>{:x=>9}]
-      assert_equal( 1, o["a"] )
-      assert_equal( 1, o[:a] )
-      assert_equal( {:x=>9}, o["b"] )
-      assert_equal( {:x=>9}, o[:b] )
-      assert_equal( 9, o["b"][:x] )
-      assert_equal( nil, o[:b]["x"] )
-    end
-
-  end
-
-  class TestOpenObject3 < Test::Unit::TestCase
-    def test_3_01
-      fo = OpenObject.new
-      9.times{ |i| fo.send( "n#{i}=", 1 ) }
-      9.times{ |i|
-        assert_equal( 1, fo.send( "n#{i}" ) )
-      }
-    end
-  end
-
-  class TestOpenObject4 < Test::Unit::TestCase
-
-    def test_4_01
-      ho = {}
-      fo = OpenObject.new
-      5.times{ |i| ho["n#{i}".to_sym]=1 }
-      5.times{ |i| fo.send( "n#{i}=", 1 ) }
-      assert_equal(ho, fo.to_h)
-    end
-
-  end
-
-  class TestOpenObject5 < Test::Unit::TestCase
-
-    def test_5_01
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = p.to_openobject
-      assert_equal( "Hello", o.word )
-    end
-
-    def test_5_02
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = OpenObject[:a=>1,:b=>2]
-      assert_instance_of( Proc, o.to_proc )
-    end
-
-  end
-
-=end