ruby_on_ruby 0.0.1

data/vendor/javascripts/emscripted-ruby/lib/irb/ext/save-history.rb

@@ -0,0 +1,85 @@
+#!/usr/local/bin/ruby
+#
+#   save-history.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#   	by Keiju ISHITSUKAkeiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+
+require "readline"
+
+module IRB
+  module HistorySavingAbility
+    @RCS_ID='-$Id: save-history.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
+  end
+
+  class Context
+    def init_save_history
+      unless (class<<@io;self;end).include?(HistorySavingAbility)
+	@io.extend(HistorySavingAbility)
+      end
+    end
+
+    def save_history
+      IRB.conf[:SAVE_HISTORY]
+    end
+
+    def save_history=(val)
+      IRB.conf[:SAVE_HISTORY] = val
+      if val
+	main_context = IRB.conf[:MAIN_CONTEXT]
+	main_context = self unless main_context
+	main_context.init_save_history
+      end
+    end
+
+    def history_file
+      IRB.conf[:HISTORY_FILE]
+    end
+
+    def history_file=(hist)
+      IRB.conf[:HISTORY_FILE] = hist
+    end
+  end
+
+  module HistorySavingAbility
+    include Readline
+
+    def HistorySavingAbility.create_finalizer
+      proc do
+	if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) > 0
+	  if hf = IRB.conf[:HISTORY_FILE]
+	    file = File.expand_path(hf)
+	  end
+	  file = IRB.rc_file("_history") unless file
+	  open(file, 'w' ) do |f|
+	    hist = HISTORY.to_a
+	    f.puts(hist[-num..-1] || hist)
+	  end
+	end
+      end
+    end
+
+    def HistorySavingAbility.extended(obj)
+      ObjectSpace.define_finalizer(obj, HistorySavingAbility.create_finalizer)
+      obj.load_history
+      obj
+    end
+
+    def load_history
+      hist = IRB.conf[:HISTORY_FILE]
+      hist = IRB.rc_file("_history") unless hist
+      if File.exist?(hist)
+	open(hist) do |f|
+	  f.each {|l| HISTORY << l.chomp}
+	end
+      end
+    end
+  end
+end
+

data/vendor/javascripts/emscripted-ruby/lib/irb/ext/tracer.rb

@@ -0,0 +1,61 @@
+#
+#   irb/lib/tracer.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+require "tracer"
+
+module IRB
+
+  # initialize tracing function
+  def IRB.initialize_tracer
+    Tracer.verbose = false
+    Tracer.add_filter {
+      |event, file, line, id, binding, *rests|
+      /^#{Regexp.quote(@CONF[:IRB_LIB_PATH])}/ !~ file and
+	File::basename(file) != "irb.rb"
+    }
+  end
+
+  class Context
+    attr_reader :use_tracer
+    alias use_tracer? use_tracer
+
+    def use_tracer=(opt)
+      if opt
+	Tracer.set_get_line_procs(@irb_path) {
+	  |line_no, *rests|
+	  @io.line(line_no)
+	}
+      elsif !opt && @use_tracer
+	Tracer.off
+      end
+      @use_tracer=opt
+    end
+  end
+
+  class WorkSpace
+    alias __evaluate__ evaluate
+    def evaluate(context, statements, file = nil, line = nil)
+      if context.use_tracer? && file != nil && line != nil
+	Tracer.on 
+	begin
+	  __evaluate__(context, statements, file, line)
+	ensure
+	  Tracer.off
+	end
+      else
+	__evaluate__(context, statements, file || __FILE__, line || __LINE__)
+      end
+    end
+  end
+
+  IRB.initialize_tracer
+end
+	

data/vendor/javascripts/emscripted-ruby/lib/irb/ext/use-loader.rb

@@ -0,0 +1,65 @@
+#
+#   use-loader.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+
+require "irb/cmd/load"
+require "irb/ext/loader"
+
+class Object
+  alias __original__load__IRB_use_loader__ load
+  alias __original__require__IRB_use_loader__ require
+end
+
+module IRB
+  module ExtendCommandBundle
+    def irb_load(*opts, &b)
+      ExtendCommand::Load.execute(irb_context, *opts, &b)
+    end
+    def irb_require(*opts, &b)
+      ExtendCommand::Require.execute(irb_context, *opts, &b)
+    end
+  end
+
+  class Context
+
+    IRB.conf[:USE_LOADER] = false
+    
+    def use_loader
+      IRB.conf[:USE_LOADER]
+    end
+
+    alias use_loader? use_loader
+
+    def use_loader=(opt)
+
+      if IRB.conf[:USE_LOADER] != opt
+	IRB.conf[:USE_LOADER] = opt
+	if opt
+	  if !$".include?("irb/cmd/load")
+	  end
+	  (class<<@workspace.main;self;end).instance_eval {
+	    alias_method :load, :irb_load
+	    alias_method :require, :irb_require
+	  }
+	else
+	  (class<<@workspace.main;self;end).instance_eval {
+	    alias_method :load, :__original__load__IRB_use_loader__
+	    alias_method :require, :__original__require__IRB_use_loader__
+	  }
+	end
+      end
+      print "Switch to load/require#{unless use_loader; ' non';end} trace mode.\n" if verbose?
+      opt
+    end
+  end
+end
+
+

data/vendor/javascripts/emscripted-ruby/lib/irb/ext/workspaces.rb

@@ -0,0 +1,56 @@
+#
+#   push-ws.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+
+module IRB
+  class Context
+
+    def irb_level
+      workspace_stack.size
+    end
+
+    def workspaces
+      if defined? @workspaces
+	@workspaces
+      else
+	@workspaces = []
+      end
+    end
+
+    def push_workspace(*_main)
+      if _main.empty?
+	if workspaces.empty?
+	  print "No other workspace\n"
+	  return nil
+	end
+	ws = workspaces.pop
+	workspaces.push @workspace
+	@workspace = ws
+	return workspaces
+      end
+
+      workspaces.push @workspace
+      @workspace = WorkSpace.new(@workspace.binding, _main[0])
+      if !(class<<main;ancestors;end).include?(ExtendCommandBundle)
+	main.extend ExtendCommandBundle
+      end
+    end
+
+    def pop_workspace
+      if workspaces.empty?
+	print "workspace stack empty\n"
+	return
+      end
+      @workspace = workspaces.pop
+    end
+  end
+end
+

data/vendor/javascripts/emscripted-ruby/lib/irb/extend-command.rb

@@ -0,0 +1,264 @@
+#
+#   irb/extend-command.rb - irb extend command 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+module IRB
+  #
+  # IRB extended command
+  #
+  module ExtendCommandBundle
+    EXCB = ExtendCommandBundle
+
+    NO_OVERRIDE = 0
+    OVERRIDE_PRIVATE_ONLY = 0x01
+    OVERRIDE_ALL = 0x02
+
+    def irb_exit(ret = 0)
+      irb_context.exit(ret)
+    end
+
+    def irb_context
+      IRB.CurrentContext
+    end
+
+    @ALIASES = [
+      [:context, :irb_context, NO_OVERRIDE],
+      [:conf, :irb_context, NO_OVERRIDE],
+      [:irb_quit, :irb_exit, OVERRIDE_PRIVATE_ONLY],
+      [:exit, :irb_exit, OVERRIDE_PRIVATE_ONLY],
+      [:quit, :irb_exit, OVERRIDE_PRIVATE_ONLY],
+    ]
+
+    @EXTEND_COMMANDS = [
+      [:irb_current_working_workspace, :CurrentWorkingWorkspace, "irb/cmd/chws",
+	[:irb_print_working_workspace, OVERRIDE_ALL],
+	[:irb_cwws, OVERRIDE_ALL],
+	[:irb_pwws, OVERRIDE_ALL],
+#	[:irb_cww, OVERRIDE_ALL],
+#	[:irb_pww, OVERRIDE_ALL],
+	[:cwws, NO_OVERRIDE],
+	[:pwws, NO_OVERRIDE],
+#	[:cww, NO_OVERRIDE],
+#	[:pww, NO_OVERRIDE],
+	[:irb_current_working_binding, OVERRIDE_ALL],
+	[:irb_print_working_binding, OVERRIDE_ALL],
+	[:irb_cwb, OVERRIDE_ALL],
+	[:irb_pwb, OVERRIDE_ALL],
+#	[:cwb, NO_OVERRIDE],
+#	[:pwb, NO_OVERRIDE]
+      ],
+      [:irb_change_workspace, :ChangeWorkspace, "irb/cmd/chws",
+	[:irb_chws, OVERRIDE_ALL],
+#	[:irb_chw, OVERRIDE_ALL],
+	[:irb_cws, OVERRIDE_ALL],
+#	[:irb_cw, OVERRIDE_ALL],
+	[:chws, NO_OVERRIDE],
+#	[:chw, NO_OVERRIDE],
+	[:cws, NO_OVERRIDE],
+#	[:cw, NO_OVERRIDE],
+	[:irb_change_binding, OVERRIDE_ALL],
+	[:irb_cb, OVERRIDE_ALL],
+	[:cb, NO_OVERRIDE]],
+
+      [:irb_workspaces, :Workspaces, "irb/cmd/pushws",
+	[:workspaces, NO_OVERRIDE],
+	[:irb_bindings, OVERRIDE_ALL],
+	[:bindings, NO_OVERRIDE]],
+      [:irb_push_workspace, :PushWorkspace, "irb/cmd/pushws",
+	[:irb_pushws, OVERRIDE_ALL],
+#	[:irb_pushw, OVERRIDE_ALL],
+	[:pushws, NO_OVERRIDE],
+#	[:pushw, NO_OVERRIDE],
+	[:irb_push_binding, OVERRIDE_ALL],
+	[:irb_pushb, OVERRIDE_ALL],
+	[:pushb, NO_OVERRIDE]],
+      [:irb_pop_workspace, :PopWorkspace, "irb/cmd/pushws",
+	[:irb_popws, OVERRIDE_ALL],
+#	[:irb_popw, OVERRIDE_ALL],
+	[:popws, NO_OVERRIDE],
+#	[:popw, NO_OVERRIDE],
+	[:irb_pop_binding, OVERRIDE_ALL],
+	[:irb_popb, OVERRIDE_ALL],
+	[:popb, NO_OVERRIDE]],
+
+      [:irb_load, :Load, "irb/cmd/load"],
+      [:irb_require, :Require, "irb/cmd/load"],
+      [:irb_source, :Source, "irb/cmd/load", 
+	[:source, NO_OVERRIDE]],
+
+      [:irb, :IrbCommand, "irb/cmd/subirb"],
+      [:irb_jobs, :Jobs, "irb/cmd/subirb", 
+	[:jobs, NO_OVERRIDE]],
+      [:irb_fg, :Foreground, "irb/cmd/subirb", 
+	[:fg, NO_OVERRIDE]],
+      [:irb_kill, :Kill, "irb/cmd/subirb", 
+	[:kill, OVERRIDE_PRIVATE_ONLY]],
+
+      [:irb_help, :Help, "irb/cmd/help",
+        [:help, NO_OVERRIDE]],
+
+    ]
+
+    def self.install_extend_commands
+      for args in @EXTEND_COMMANDS
+	def_extend_command(*args)
+      end
+    end
+
+    # aliases = [commans_alias, flag], ...
+    def self.def_extend_command(cmd_name, cmd_class, load_file = nil, *aliases)
+      case cmd_class
+      when Symbol
+	cmd_class = cmd_class.id2name
+      when String
+      when Class
+	cmd_class = cmd_class.name
+      end
+
+      if load_file
+	eval %[
+	  def #{cmd_name}(*opts, &b)
+	    require "#{load_file}"
+	    eval %[
+	      def #{cmd_name}(*opts, &b)
+		ExtendCommand::#{cmd_class}.execute(irb_context, *opts, &b)
+	      end
+	    ]
+	    send :#{cmd_name}, *opts, &b
+	  end
+	]
+      else
+	eval %[
+	  def #{cmd_name}(*opts, &b)
+	    ExtendCommand::#{cmd_class}.execute(irb_context, *opts, &b)
+	  end
+	]
+      end
+
+      for ali, flag in aliases
+	@ALIASES.push [ali, cmd_name, flag]
+      end
+    end
+
+    # override = {NO_OVERRIDE, OVERRIDE_PRIVATE_ONLY, OVERRIDE_ALL}
+    def install_alias_method(to, from, override = NO_OVERRIDE)
+      to = to.id2name unless to.kind_of?(String)
+      from = from.id2name unless from.kind_of?(String)
+
+      if override == OVERRIDE_ALL or
+	  (override == OVERRIDE_PRIVATE_ONLY) && !respond_to?(to) or
+	  (override == NO_OVERRIDE) &&  !respond_to?(to, true)
+	target = self
+	(class<<self;self;end).instance_eval{
+	  if target.respond_to?(to, true) && 
+	      !target.respond_to?(EXCB.irb_original_method_name(to), true)
+	    alias_method(EXCB.irb_original_method_name(to), to) 
+	  end
+	  alias_method to, from
+	}
+      else
+	print "irb: warn: can't alias #{to} from #{from}.\n"
+      end
+    end
+
+    def self.irb_original_method_name(method_name)
+      "irb_" + method_name + "_org"
+    end
+
+    def self.extend_object(obj)
+      unless (class<<obj;ancestors;end).include?(EXCB)
+	super
+	for ali, com, flg in @ALIASES
+	  obj.install_alias_method(ali, com, flg)
+	end
+      end
+    end
+
+    install_extend_commands
+  end
+
+  # extension support for Context
+  module ContextExtender
+    CE = ContextExtender
+
+    @EXTEND_COMMANDS = [
+      [:eval_history=, "irb/ext/history.rb"],
+      [:use_tracer=, "irb/ext/tracer.rb"],
+      [:math_mode=, "irb/ext/math-mode.rb"],
+      [:use_loader=, "irb/ext/use-loader.rb"],
+      [:save_history=, "irb/ext/save-history.rb"],
+    ]
+
+    def self.install_extend_commands
+      for args in @EXTEND_COMMANDS
+	def_extend_command(*args)
+      end
+    end
+
+    def self.def_extend_command(cmd_name, load_file, *aliases)
+      Context.module_eval %[
+        def #{cmd_name}(*opts, &b)
+	  Context.module_eval {remove_method(:#{cmd_name})}
+	  require "#{load_file}"
+	  send :#{cmd_name}, *opts, &b
+	end
+	for ali in aliases
+	  alias_method ali, cmd_name
+	end
+      ]
+    end
+
+    CE.install_extend_commands
+  end
+
+  module MethodExtender
+    def def_pre_proc(base_method, extend_method)
+      base_method = base_method.to_s
+      extend_method = extend_method.to_s
+
+      alias_name = new_alias_name(base_method)
+      module_eval %[
+        alias_method alias_name, base_method
+        def #{base_method}(*opts)
+	  send :#{extend_method}, *opts
+	  send :#{alias_name}, *opts
+	end
+      ]
+    end
+
+    def def_post_proc(base_method, extend_method)
+      base_method = base_method.to_s
+      extend_method = extend_method.to_s
+
+      alias_name = new_alias_name(base_method)
+      module_eval %[
+        alias_method alias_name, base_method
+        def #{base_method}(*opts)
+	  send :#{alias_name}, *opts
+	  send :#{extend_method}, *opts
+	end
+      ]
+    end
+
+    # return #{prefix}#{name}#{postfix}<num>
+    def new_alias_name(name, prefix = "__alias_of__", postfix = "__")
+      base_name = "#{prefix}#{name}#{postfix}"
+      all_methods = instance_methods(true) + private_instance_methods(true)
+      same_methods = all_methods.grep(/^#{Regexp.quote(base_name)}[0-9]*$/)
+      return base_name if same_methods.empty?
+      no = same_methods.size
+      while !same_methods.include?(alias_name = base_name + no)
+	no += 1
+      end
+      alias_name
+    end
+  end
+end
+