facets 1.8.49 → 1.8.51

data/work/more/tag.rb

@@ -1,31 +0,0 @@
-# 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

@@ -1,164 +0,0 @@
-# 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

@@ -1,87 +0,0 @@
-
-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/openobject-temp.rb

@@ -1,45 +0,0 @@
-# TO BE DEPRECTATED!!!
-
-require 'facets/more/openhash'
-
-OpenObject = OpenHash
-
-# Core Extensions
-
-class NilClass
-  # Nil converts to an empty OpenHash.
-
-  def to_openobject
-    OpenObject.new
-  end
-end
-
-class Hash
-  # Convert a Hash into an OpenHash.
-
-  def to_openobject
-    OpenObject[self]
-  end
-end
-
-class Proc
-  # Translates a Proc into an OpenHash. By droping an OpenHash into
-  # the Proc, the resulting assignments incured as the procedure is
-  # evaluated produce the OpenHash. This technique is simlar to that
-  # of MethodProbe.
-  #
-  #   p = lambda { |x|
-  #     x.word = "Hello"
-  #   }
-  #   o = p.to_openhash
-  #   o.word #=> "Hello"
-  #
-  # NOTE The Proc must have an arity of one --no more and no less.
-
-  def to_openobject
-    raise ArgumentError, 'bad arity for converting Proc to openhash' if arity != 1
-    o = OpenObject.new
-    self.call( o )
-    o
-  end
-end

data/work/pore/autorequire.rb

@@ -1,83 +0,0 @@
-
-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

@@ -1,40 +0,0 @@
-# = 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