facets 1.7.46 → 1.8.0

data/work/more/tag.rb

@@ -0,0 +1,31 @@
+# What about a tag system like annotations, but w/o the associated data?
+
+
+
+# Method Tags
+
+class Module
+
+  @@tags = {}
+
+  def tag( taghash )
+    # sanitize the taghash
+    h = {}
+    taghash.each{ |k,v|
+      nk = ( Symbol === k ? k : k.to_sym )
+      if not self.instance_methods.include?(k.to_s)
+        p self.instance_methods
+        raise "#{k} is not defined for tagging"
+      end
+      nv = ( Array === v ? v : [ v ] )
+      h[nk] = nv
+    }
+    # store
+    @@tags.update(h)
+  end
+
+  def tags
+    @@tags
+  end
+
+end

data/work/more/timer.rb

@@ -0,0 +1,164 @@
+# Merge some of these coapabilities into Facets' Timer class, perhaps?
+
+# Ruby license. Copyright (C)2004 Joel VanderWerf.
+# Contact mailto:vjoel@users.sourceforge.net.
+#
+# A lightweight, non-drifting, self-correcting timer. Average error is bounded
+# as long as, on average, there is enough time to complete the work done, and
+# the timer is checked often enough. It is lightweight in the sense that no
+# threads are created. Can be used either as an internal iterator (Timer.every)
+# or as an external iterator (Timer.new).
+#
+# Simple usage:
+#
+# require 'timer'
+#
+# Timer.every(0.1, 0.5) { |elapsed| puts elapsed }
+#
+# timer = Timer.new(0.1)
+# 5.times do
+#   puts timer.elapsed
+#   timer.wait
+# end 
+#
+class Timer
+  # Yields to the supplied block every +period+ seconds. The value yielded is
+  # the total elapsed time (an instance of +Time+). If +expire+ is given, then
+  # #every returns after that amount of elapsed time.
+  def Timer.every(period, expire = nil)
+    target = time_start = Time.now
+    loop do
+      elapsed = Time.now - time_start
+      break if expire and elapsed > expire
+      yield elapsed
+      target += period
+      error = target - Time.now
+      sleep error if error > 0
+    end
+  end
+  
+  # Make a Timer that can be checked when needed, using #wait or #if_ready. The
+  # advantage over Timer.every is that the timer can be checked on separate
+  # passes through a loop.
+  def initialize(period = 1)
+    @period = period
+    restart
+  end
+  
+  attr_reader :period
+  
+  # Call this to restart the timer after a period of inactivity (e.g., the user
+  # hits the pause button, and then hits the go button).
+  def restart
+    @target = @time_start = Time.now
+  end
+  
+  # Time on timer since instantiation or last #restart.
+  def elapsed
+    Time.now - @time_start
+  end
+  
+  # Wait for the next cycle, if time remains in the current cycle. Otherwise,
+  # return immediately to caller.
+  def wait
+    @target += @period
+    error = @target - Time.now
+    sleep error if error > 0
+    true
+  end
+  
+  # Yield to the block if no time remains in cycle. Otherwise, return
+  # immediately to caller
+  def if_ready
+    error = @target + @period - Time.now
+    if error <= 0
+      @target += @period
+      elapsed = Time.now - @time_start
+      yield elapsed
+    end
+  end
+end
+
+
+
+if __FILE__ == $0
+
+  require 'test/unit'
+  
+  # These tests may not work on a slow machine or heavily loaded system; try
+  # adjusting FUDGE.
+  class Test_Timer < Test::Unit::TestCase # :nodoc:
+
+    FUDGE = 0.01 # a constant independent of period.
+
+    def generic_test
+      steps = 100
+      period = 0.01
+      max_sleep = period/2
+      
+      start_time = Time.now
+      yield steps, period, max_sleep
+      finish_time = Time.now
+      
+      assert_in_delta(
+        start_time.to_f + steps*period,
+        finish_time.to_f,
+        period + FUDGE,
+        "delta = #{finish_time.to_f - (start_time.to_f + steps*period)}"
+      )
+    end
+
+    def test_every
+      generic_test do |steps, period, max_sleep|
+        Timer.every period do |elapsed|
+          s = rand()*max_sleep
+          #puts "#{elapsed} elapsed; sleeping #{s}"
+          sleep(s)
+          steps -= 1
+          break if steps == 0
+        end
+      end
+    end
+    
+    def test_every_with_expire
+      generic_test do |steps, period, max_sleep|
+        Timer.every period, period*steps do
+          s = rand()*max_sleep
+          #puts "#{elapsed} elapsed; sleeping #{s}"
+          sleep(s)
+        end
+      end
+    end
+    
+    def test_wait
+      generic_test do |steps, period, max_sleep|
+        timer = Timer.new(period)
+        steps.times do
+          s = rand()*max_sleep
+          #puts "#{timer.elapsed} elapsed; sleeping #{s}"
+          sleep(s)
+          timer.wait
+        end
+      end
+    end
+  
+    def test_if_ready
+      generic_test do |steps, period, max_sleep|
+        timer = Timer.new(period)
+        catch :done do
+          loop do
+            timer.if_ready do |elapsed|
+              s = rand()*max_sleep
+              #puts "#{elapsed} elapsed; sleeping #{s}"
+              sleep(s)
+              steps -= 1
+              throw :done if steps == 0
+            end
+          end
+        end
+      end
+    end
+  
+  end
+  
+end

data/work/op_rshift.rb

@@ -0,0 +1,87 @@
+
+module Kernel
+
+  module Pervasives
+    METHODS = {}
+    Kernel.instance_methods.each do |m|
+      METHODS[m] = Kernel.instance_method(m)
+    end
+    METHODS.each do |s,m|
+      define_method s do |o,*a|
+        m.bind(o).call(*a)
+      end
+      module_function s
+    end
+  end
+  Pervasives.freeze(Pervasives)
+
+  def >>(a)
+    a = [a].flatten
+    case a[0] when Module, Class
+      c, m, *a = *a
+      c.instance_method(m).bind(self).call(*a)
+    else
+      if respond_to?(a[0])
+        Pervasives.send(self,*a)
+      elsif respond_to?(:method_missing)
+        method_missing(*a)
+      else
+        raise NoMethodError, "private method called for #{self}"
+      end
+
+    end
+  end
+
+end
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  class TestSendOP < Test::Unit::TestCase
+
+    class C
+      def a; "c"; end
+    end
+
+    class X < C
+      def send; "send"; end
+      def a; "a"; end
+      private
+      def b; "b"; end
+    end
+
+    def setup
+      @x = X.new
+    end
+
+    def test_send
+      assert_equal( "send", @x.send )
+    end
+
+    def test_normal
+      assert_equal( "a", @x >> [:a] )
+    end
+
+    def test_as_C
+      assert_equal( "c", @x >> [C,:a] )
+    end
+
+    def test_singleton
+      assert_equal( "a", @x >> [(class<<@x;self;end),:a] )
+    end
+
+    def test_singleton_bypass_private
+      assert_equal( "b", @x >> [(class<<@x;self;end),:b] )
+    end
+
+    def test_private
+      assert_raises(NoMethodError){ @x >> [:b] }
+    end
+
+  end
+
+=end
+

data/work/pore/autorequire.rb

@@ -0,0 +1,83 @@
+
+def autorequire
+  # built-in
+  autoload( 'CGI', 'cgi' )
+  autoload( 'FCGI', 'fcgi' )
+  autoload( 'OpenStruct', 'ostruct' )
+  # facets
+  autoload( 'ANSICode', 'calibre/class/ansicode' )
+  autoload( 'BBCode', 'calibre/class/bbcode' )
+  autoload( 'BinaryReader', 'calibre/class/binaryreader' )
+  autoload( 'BlankSlate', 'calibre/class/blankslate' )
+  autoload( 'ByteOrder', 'calibre/class/byteorder' )
+  autoload( 'ClassMethods', 'calibre/class/classmethods' )
+  autoload( 'Coroutine', 'calibre/class/coroutine' )
+  autoload( 'CrossCase', 'calibre/class/crosscase' )
+  autoload( 'FileList', 'calibre/class/expirable' )
+  autoload( 'FloatString', 'calibre/class/floatstring' )
+  autoload( 'Functor', 'calibre/class/functor' )  
+  autoload( 'HArray', 'calibre/class/floatstring' )
+  autoload( 'Heap', 'calibre/class/floatstring' )
+  autoload( 'Infinity', 'calibre/class/infinity' )
+  autoload( 'Interval', 'calibre/class/interval' )
+  autoload( 'IOReactor', 'calibre/class/ioreactor' )
+  autoload( 'IORedirect', 'calibre/class/ioredirect' )
+  autoload( 'LRUCache', 'calibre/class/lrucache' )
+  autoload( 'MethodProbe', 'calibre/class/methodprobe' )
+  autoload( 'Multiton', 'calibre/class/multiton' )
+  autoload( 'Nack', 'calibre/class/nack' )
+  autoload( 'NilComparable', 'calibre/class/nilcomparable' )
+  autoload( 'NotCopyable', 'calibre/class/notcopyable' )
+  autoload( 'OpenStructable', 'calibre/class/ostructable' )
+  autoload( 'OrderedHash', 'calibre/class/ohash' )
+  autoload( 'ParamEnumerable', 'calibre/class/penumerable' )
+  autoload( 'Parser', 'calibre/class/parser' )
+  autoload( 'PhysicalConst', 'calibre/class/physical-const' )
+  autoload( 'Pool', 'calibre/class/pool' )
+  autoload( 'PromoteSelf', 'calibre/class/promoteself' )
+  autoload( 'Reference', 'calibre/class/reference' )
+  autoload( 'Semaphore', 'calibre/class/semaphore' )
+  autoload( 'StaticHash', 'calibre/class/statichash' )
+  autoload( 'SuperStruct', 'calibre/class/sstruct' )
+  autoload( 'SyncHash', 'calibre/class/synchash' )
+  autoload( 'SyncArray', 'calibre/class/syncarray' )
+  autoload( 'SyncHash', 'calibre/class/synchash' )
+  autoload( 'TagIterator', 'calibre/class/tagiter' )
+  autoload( 'Timer', 'calibre/class/timer' )
+  autoload( 'TracePoint', 'calibre/class/tracepoint' )
+  autoload( 'Tuple', 'calibre/class/tuple' )
+  autoload( 'Tuple', 'calibre/class/tuple' )
+  autoload( 'Uninheritable', 'calibre/class/uninheritable' )
+  autoload( 'Version', 'calibre/class/version' )
+end
+
+alias  :autoload_classes :autorequire
+alias  :autoload_modules :autorequire
+
+
+
+# testing
+
+if $0 == __FILE__
+
+  require 'test/unit'
+
+  autoload_classes
+
+  class TC < Test::Unit::TestCase
+
+    def test01
+      assert_nothing_raised do
+        Interval.new(0,9)
+      end
+    end
+
+    def test02
+      assert_raise(NameError) do
+        GGAARRBBAAGGEE.new
+      end
+    end
+
+  end #class TC
+
+end

data/work/pore/basefactory.rb

@@ -0,0 +1,40 @@
+# = basefactory.rb
+
+require 'facets/core/module/class_extension'
+
+# BaseFactory
+
+module BaseFactory
+
+  def self.included( base )
+    class << base
+      alias :instance :new
+    end
+  end
+
+  class_extension {
+
+    # Factory-pattern initialization.
+
+    def new(type, *set, &yld)
+      #begin
+        send(type, *set, &yld)
+      #rescue
+      #  raise FactoryError, "Not a known #{self} -- #{type}."
+      #end
+    end
+
+    # Subclasses should have standard #new methods.
+
+    def inherited( subclass )
+      class << subclass
+        alias :new :instance
+      end
+    end
+
+  }
+
+end
+
+class FactoryError < ArgumentError
+end

data/work/pore/hash/each.rb

@@ -0,0 +1,76 @@
+#--
+# Special thanks to Daniel Schierbeck.
+#++
+
+# TODO Deprecate Hash#each
+warn "Hash#each is being deprecated"
+
+
+class Hash
+
+  # A "smarter" hash#each which iterates through each
+  # _value_ if only one block parameter is given.
+  #
+  #   {:a=>"a", 2=>"b", "x"=>"c"}.each{ |v| puts v }
+  #
+  # _produces_
+  #
+  #   a
+  #   b
+  #   c
+  #
+  # WARNING! Use with caution. Methods from other libraries 
+  # may depend on the old behavior, expecting a two element 
+  # array to be passed into a single block argument.
+
+  def each(&block)
+     if block.arity < 2
+       each_value(&block)
+     else
+       each_pair(&block)
+     end
+   end 
+
+# def each(&yld)
+#   case yld.arity
+#   when 0
+#   when 1
+#     each_value{|v| yield(v)}
+#   else
+#     each_pair{|k,v| yld.call(k,v)}
+#   end
+#   self
+# end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCHash < Test::Unit::TestCase
+
+    def test_each_1
+      h = { :a=>1, :b=>2, :c=>3 }
+      a = []
+      h.each { |v| a << v }
+      assert_equal( [1,2,3], a.sort )
+   end
+
+   def test_each_2
+      h = { 'a'=>1, 'b'=>2, 'c'=>3 }
+      a = []
+      h.each { |k,v| a << [k,v] }
+      assert_equal( [['a',1],['b',2],['c',3]], a.sort )
+    end
+
+  end
+
+=end