ruby_on_ruby 0.0.1

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

@@ -0,0 +1,311 @@
+#
+#   sync.rb - 2 phase lock with counter
+#   	$Release Version: 1.0$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#
+# --
+#  Sync_m, Synchronizer_m
+#  Usage:
+#   obj.extend(Sync_m)
+#   or
+#   class Foo
+#	include Sync_m
+#	:
+#   end
+#
+#   Sync_m#sync_mode
+#   Sync_m#sync_locked?, locked?
+#   Sync_m#sync_shared?, shared?
+#   Sync_m#sync_exclusive?, sync_exclusive?
+#   Sync_m#sync_try_lock, try_lock
+#   Sync_m#sync_lock, lock
+#   Sync_m#sync_unlock, unlock
+#
+#   Sync, Synchronicer:
+#	include Sync_m
+#   Usage:
+#   sync = Sync.new
+#
+#   Sync#mode
+#   Sync#locked?
+#   Sync#shared?
+#   Sync#exclusive?
+#   Sync#try_lock(mode) -- mode = :EX, :SH, :UN
+#   Sync#lock(mode)     -- mode = :EX, :SH, :UN
+#   Sync#unlock
+#   Sync#synchronize(mode) {...}
+#   
+#
+
+unless defined? Thread
+  fail "Thread not available for this ruby interpreter"
+end
+
+module Sync_m
+  RCS_ID='-$Header$-'
+  
+  # lock mode
+  UN = :UN
+  SH = :SH
+  EX = :EX
+  
+  # exceptions
+  class Err < StandardError
+    def Err.Fail(*opt)
+      fail self, sprintf(self::Message, *opt)
+    end
+    
+    class UnknownLocker < Err
+      Message = "Thread(%s) not locked."
+      def UnknownLocker.Fail(th)
+	super(th.inspect)
+      end
+    end
+    
+    class LockModeFailer < Err
+      Message = "Unknown lock mode(%s)"
+      def LockModeFailer.Fail(mode)
+	if mode.id2name
+	  mode = id2name
+	end
+	super(mode)
+      end
+    end
+  end
+  
+  def Sync_m.define_aliases(cl)
+    cl.module_eval %q{
+      alias locked? sync_locked?
+      alias shared? sync_shared?
+      alias exclusive? sync_exclusive?
+      alias lock sync_lock
+      alias unlock sync_unlock
+      alias try_lock sync_try_lock
+      alias synchronize sync_synchronize
+    }
+  end
+  
+  def Sync_m.append_features(cl)
+    super
+    unless cl.instance_of?(Module)
+      # do nothing for Modules
+      # make aliases and include the proper module.
+      define_aliases(cl)
+    end
+  end
+  
+  def Sync_m.extend_object(obj)
+    super
+    obj.sync_extended
+  end
+
+  def sync_extended
+    unless (defined? locked? and
+	    defined? shared? and
+	    defined? exclusive? and
+	    defined? lock and
+	    defined? unlock and
+	    defined? try_lock and
+	    defined? synchronize)
+      Sync_m.define_aliases(class<<self;self;end)
+    end
+    sync_initialize
+  end
+
+  # accessing
+  def sync_locked?
+    sync_mode != UN
+  end
+  
+  def sync_shared?
+    sync_mode == SH
+  end
+  
+  def sync_exclusive?
+    sync_mode == EX
+  end
+  
+  # locking methods.
+  def sync_try_lock(mode = EX)
+    return unlock if sync_mode == UN
+    
+    Thread.critical = true
+    ret = sync_try_lock_sub(sync_mode)
+    Thread.critical = false
+    ret
+  end
+  
+  def sync_lock(m = EX)
+    return unlock if m == UN
+
+    until (Thread.critical = true; sync_try_lock_sub(m))
+      if sync_sh_locker[Thread.current]
+	sync_upgrade_waiting.push [Thread.current, sync_sh_locker[Thread.current]]
+	sync_sh_locker.delete(Thread.current)
+      else
+	sync_waiting.push Thread.current
+      end
+      Thread.stop
+    end
+    Thread.critical = false
+    self
+  end
+  
+  def sync_unlock(m = EX)
+    Thread.critical = true
+    if sync_mode == UN
+      Thread.critical = false
+      Err::UnknownLocker.Fail(Thread.current)
+    end
+    
+    m = sync_mode if m == EX and sync_mode == SH
+    
+    runnable = false
+    case m
+    when UN
+      Thread.critical = false
+      Err::UnknownLocker.Fail(Thread.current)
+      
+    when EX
+      if sync_ex_locker == Thread.current
+	if (self.sync_ex_count = sync_ex_count - 1) == 0
+	  self.sync_ex_locker = nil
+	  if sync_sh_locker.include?(Thread.current)
+	    self.sync_mode = SH
+	  else
+	    self.sync_mode = UN
+	  end
+	  runnable = true
+	end
+      else
+	Err::UnknownLocker.Fail(Thread.current)
+      end
+      
+    when SH
+      if (count = sync_sh_locker[Thread.current]).nil?
+	Err::UnknownLocker.Fail(Thread.current)
+      else
+	if (sync_sh_locker[Thread.current] = count - 1) == 0 
+	  sync_sh_locker.delete(Thread.current)
+	  if sync_sh_locker.empty? and sync_ex_count == 0
+	    self.sync_mode = UN
+	    runnable = true
+	  end
+	end
+      end
+    end
+    
+    if runnable
+      if sync_upgrade_waiting.size > 0
+	for k, v in sync_upgrade_waiting
+	  sync_sh_locker[k] = v
+	end
+	wait = sync_upgrade_waiting
+	self.sync_upgrade_waiting = []
+	Thread.critical = false
+	
+	for w, v in wait
+	  w.run
+	end
+      else
+	wait = sync_waiting
+	self.sync_waiting = []
+	Thread.critical = false
+	for w in wait
+	  w.run
+	end
+      end
+    end
+    
+    Thread.critical = false
+    self
+  end
+  
+  def sync_synchronize(mode = EX)
+    begin
+      sync_lock(mode)
+      yield
+    ensure
+      sync_unlock
+    end
+  end
+
+  attr :sync_mode, true
+    
+  attr :sync_waiting, true
+  attr :sync_upgrade_waiting, true
+  attr :sync_sh_locker, true
+  attr :sync_ex_locker, true
+  attr :sync_ex_count, true
+    
+  private
+
+  def sync_initialize
+    @sync_mode = UN
+    @sync_waiting = []
+    @sync_upgrade_waiting = []
+    @sync_sh_locker = Hash.new
+    @sync_ex_locker = nil
+    @sync_ex_count = 0
+  end
+
+  def initialize(*args)
+    sync_initialize
+    super
+  end
+    
+  def sync_try_lock_sub(m)
+    case m
+    when SH
+      case sync_mode
+      when UN
+	self.sync_mode = m
+	sync_sh_locker[Thread.current] = 1
+	ret = true
+      when SH
+	count = 0 unless count = sync_sh_locker[Thread.current]
+	sync_sh_locker[Thread.current] = count + 1
+	ret = true
+      when EX
+	# in EX mode, lock will upgrade to EX lock
+	if sync_ex_locker == Thread.current
+	  self.sync_ex_count = sync_ex_count + 1
+	  ret = true
+	else
+	  ret = false
+	end
+      end
+    when EX
+      if sync_mode == UN or
+	sync_mode == SH && sync_sh_locker.size == 1 && sync_sh_locker.include?(Thread.current) 
+	self.sync_mode = m
+	self.sync_ex_locker = Thread.current
+	self.sync_ex_count = 1
+	ret = true
+      elsif sync_mode == EX && sync_ex_locker == Thread.current
+	self.sync_ex_count = sync_ex_count + 1
+	ret = true
+      else
+	ret = false
+      end
+    else
+      Thread.critical = false
+      Err::LockModeFailer.Fail mode
+    end
+    return ret
+  end
+end
+Synchronizer_m = Sync_m
+
+class Sync
+  #Sync_m.extend_class self
+  include Sync_m
+    
+  def initialize
+    super
+  end
+    
+end
+Synchronizer = Sync

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

@@ -0,0 +1,209 @@
+#
+# tempfile - manipulates temporary files
+#
+# $Id: tempfile.rb 16127 2008-04-21 09:43:44Z knu $
+#
+
+require 'delegate'
+require 'tmpdir'
+
+# A class for managing temporary files.  This library is written to be
+# thread safe.
+class Tempfile < DelegateClass(File)
+  MAX_TRY = 10
+  @@cleanlist = []
+
+  # Creates a temporary file of mode 0600 in the temporary directory,
+  # opens it with mode "w+", and returns a Tempfile object which
+  # represents the created temporary file.  A Tempfile object can be
+  # treated just like a normal File object.
+  #
+  # The basename parameter is used to determine the name of a
+  # temporary file.  If an Array is given, the first element is used
+  # as prefix string and the second as suffix string, respectively.
+  # Otherwise it is treated as prefix string.
+  #
+  # If tmpdir is omitted, the temporary directory is determined by
+  # Dir::tmpdir provided by 'tmpdir.rb'.
+  # When $SAFE > 0 and the given tmpdir is tainted, it uses
+  # /tmp. (Note that ENV values are tainted by default)
+  def initialize(basename, tmpdir=Dir::tmpdir)
+    if $SAFE > 0 and tmpdir.tainted?
+      tmpdir = '/tmp'
+    end
+
+    lock = nil
+    n = failure = 0
+    
+    begin
+      Thread.critical = true
+
+      begin
+	tmpname = File.join(tmpdir, make_tmpname(basename, n))
+	lock = tmpname + '.lock'
+	n += 1
+      end while @@cleanlist.include?(tmpname) or
+	File.exist?(lock) or File.exist?(tmpname)
+
+      Dir.mkdir(lock)
+    rescue
+      failure += 1
+      retry if failure < MAX_TRY
+      raise "cannot generate tempfile `%s'" % tmpname
+    ensure
+      Thread.critical = false
+    end
+
+    @data = [tmpname]
+    @clean_proc = Tempfile.callback(@data)
+    ObjectSpace.define_finalizer(self, @clean_proc)
+
+    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+    @tmpname = tmpname
+    @@cleanlist << @tmpname
+    @data[1] = @tmpfile
+    @data[2] = @@cleanlist
+
+    super(@tmpfile)
+
+    # Now we have all the File/IO methods defined, you must not
+    # carelessly put bare puts(), etc. after this.
+
+    Dir.rmdir(lock)
+  end
+
+  def make_tmpname(basename, n)
+    case basename
+    when Array
+      prefix, suffix = *basename
+    else
+      prefix, suffix = basename, ''
+    end
+ 
+    t = Time.now.strftime("%Y%m%d")
+    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+  end
+  private :make_tmpname
+
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, 'r+')
+    @data[1] = @tmpfile
+    __setobj__(@tmpfile)
+  end
+
+  def _close	# :nodoc:
+    @tmpfile.close if @tmpfile
+    @tmpfile = nil
+    @data[1] = nil if @data
+  end    
+  protected :_close
+
+  # Closes the file.  If the optional flag is true, unlinks the file
+  # after closing.
+  #
+  # If you don't explicitly unlink the temporary file, the removal
+  # will be delayed until the object is finalized.
+  def close(unlink_now=false)
+    if unlink_now
+      close!
+    else
+      _close
+    end
+  end
+
+  # Closes and unlinks the file.
+  def close!
+    _close
+    @clean_proc.call
+    ObjectSpace.undefine_finalizer(self)
+    @data = @tmpname = nil
+  end
+
+  # Unlinks the file.  On UNIX-like systems, it is often a good idea
+  # to unlink a temporary file immediately after creating and opening
+  # it, because it leaves other programs zero chance to access the
+  # file.
+  def unlink
+    # keep this order for thread safeness
+    begin
+      File.unlink(@tmpname) if File.exist?(@tmpname)
+      @@cleanlist.delete(@tmpname)
+      @data = @tmpname = nil
+      ObjectSpace.undefine_finalizer(self)
+    rescue Errno::EACCES
+      # may not be able to unlink on Windows; just ignore
+    end
+  end
+  alias delete unlink
+
+  # Returns the full path name of the temporary file.
+  def path
+    @tmpname
+  end
+
+  # Returns the size of the temporary file.  As a side effect, the IO
+  # buffer is flushed before determining the size.
+  def size
+    if @tmpfile
+      @tmpfile.flush
+      @tmpfile.stat.size
+    else
+      0
+    end
+  end
+  alias length size
+
+  class << self
+    def callback(data)	# :nodoc:
+      pid = $$
+      lambda{
+	if pid == $$ 
+	  path, tmpfile, cleanlist = *data
+
+	  print "removing ", path, "..." if $DEBUG
+
+	  tmpfile.close if tmpfile
+
+	  # keep this order for thread safeness
+	  File.unlink(path) if File.exist?(path)
+	  cleanlist.delete(path) if cleanlist
+
+	  print "done\n" if $DEBUG
+	end
+      }
+    end
+
+    # If no block is given, this is a synonym for new().
+    #
+    # If a block is given, it will be passed tempfile as an argument,
+    # and the tempfile will automatically be closed when the block
+    # terminates.  In this case, open() returns nil.
+    def open(*args)
+      tempfile = new(*args)
+
+      if block_given?
+	begin
+	  yield(tempfile)
+	ensure
+	  tempfile.close
+	end
+
+	nil
+      else
+	tempfile
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+#  $DEBUG = true
+  f = Tempfile.new("foo")
+  f.print("foo\n")
+  f.close
+  f.open
+  p f.gets # => "foo\n"
+  f.close!
+end