ruby_on_ruby 0.0.1

data/vendor/javascripts/emscripted-ruby/lib/finalize.rb

@@ -0,0 +1,193 @@
+#--
+#   finalizer.rb - 
+#   	$Release Version: 0.3$
+#   	$Revision: 1.4 $
+#   	$Date: 1998/02/27 05:34:33 $
+#   	by Keiju ISHITSUKA
+#++
+#
+# Usage:
+#
+# add dependency R_method(obj, dependant)
+#   add(obj, dependant, method = :finalize, *opt)
+#   add_dependency(obj, dependant, method = :finalize, *opt)
+#
+# delete dependency R_method(obj, dependant)
+#   delete(obj_or_id, dependant, method = :finalize)
+#   delete_dependency(obj_or_id, dependant, method = :finalize)
+#
+# delete dependency R_*(obj, dependant)
+#   delete_all_dependency(obj_or_id, dependant)
+#
+# delete dependency R_method(*, dependant)
+#   delete_by_dependant(dependant, method = :finalize)
+#
+# delete dependency R_*(*, dependant)
+#   delete_all_by_dependant(dependant)
+#
+# delete all dependency R_*(*, *)
+#   delete_all
+#
+# finalize the dependant connected by dependency R_method(obj, dependtant).
+#   finalize(obj_or_id, dependant, method = :finalize)
+#   finalize_dependency(obj_or_id, dependant, method = :finalize)
+#
+# finalize all dependants connected by dependency R_*(obj, dependtant).
+#   finalize_all_dependency(obj_or_id, dependant)
+#
+# finalize the dependant connected by dependency R_method(*, dependtant).
+#   finalize_by_dependant(dependant, method = :finalize)
+#
+# finalize all dependants connected by dependency R_*(*, dependant).
+#   finalize_all_by_dependant(dependant)
+#
+# finalize all dependency registered to the Finalizer.
+#   finalize_all
+#
+# stop invoking Finalizer on GC.
+#   safe{..}
+#
+
+module Finalizer
+  RCS_ID='-$Id: finalize.rb,v 1.4 1998/02/27 05:34:33 keiju Exp keiju $-'
+
+  class <<self
+    # @dependency: {id => [[dependant, method, *opt], ...], ...}
+
+    # add dependency R_method(obj, dependant)
+    def add_dependency(obj, dependant, method = :finalize, *opt)
+      ObjectSpace.call_finalizer(obj)
+      method = method.intern unless method.kind_of?(Integer)
+      assoc = [dependant, method].concat(opt)
+      if dep = @dependency[obj.object_id]
+	dep.push assoc
+      else
+	@dependency[obj.object_id] = [assoc]
+      end
+    end
+    alias add add_dependency
+
+    # delete dependency R_method(obj, dependant)
+    def delete_dependency(id, dependant, method = :finalize)
+      id = id.object_id unless id.kind_of?(Integer)
+      method = method.intern unless method.kind_of?(Integer)
+      for assoc in @dependency[id]
+	assoc.delete_if do
+	  |d, m, *o|
+	  d == dependant && m == method
+	end
+	@dependency.delete(id) if assoc.empty?
+      end
+    end
+    alias delete delete_dependency
+
+    # delete dependency R_*(obj, dependant)
+    def delete_all_dependency(id, dependant)
+      id = id.object_id unless id.kind_of?(Integer)
+      method = method.intern unless method.kind_of?(Integer)
+      for assoc in @dependency[id]
+	assoc.delete_if do
+	  |d, m, *o|
+	  d == dependant
+	end
+	@dependency.delete(id) if assoc.empty?
+      end
+    end
+
+    # delete dependency R_method(*, dependant)
+    def delete_by_dependant(dependant, method = :finalize)
+      method = method.intern unless method.kind_of?(Integer)
+      for id in @dependency.keys
+	delete(id, dependant, method)
+      end
+    end
+
+    # delete dependency R_*(*, dependant)
+    def delete_all_by_dependant(dependant)
+      for id in @dependency.keys
+	delete_all_dependency(id, dependant)
+      end
+    end
+
+    # finalize the depandant connected by dependency R_method(obj, dependtant)
+    def finalize_dependency(id, dependant, method = :finalize)
+      id = id.object_id unless id.kind_of?(Integer)
+      method = method.intern unless method.kind_of?(Integer)
+      for assocs in @dependency[id]
+	assocs.delete_if do
+	  |d, m, *o|
+	  d.send(m, id, *o) if ret = d == dependant && m == method
+	  ret
+	end
+	@dependency.delete(id) if assoc.empty?
+      end
+    end
+    alias finalize finalize_dependency
+
+    # finalize all dependants connected by dependency R_*(obj, dependtant)
+    def finalize_all_dependency(id, dependant)
+      id = id.object_id unless id.kind_of?(Integer)
+      method = method.intern unless method.kind_of?(Integer)
+      for assoc in @dependency[id]
+	assoc.delete_if do
+	  |d, m, *o|
+	  d.send(m, id, *o) if ret = d == dependant
+	end
+	@dependency.delete(id) if assoc.empty?
+      end
+    end
+
+    # finalize the dependant connected by dependency R_method(*, dependtant)
+    def finalize_by_dependant(dependant, method = :finalize)
+      method = method.intern unless method.kind_of?(Integer)
+      for id in @dependency.keys
+	finalize(id, dependant, method)
+      end
+    end
+
+    # finalize all dependants connected by dependency R_*(*, dependtant)
+    def finalize_all_by_dependant(dependant)
+      for id in @dependency.keys
+	finalize_all_dependency(id, dependant)
+      end
+    end
+
+    # finalize all dependants registered to the Finalizer.
+    def finalize_all
+      for id, assocs in @dependency
+	for dependant, method, *opt in assocs
+	  dependant.send(method, id, *opt)
+	end
+	assocs.clear
+      end
+    end
+
+    # method to call finalize_* safely.
+    def safe
+      old_status = Thread.critical
+      Thread.critical = true
+      ObjectSpace.remove_finalizer(@proc)
+      begin
+	yield
+      ensure
+	ObjectSpace.add_finalizer(@proc)
+	Thread.critical = old_status
+      end
+    end
+
+    private
+
+    # registering function to ObjectSpace#add_finalizer
+    def final_of(id)
+      if assocs = @dependency.delete(id)
+	for dependant, method, *opt in assocs
+	  dependant.send(method, id, *opt)
+	end
+      end
+    end
+
+  end
+  @dependency = Hash.new
+  @proc = proc{|id| final_of(id)}
+  ObjectSpace.add_finalizer(@proc)
+end

data/vendor/javascripts/emscripted-ruby/lib/find.rb

@@ -0,0 +1,79 @@
+#
+# find.rb: the Find module for processing all files under a given directory.
+#
+
+#
+# The +Find+ module supports the top-down traversal of a set of file paths.
+#
+# For example, to total the size of all files under your home directory,
+# ignoring anything in a "dot" directory (e.g. $HOME/.ssh):
+#
+#   require 'find'
+#
+#   total_size = 0
+#
+#   Find.find(ENV["HOME"]) do |path|
+#     if FileTest.directory?(path)
+#       if File.basename(path)[0] == ?.
+#         Find.prune       # Don't look any further into this directory.
+#       else
+#         next
+#       end
+#     else
+#       total_size += FileTest.size(path)
+#     end
+#   end
+#
+module Find
+
+  #
+  # Calls the associated block with the name of every file and directory listed
+  # as arguments, then recursively on their subdirectories, and so on.
+  #
+  # See the +Find+ module documentation for an example.
+  #
+  def find(*paths) # :yield: path
+    paths.collect!{|d| d.dup}
+    while file = paths.shift
+      catch(:prune) do
+	yield file.dup.taint
+        next unless File.exist? file
+	begin
+	  if File.lstat(file).directory? then
+	    d = Dir.open(file)
+	    begin
+	      for f in d
+		next if f == "." or f == ".."
+		if File::ALT_SEPARATOR and file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
+		  f = file + f
+		elsif file == "/" then
+		  f = "/" + f
+		else
+		  f = File.join(file, f)
+		end
+		paths.unshift f.untaint
+	      end
+	    ensure
+	      d.close
+	    end
+	  end
+        rescue Errno::ENOENT, Errno::EACCES
+	end
+      end
+    end
+  end
+
+  #
+  # Skips the current file or directory, restarting the loop with the next
+  # entry. If the current file is a directory, that directory will not be
+  # recursively entered. Meaningful only within the block associated with
+  # Find::find.
+  #
+  # See the +Find+ module documentation for an example.
+  #
+  def prune
+    throw :prune
+  end
+
+  module_function :find, :prune
+end

data/vendor/javascripts/emscripted-ruby/lib/forwardable.rb

@@ -0,0 +1,218 @@
+# = forwardable - Support for the Delegation Pattern
+#
+#    $Release Version: 1.1$
+#    $Revision: 11708 $
+#    $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#    by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#
+#    Documentation by James Edward Gray II and Gavin Sinclair
+#
+# == Introduction
+#
+# This library allows you delegate method calls to an object, on a method by
+# method basis.  You can use Forwardable to setup this delegation at the class
+# level, or SingleForwardable to handle it at the object level.
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# <b>forwardable.rb provides single-method delegation via the
+# def_delegator() and def_delegators() methods.  For full-class
+# delegation via DelegateClass(), see delegate.rb.</b>
+#
+# == Examples
+#
+# === Forwardable
+#
+# Forwardable makes building a new class based on existing work, with a proper
+# interface, almost trivial.  We want to rely on what has come before obviously,
+# but with delegation we can take just the methods we need and even rename them
+# as appropriate.  In many cases this is preferable to inheritance, which gives
+# us the entire old interface, even if much of it isn't needed.
+#
+#   class Queue
+#     extend Forwardable
+#     
+#     def initialize
+#       @q = [ ]    # prepare delegate object
+#     end
+#     
+#     # setup prefered interface, enq() and deq()...
+#     def_delegator :@q, :push, :enq
+#     def_delegator :@q, :shift, :deq
+#     
+#     # support some general Array methods that fit Queues well
+#     def_delegators :@q, :clear, :first, :push, :shift, :size
+#   end
+# 
+#   q = Queue.new
+#   q.enq 1, 2, 3, 4, 5
+#   q.push 6
+# 
+#   q.shift    # => 1
+#   while q.size > 0
+#     puts q.deq
+#   end
+# 
+#   q.enq "Ruby", "Perl", "Python"
+#   puts q.first
+#   q.clear
+#   puts q.first
+#
+# <i>Prints:</i>
+#
+#   2
+#   3
+#   4
+#   5
+#   6
+#   Ruby
+#   nil
+#
+# === SingleForwardable
+#
+#    printer = String.new
+#    printer.extend SingleForwardable        # prepare object for delegation
+#    printer.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#    printer.puts "Howdy!"
+#
+# <i>Prints:</i>
+#
+#    Howdy!
+
+#
+# The Forwardable module provides delegation of specified
+# methods to a designated object, using the methods #def_delegator
+# and #def_delegators.
+#
+# For example, say you have a class RecordCollection which
+# contains an array <tt>@records</tt>.  You could provide the lookup method
+# #record_number(), which simply calls #[] on the <tt>@records</tt>
+# array, like this:
+#
+#   class RecordCollection
+#     extend Forwardable
+#     def_delegator :@records, :[], :record_number
+#   end
+#
+# Further, if you wish to provide the methods #size, #<<, and #map,
+# all of which delegate to @records, this is how you can do it:
+#
+#   class RecordCollection
+#     # extend Forwardable, but we did that above
+#     def_delegators :@records, :size, :<<, :map
+#   end
+#
+# Also see the example at forwardable.rb.
+#
+module Forwardable
+
+  @debug = nil
+  class<<self
+    # force Forwardable to show up in stack backtraces of delegated methods
+    attr_accessor :debug
+  end
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  # See the examples at Forwardable and forwardable.rb.
+  #
+  def def_instance_delegators(accessor, *methods)
+    for method in methods
+      def_instance_delegator(accessor, method)
+    end
+  end
+
+  #
+  # Defines a method _method_ which delegates to _obj_ (i.e. it calls
+  # the method of the same name in _obj_).  If _new_name_ is
+  # provided, it is used as the name for the delegate method.
+  #
+  # See the examples at Forwardable and forwardable.rb.
+  #
+  def def_instance_delegator(accessor, method, ali = method)
+    accessor = accessor.id2name if accessor.kind_of?(Integer)
+    method = method.id2name if method.kind_of?(Integer)
+    ali = ali.id2name if ali.kind_of?(Integer)
+
+    module_eval(<<-EOS, "(__FORWARDABLE__)", 1)
+      def #{ali}(*args, &block)
+	begin
+	  #{accessor}.__send__(:#{method}, *args, &block)
+	rescue Exception
+	  $@.delete_if{|s| /^\\(__FORWARDABLE__\\):/ =~ s} unless Forwardable::debug
+	  Kernel::raise
+	end
+      end
+    EOS
+  end
+
+  alias def_delegators def_instance_delegators
+  alias def_delegator def_instance_delegator
+end
+
+#
+# The SingleForwardable module provides delegation of specified
+# methods to a designated object, using the methods #def_delegator
+# and #def_delegators.  This module is similar to Forwardable, but it works on
+# objects themselves, instead of their defining classes.
+#
+# Also see the example at forwardable.rb.
+#
+module SingleForwardable
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   single_forwardable.def_delegators :@records, :size, :<<, :map
+  #
+  #   single_forwardable.def_delegator :@records, :size
+  #   single_forwardable.def_delegator :@records, :<<
+  #   single_forwardable.def_delegator :@records, :map
+  #
+  # See the example at forwardable.rb.
+  #
+  def def_singleton_delegators(accessor, *methods)
+    for method in methods
+      def_singleton_delegator(accessor, method)
+    end
+  end
+
+  #
+  # Defines a method _method_ which delegates to _obj_ (i.e. it calls
+  # the method of the same name in _obj_).  If _new_name_ is
+  # provided, it is used as the name for the delegate method.
+  #
+  # See the example at forwardable.rb.
+  #
+  def def_singleton_delegator(accessor, method, ali = method)
+    accessor = accessor.id2name if accessor.kind_of?(Integer)
+    method = method.id2name if method.kind_of?(Integer)
+    ali = ali.id2name if ali.kind_of?(Integer)
+
+    instance_eval(<<-EOS, "(__FORWARDABLE__)", 1)
+       def #{ali}(*args, &block)
+	 begin
+	   #{accessor}.__send__(:#{method}, *args,&block)
+	 rescue Exception
+	   $@.delete_if{|s| /^\\(__FORWARDABLE__\\):/ =~ s} unless Forwardable::debug
+	   Kernel::raise
+	 end
+       end
+    EOS
+  end
+
+  alias def_delegators def_singleton_delegators
+  alias def_delegator def_singleton_delegator
+end