facets 2.0.2 → 2.0.3

data/lib/more/facets/dictionary.rb

@@ -27,7 +27,12 @@
 #   FOR A PARTICULAR PURPOSE.
 #
 #   Originally ported from OrderHash 2.0, Copyright (c) 2005 jan molic
-
+#
+# LOG:
+#
+#   - 2007.10.31 trans
+#     Fixed initialize so the constructor blocks correctly effected dictionary
+#     rather then just the internal hash.
 
 # = Dictionary
 #
@@ -81,7 +86,7 @@ class Dictionary
     # TODO is this needed? Doesn't the super class do this?
     #++
 
-    def []( *args )
+    def [](*args)
       hsh = new
       if Hash === args[0]
         hsh.replace(args[0])
@@ -97,7 +102,7 @@ class Dictionary
 
     # Like #new but the block sets the order.
     #
-    def new_by( *args, &blk )
+    def new_by(*args, &blk)
       new(*args).order_by(&blk)
     end
 
@@ -113,8 +118,8 @@ class Dictionary
     #
     #   Dictionary.new.order_by { |key,value| key }
 
-    def alpha( *args, &block )
-      new( *args, &block ).order_by_key
+    def alpha(*args, &block)
+      new(*args, &block).order_by_key
     end
 
     # Alternate to #new which auto-creates sub-dictionaries as needed.
@@ -122,17 +127,21 @@ class Dictionary
     #   d = Dictionary.auto
     #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
     #
-    def auto( *args )
+    def auto(*args)
       #AutoDictionary.new(*args)
-      leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+      leet = lambda { |hsh, key| hsh[key] = new(&leet) }
       new(*args, &leet)
     end
   end
 
-  def initialize( *args, &blk )
+   # New Dictiionary.
+
+  def initialize(*args, &blk)
     @order = []
     @order_by = nil
-    @hash = Hash.new( *args, &blk )
+    dict = self                                  # This ensure autmatic key entry effect the
+    oblk = lambda{ |hsh, key| blk[dict,key] }    # dictionary rather then just the interal hash.
+    @hash = Hash.new(*args, &oblk)
   end
 
   def order
@@ -190,7 +199,7 @@ class Dictionary
 
   def reorder
     if @order_by
-      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by( &@order_by )
+      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)
       @order = assoc.collect{ |k,v| k }
     end
     @order
@@ -201,7 +210,7 @@ class Dictionary
   #  super hsh2
   #end
 
-  def ==( hsh2 )
+  def ==(hsh2)
     if hsh2.is_a?( Dictionary )
       @order == hsh2.order &&
       @hash  == hsh2.instance_variable_get("@hash")
@@ -214,8 +223,8 @@ class Dictionary
     @hash[ k ]
   end
 
-  def fetch( k, *a, &b )
-    @hash.fetch( k, *a, &b )
+  def fetch(k, *a, &b)
+    @hash.fetch(k, *a, &b)
   end
 
   # Store operator.
@@ -346,7 +355,9 @@ class Dictionary
   end
 
   def dup
-    self.class[*to_a.flatten]
+    a = []
+    each{ |k,v| a << k; a << v }
+    self.class[*a]
   end
 
   def update( hsh2 )
@@ -418,120 +429,3 @@ class Dictionary
     @hash.dup
   end
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_Dictionary < Test::Unit::TestCase
-
-    def test_create
-      hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-      assert_equal( ['z','a','c'], hsh.keys )
-    end
-
-    def test_op_store
-      hsh = Dictionary.new
-      hsh['z'] = 1
-      hsh['a'] = 2
-      hsh['c'] = 3
-      assert_equal( ['z','a','c'], hsh.keys )
-    end
-
-    def test_push
-      hsh = Dictionary['a', 1, 'c', 2, 'z', 3]
-      assert( hsh.push('end', 15) )
-      assert_equal( 15, hsh['end'] )
-      assert( ! hsh.push('end', 30) )
-      assert( hsh.unshift('begin', 50) )
-      assert_equal( 50, hsh['begin'] )
-      assert( ! hsh.unshift('begin', 60) )
-      assert_equal( ["begin", "a", "c", "z", "end"], hsh.keys )
-      assert_equal( ["end", 15], hsh.pop )
-      assert_equal( ["begin", "a", "c", "z"], hsh.keys )
-      assert_equal( ["begin", 50], hsh.shift )
-    end
-
-    def test_insert
-      # front
-      h = Dictionary['a', 1, 'b', 2, 'c', 3]
-      r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
-      assert_equal( 4, h.insert(0,'d',4) )
-      assert_equal( r, h )
-      # back
-      h = Dictionary['a', 1, 'b', 2, 'c', 3]
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( 4, h.insert(-1,'d',4) )
-      assert_equal( r, h )
-    end
-
-    def test_update
-      # with other orderred hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = Dictionary['d', 4]
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.update(h2) )
-      assert_equal( r, h1 )
-      # with other hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = { 'd' => 4 }
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.update(h2) )
-      assert_equal( r, h1 )
-    end
-
-    def test_merge
-      # with other orderred hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = Dictionary['d', 4]
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.merge(h2) )
-      # with other hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = { 'd' => 4 }
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.merge(h2) )
-    end
-
-    def test_order_by
-      h1 = Dictionary['a', 3, 'b', 2, 'c', 1]
-      h1.order_by{ |k,v| v }
-      assert_equal( [1,2,3], h1.values )
-      assert_equal( ['c','b','a'], h1.keys )
-    end
-
-    def test_op_store
-      h1 = Dictionary[]
-      h1[:a] = 1
-      h1[:c] = 3
-      assert_equal( [1,3], h1.values )
-      h1[:b,1] = 2
-      assert_equal( [1,2,3], h1.values )
-      assert_equal( [:a,:b,:c], h1.keys )
-    end
-
-    def test_reverse!
-      hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-      hsh.reverse!
-      assert_equal( ['c','a','z'], hsh.keys )
-    end
-
-    def test_enumerable
-      h1 = Dictionary[]
-      h1[:a] = "a"
-      h1[:c] = "b"
-      assert_equal( ["A","B"], h1.collect{|k,v| v.capitalize} )
-    end
-
-  end
-
-=end

data/lib/more/facets/downloader.rb

@@ -195,7 +195,7 @@ class Downloader
 
     STDOUT.sync = true
     begin
-      local_file = File.open( filepath, 'w' )
+      local_file = File.open( filepath, 'wb' )
       remote_file = open( url, :progress_proc => progress_proc )
       local_file << remote_file.read
     rescue

data/lib/more/facets/infinity.rb

@@ -62,6 +62,7 @@ class InfinityClass < Numeric
 
   def initialize(direction=1)
     @direction = (direction <=> 0)
+    super()
   end
 
   # Change direction of infinity.
@@ -172,9 +173,8 @@ class Numeric
 end
 
 # Set constant to positive infinity.
-
-UNDEFINED = InfinityClass.instance(0)
-INFINITY  = InfinityClass.instance(1)
+UNDEFINED = InfinityClass.new(0)
+INFINITY  = InfinityClass.new(1)
 
 NaN = UNDEFINED
 Inf = INFINITY

data/lib/more/facets/interval.rb

@@ -64,7 +64,6 @@ require 'facets/enumerablepass'
 #
 #   i = Interval[1,3]
 #   i.to_a(1,2)  #=> [1.0,1.5,2.0,2.5,3.0]
-#
 
 class Interval
 
@@ -265,163 +264,3 @@ class Interval
   end
 
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class InclusiveTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( 1, 10 )
-      @b = Interval.new( 1, 10, true, false )
-      @c = Interval.new( 1, 10, false, true )
-      @d = Interval.new( 1, 10, true, true )
-    end
-
-    def test_001A ; assert_equal( false, @a.include?(0)  ) ; end
-    def test_002A ; assert_equal( true,  @a.include?(1)  ) ; end
-    def test_003A ; assert_equal( true,  @a.include?(2)  ) ; end
-    def test_004A ; assert_equal( true,  @a.include?(9)  ) ; end
-    def test_005A ; assert_equal( true,  @a.include?(10) ) ; end
-    def test_006A ; assert_equal( false, @a.include?(11) ) ; end
-
-    def test_001B ; assert_equal( false, @b.include?(0)  ) ; end
-    def test_002B ; assert_equal( false, @b.include?(1)  ) ; end
-    def test_003B ; assert_equal( true,  @b.include?(2)  ) ; end
-    def test_004B ; assert_equal( true,  @b.include?(9)  ) ; end
-    def test_005B ; assert_equal( true,  @b.include?(10) ) ; end
-    def test_006B ; assert_equal( false, @b.include?(11) ) ; end
-
-    def test_001C ; assert_equal( false, @c.include?(0)  ) ; end
-    def test_002C ; assert_equal( true,  @c.include?(1)  ) ; end
-    def test_003C ; assert_equal( true,  @c.include?(2)  ) ; end
-    def test_004C ; assert_equal( true,  @c.include?(9)  ) ; end
-    def test_005C ; assert_equal( false, @c.include?(10) ) ; end
-    def test_006C ; assert_equal( false, @c.include?(11) ) ; end
-
-    def test_001D ; assert_equal( false, @d.include?(0)  ) ; end
-    def test_002D ; assert_equal( false, @d.include?(1)  ) ; end
-    def test_003D ; assert_equal( true,  @d.include?(2)  ) ; end
-    def test_004D ; assert_equal( true,  @d.include?(9)  ) ; end
-    def test_005D ; assert_equal( false, @d.include?(10) ) ; end
-    def test_006D ; assert_equal( false, @d.include?(11) ) ; end
-
-  end
-
-  class LrgNumericTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new(0,100000000)
-      @b = Interval.new(0,100000000)
-    end
-
-    def test_001A ; assert_equal( true,  @a.include?(0)         ) ; end
-    def test_002A ; assert_equal( true,  @a.include?(1000)      ) ; end
-    def test_003A ; assert_equal( true,  @a.include?(1000000)   ) ; end
-    def test_004A ; assert_equal( true,  @a.include?(100000000) ) ; end
-    #def test_005A ; assert_equal( false, @a.include?(INFINITY)  ) ; end
-
-    def test_001B ; assert_equal( true,  @b.include?(0)         ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(5)         ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(70007)     ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(5000005)   ) ; end
-    #def test_002B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
-
-  end
-
-  class SelectTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( 0,10 )
-    end
-
-    def test_001
-      b = @a.collect( 2 ){ |n| n }
-      assert_equal( [0,2,4,6,8,10], b )
-    end
-
-    def test_002
-      b = @a.select{ |n| n % 2 == 0 }
-      assert_equal( [0,2,4,6,8,10], b )
-    end
-
-    def test_003
-      b = @a.collect( 1,2 ){ |n| n }
-      assert_equal( [0,5,10], b )
-    end
-
-    def test_004
-      b = @a.select( 1,2 ){ |n| n % 2 == 0 }
-      assert_equal( [0,10], b )
-    end
-
-  end
-
-  class ArrayTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( 0,10 )
-      @b = Interval.new( 0,1 )
-    end
-
-    def test_001A ; assert_equal( [0,5,10], @a.to_a(1,2) ) ; end
-
-    def test_001B ; assert_equal( [0, 0.25, 0.5, 0.75, 1.0], @b.to_a(1,4) ) ; end
-
-  end
-
-=end
-
-=begin
-  class InfTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( -INFINITY, -3 )
-      @b = Interval.new( -INFINITY, -3, true, false )
-      @c = Interval.new( -3, INFINITY )
-      @d = Interval.new( -INFINITY, INFINITY )
-      @e = Interval.new( -3, -2 )
-    end
-
-    def test_001A ; assert_equal( true,  @a.include?(-INFINITY) ) ; end
-    def test_002A ; assert_equal( true,  @a.include?(-4)        ) ; end
-    def test_003A ; assert_equal( true,  @a.include?(-3)        ) ; end
-    def test_004A ; assert_equal( false, @a.include?(-2)        ) ; end
-    def test_005A ; assert_equal( false, @a.include?(INFINITY)  ) ; end
-
-    def test_001B ; assert_equal( true,  @b.include?(-INFINITY) ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(-4)        ) ; end
-    def test_003B ; assert_equal( false, @b.include?(-3)        ) ; end
-    def test_004B ; assert_equal( false, @b.include?(-2)        ) ; end
-    def test_005B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
-
-    def test_001C ; assert_equal( false, @c.include?(-INFINITY) ) ; end
-    def test_002C ; assert_equal( false, @c.include?(-4)        ) ; end
-    def test_003C ; assert_equal( true,  @c.include?(-3)        ) ; end
-    def test_004C ; assert_equal( true,  @c.include?(-2)        ) ; end
-    def test_005C ; assert_equal( true,  @c.include?(INFINITY)  ) ; end
-
-    def test_001D ; assert_equal( true,  @d.include?(-INFINITY) ) ; end
-    def test_002D ; assert_equal( true,  @d.include?(-4)        ) ; end
-    def test_003D ; assert_equal( true,  @d.include?(-3)        ) ; end
-    def test_004D ; assert_equal( true,  @d.include?(-2)        ) ; end
-    def test_005D ; assert_equal( true,  @d.include?(INFINITY)  ) ; end
-
-    def test_001E ; assert_equal( false, @e.include?(-INFINITY) ) ; end
-    def test_002E ; assert_equal( false, @e.include?(-4)        ) ; end
-    def test_003E ; assert_equal( true,  @e.include?(-3)        ) ; end
-    def test_004E ; assert_equal( true,  @e.include?(-2)        ) ; end
-    def test_005E ; assert_equal( false, @e.include?(INFINITY)  ) ; end
-
-  end
-=end

data/lib/more/facets/multiton.rb

@@ -104,11 +104,13 @@ module Multiton
   #  disable build-in copying methods
 
   def clone
-    self #raise TypeError, "can't clone Multiton #{self}"
+    raise TypeError, "can't clone Multiton #{self}"
+    #self
   end
 
   def dup
-    self #raise TypeError, "can't dup Multiton #{self}"
+    raise TypeError, "can't dup Multiton #{self}"
+    #self
   end
 
   # default marshalling strategy
@@ -157,11 +159,12 @@ module Multiton
     private
     def included(base)
       class << base
+        #alias_method(:new!, :new) unless method_defined?(:new!)
         # gracefully handle multiple inclusions of Multiton
-        unless include?(Multiton::ClassMethods)
-          #alias_method :_new, :new
-          private :allocate, :new #, :new
-          include Multiton::ClassMethods
+        unless include?(Multiton::MetaMethods)
+          alias_method :new!, :new
+          private :allocate #, :new
+          include Multiton::MetaMethods
 
           if method_defined?(:marshal_dump)
             undef_method :marshal_dump
@@ -176,7 +179,7 @@ module Multiton
 
   #
 
-  module ClassMethods
+  module MetaMethods
 
     include Inclusive
 
@@ -185,7 +188,7 @@ module Multiton
       multiton_instance.fetch(arg) do
         multiton_mutex[arg].synchronize do
           multiton_instance.fetch(arg) do
-            val = multiton_instance[arg] = new(*e, &b) #_new(*e, &b)
+            val = multiton_instance[arg] = new!(*e, &b) #new(*e, &b)
             val.instance_variable_set(:@multiton_initializer, e, &b)
             multiton_mutex.initialized(arg)
             val
@@ -193,7 +196,7 @@ module Multiton
         end
       end
     end
-    #alias_method :new, :instance
+    alias_method :new, :instance
 
     def initialized?(*e, &b)
       multiton_instance.key?(multiton_id(*e, &b))
@@ -242,8 +245,8 @@ end
 
 
 
-
-
+=begin
+# TODO Convert this into a real test and/or benchmark.
 
 if $0 == __FILE__
 
@@ -320,7 +323,7 @@ if $0 == __FILE__
       super
     end
 
-    def new(*e)
+    def new!(*e)  # NOTICE!!!
       super
     ensure
       nap()
@@ -351,3 +354,4 @@ if $0 == __FILE__
   end
 
 end
+=end