ruby_on_ruby 0.0.1

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

@@ -0,0 +1,6 @@
+require 'profiler'
+
+END {
+  Profiler__::print_profile(STDERR)
+}
+Profiler__::start_profile

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

@@ -0,0 +1,59 @@
+module Profiler__
+  # internal values
+  @@start = @@stack = @@map = nil
+  PROFILE_PROC = proc{|event, file, line, id, binding, klass|
+    case event
+    when "call", "c-call"
+      now = Process.times[0]
+      @@stack.push [now, 0.0]
+    when "return", "c-return"
+      now = Process.times[0]
+      key = [klass, id]
+      if tick = @@stack.pop
+        data = (@@map[key] ||= [0, 0.0, 0.0, key])
+        data[0] += 1
+        cost = now - tick[0]
+        data[1] += cost
+        data[2] += cost - tick[1]
+        @@stack[-1][1] += cost if @@stack[-1]
+      end
+    end
+  }
+module_function
+  def start_profile
+    @@start = Process.times[0]
+    @@stack = []
+    @@map = {}
+    set_trace_func PROFILE_PROC
+  end
+  def stop_profile
+    set_trace_func nil
+  end
+  def print_profile(f)
+    stop_profile
+    total = Process.times[0] - @@start
+    if total == 0 then total = 0.01 end
+    data = @@map.values
+    data.sort!{|a,b| b[2] <=> a[2]}
+    sum = 0
+    f.printf "  %%   cumulative   self              self     total\n"
+    f.printf " time   seconds   seconds    calls  ms/call  ms/call  name\n"
+    for d in data
+      sum += d[2]
+      f.printf "%6.2f %8.2f  %8.2f %8d ", d[2]/total*100, sum, d[2], d[0]
+      f.printf "%8.2f %8.2f  %s\n", d[2]*1000/d[0], d[1]*1000/d[0], get_name(*d[3])
+    end
+    f.printf "%6.2f %8.2f  %8.2f %8d ", 0.0, total, 0.0, 1     # ???
+    f.printf "%8.2f %8.2f  %s\n", 0.0, total*1000, "#toplevel" # ???
+  end
+  def get_name(klass, id)
+    name = klass.to_s || ""
+    if klass.kind_of? Class
+      name += "#"
+    else
+      name += "."
+    end
+    name + id.id2name
+  end
+  private :get_name
+end

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

@@ -0,0 +1,395 @@
+# = PStore -- Transactional File Storage for Ruby Objects
+#
+# pstore.rb -
+#   originally by matz
+#   documentation by Kev Jackson and James Edward Gray II
+#
+# See PStore for documentation.
+
+
+require "fileutils"
+require "digest/md5"
+
+#
+# PStore implements a file based persistance mechanism based on a Hash.  User
+# code can store hierarchies of Ruby objects (values) into the data store file
+# by name (keys).  An object hierarchy may be just a single object.  User code 
+# may later read values back from the data store or even update data, as needed.
+# 
+# The transactional behavior ensures that any changes succeed or fail together.
+# This can be used to ensure that the data store is not left in a transitory
+# state, where some values were upated but others were not.
+# 
+# Behind the scenes, Ruby objects are stored to the data store file with 
+# Marshal.  That carries the usual limitations.  Proc objects cannot be 
+# marshalled, for example.
+#
+# == Usage example:
+# 
+#  require "pstore"
+#  
+#  # a mock wiki object...
+#  class WikiPage
+#    def initialize( page_name, author, contents )
+#      @page_name = page_name
+#      @revisions = Array.new
+#      
+#      add_revision(author, contents)
+#    end
+#    
+#    attr_reader :page_name
+#    
+#    def add_revision( author, contents )
+#      @revisions << { :created  => Time.now,
+#                      :author   => author,
+#                      :contents => contents }
+#    end
+#    
+#    def wiki_page_references
+#      [@page_name] + @revisions.last[:contents].scan(/\b(?:[A-Z]+[a-z]+){2,}/)
+#    end
+#    
+#    # ...
+#  end
+#  
+#  # create a new page...
+#  home_page = WikiPage.new( "HomePage", "James Edward Gray II",
+#                            "A page about the JoysOfDocumentation..." )
+#  
+#  # then we want to update page data and the index together, or not at all...
+#  wiki = PStore.new("wiki_pages.pstore")
+#  wiki.transaction do  # begin transaction; do all of this or none of it
+#    # store page...
+#    wiki[home_page.page_name] = home_page
+#    # ensure that an index has been created...
+#    wiki[:wiki_index] ||= Array.new
+#    # update wiki index...
+#    wiki[:wiki_index].push(*home_page.wiki_page_references)
+#  end                   # commit changes to wiki data store file
+#  
+#  ### Some time later... ###
+#  
+#  # read wiki data...
+#  wiki.transaction(true) do  # begin read-only transaction, no changes allowed
+#    wiki.roots.each do |data_root_name|
+#      p data_root_name
+#      p wiki[data_root_name]
+#    end
+#  end
+#
+class PStore
+  binmode = defined?(File::BINARY) ? File::BINARY : 0
+  RDWR_ACCESS = File::RDWR | File::CREAT | binmode
+  RD_ACCESS = File::RDONLY | binmode
+  WR_ACCESS = File::WRONLY | File::CREAT | File::TRUNC | binmode
+
+  # The error type thrown by all PStore methods.
+  class Error < StandardError
+  end
+
+  # 
+  # To construct a PStore object, pass in the _file_ path where you would like 
+  # the data to be stored.
+  # 
+  def initialize(file)
+    dir = File::dirname(file)
+    unless File::directory? dir
+      raise PStore::Error, format("directory %s does not exist", dir)
+    end
+    if File::exist? file and not File::readable? file
+      raise PStore::Error, format("file %s not readable", file)
+    end
+    @transaction = false
+    @filename = file
+    @abort = false
+  end
+
+  # Raises PStore::Error if the calling code is not in a PStore#transaction.
+  def in_transaction
+    raise PStore::Error, "not in transaction" unless @transaction
+  end
+  # 
+  # Raises PStore::Error if the calling code is not in a PStore#transaction or
+  # if the code is in a read-only PStore#transaction.
+  # 
+  def in_transaction_wr()
+    in_transaction()
+    raise PStore::Error, "in read-only transaction" if @rdonly
+  end
+  private :in_transaction, :in_transaction_wr
+
+  #
+  # Retrieves a value from the PStore file data, by _name_.  The hierarchy of 
+  # Ruby objects stored under that root _name_ will be returned.
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def [](name)
+    in_transaction
+    @table[name]
+  end
+  #
+  # This method is just like PStore#[], save that you may also provide a 
+  # _default_ value for the object.  In the event the specified _name_ is not 
+  # found in the data store, your _default_ will be returned instead.  If you do 
+  # not specify a default, PStore::Error will be raised if the object is not 
+  # found.
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def fetch(name, default=PStore::Error)
+    in_transaction
+    unless @table.key? name
+      if default==PStore::Error
+	raise PStore::Error, format("undefined root name `%s'", name)
+      else
+	return default
+      end
+    end
+    @table[name]
+  end
+  #
+  # Stores an individual Ruby object or a hierarchy of Ruby objects in the data
+  # store file under the root _name_.  Assigning to a _name_ already in the data
+  # store clobbers the old data.
+  # 
+  # == Example:
+  # 
+  #  require "pstore"
+  #  
+  #  store = PStore.new("data_file.pstore")
+  #  store.transaction do  # begin transaction
+  #    # load some data into the store...
+  #    store[:single_object] = "My data..."
+  #    store[:obj_heirarchy] = { "Kev Jackson" => ["rational.rb", "pstore.rb"],
+  #                              "James Gray"  => ["erb.rb", "pstore.rb"] }
+  #  end                   # commit changes to data store file
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction and it cannot
+  # be read-only.  It will raise PStore::Error if called at any other time.
+  #
+  def []=(name, value)
+    in_transaction_wr()
+    @table[name] = value
+  end
+  #
+  # Removes an object hierarchy from the data store, by _name_.
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction and it cannot
+  # be read-only.  It will raise PStore::Error if called at any other time.
+  #
+  def delete(name)
+    in_transaction_wr()
+    @table.delete name
+  end
+
+  #
+  # Returns the names of all object hierarchies currently in the store.
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def roots
+    in_transaction
+    @table.keys
+  end
+  #
+  # Returns true if the supplied _name_ is currently in the data store.
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def root?(name)
+    in_transaction
+    @table.key? name
+  end
+  # Returns the path to the data store file.
+  def path
+    @filename
+  end
+
+  #
+  # Ends the current PStore#transaction, committing any changes to the data
+  # store immediately.
+  # 
+  # == Example:
+  # 
+  #  require "pstore"
+  #   
+  #  store = PStore.new("data_file.pstore")
+  #  store.transaction do  # begin transaction
+  #    # load some data into the store...
+  #    store[:one] = 1
+  #    store[:two] = 2
+  #  
+  #    store.commit        # end transaction here, committing changes
+  #  
+  #    store[:three] = 3   # this change is never reached
+  #  end
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def commit
+    in_transaction
+    @abort = false
+    throw :pstore_abort_transaction
+  end
+  #
+  # Ends the current PStore#transaction, discarding any changes to the data
+  # store.
+  # 
+  # == Example:
+  # 
+  #  require "pstore"
+  #   
+  #  store = PStore.new("data_file.pstore")
+  #  store.transaction do  # begin transaction
+  #    store[:one] = 1     # this change is not applied, see below...
+  #    store[:two] = 2     # this change is not applied, see below...
+  #  
+  #    store.abort         # end transaction here, discard all changes
+  #  
+  #    store[:three] = 3   # this change is never reached
+  #  end
+  # 
+  # *WARNING*:  This method is only valid in a PStore#transaction.  It will
+  # raise PStore::Error if called at any other time.
+  #
+  def abort
+    in_transaction
+    @abort = true
+    throw :pstore_abort_transaction
+  end
+
+  #
+  # Opens a new transaction for the data store.  Code executed inside a block
+  # passed to this method may read and write data to and from the data store 
+  # file.
+  # 
+  # At the end of the block, changes are committed to the data store
+  # automatically.  You may exit the transaction early with a call to either 
+  # PStore#commit or PStore#abort.  See those methods for details about how
+  # changes are handled.  Raising an uncaught Exception in the block is 
+  # equivalent to calling PStore#abort.
+  # 
+  # If _read_only_ is set to +true+, you will only be allowed to read from the
+  # data store during the transaction and any attempts to change the data will
+  # raise a PStore::Error.
+  # 
+  # Note that PStore does not support nested transactions.
+  #
+  def transaction(read_only=false)  # :yields:  pstore
+    raise PStore::Error, "nested transaction" if @transaction
+    begin
+      @rdonly = read_only
+      @abort = false
+      @transaction = true
+      value = nil
+      new_file = @filename + ".new"
+
+      content = nil
+      unless read_only
+        file = File.open(@filename, RDWR_ACCESS)
+        file.flock(File::LOCK_EX)
+        commit_new(file) if FileTest.exist?(new_file)
+        content = file.read()
+      else
+        begin
+          file = File.open(@filename, RD_ACCESS)
+          file.flock(File::LOCK_SH)
+          content = (File.open(new_file, RD_ACCESS) {|n| n.read} rescue file.read())
+        rescue Errno::ENOENT
+          content = ""
+        end
+      end
+
+      if content != ""
+	@table = load(content)
+        if !read_only
+          size = content.size
+          md5 = Digest::MD5.digest(content)
+        end
+      else
+	@table = {}
+      end
+      content = nil		# unreference huge data
+
+      begin
+	catch(:pstore_abort_transaction) do
+	  value = yield(self)
+	end
+      rescue Exception
+	@abort = true
+	raise
+      ensure
+	if !read_only and !@abort
+          tmp_file = @filename + ".tmp"
+	  content = dump(@table)
+	  if !md5 || size != content.size || md5 != Digest::MD5.digest(content)
+            File.open(tmp_file, WR_ACCESS) {|t| t.write(content)}
+            File.rename(tmp_file, new_file)
+            commit_new(file)
+          end
+          content = nil		# unreference huge data
+	end
+      end
+    ensure
+      @table = nil
+      @transaction = false
+      file.close if file
+    end
+    value
+  end
+
+  # This method is just a wrapped around Marshal.dump.
+  def dump(table)  # :nodoc:
+    Marshal::dump(table)
+  end
+
+  # This method is just a wrapped around Marshal.load.
+  def load(content)  # :nodoc:
+    Marshal::load(content)
+  end
+
+  # This method is just a wrapped around Marshal.load.
+  def load_file(file)  # :nodoc:
+    Marshal::load(file)
+  end
+
+  private
+  # Commits changes to the data store file.
+  def commit_new(f)
+    f.truncate(0)
+    f.rewind
+    new_file = @filename + ".new"
+    File.open(new_file, RD_ACCESS) do |nf|
+      FileUtils.copy_stream(nf, f)
+    end
+    File.unlink(new_file)
+  end
+end
+
+# :enddoc:
+
+if __FILE__ == $0
+  db = PStore.new("/tmp/foo")
+  db.transaction do
+    p db.roots
+    ary = db["root"] = [1,2,3,4]
+    ary[1] = [1,1.5]
+  end
+
+  1000.times do
+    db.transaction do
+      db["root"][0] += 1
+      p db["root"][0]
+    end
+  end
+
+  db.transaction(true) do
+    p db["root"]
+  end
+end