rubysl-irb 1.0.0

data/lib/irb/ext/math-mode.rb

@@ -0,0 +1,37 @@
+#
+#   math-mode.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+require "mathn"
+
+module IRB
+  class Context
+    attr_reader :math_mode
+    alias math? math_mode
+
+    def math_mode=(opt)
+      if @math_mode == true && opt == false
+	IRB.fail CantReturnToNormalMode
+	return
+      end
+
+      @math_mode = opt
+      if math_mode
+	main.extend Math
+	print "start math mode\n" if verbose?
+      end
+    end
+
+    def inspect?
+      @inspect_mode.nil? && !@math_mode or @inspect_mode
+    end
+  end
+end
+

data/lib/irb/ext/multi-irb.rb

@@ -0,0 +1,241 @@
+#
+#   irb/multi-irb.rb - multiple irb module
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#   
+#
+IRB.fail CantShiftToMultiIrbMode unless defined?(Thread)
+require "thread"
+
+module IRB
+  # job management class
+  class JobManager
+    @RCS_ID='-$Id: multi-irb.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
+
+    def initialize
+      # @jobs = [[thread, irb],...]
+      @jobs = []
+      @current_job = nil
+    end
+
+    attr_accessor :current_job
+
+    def n_jobs
+      @jobs.size
+    end
+
+    def thread(key)
+      th, irb = search(key)
+      th
+    end
+
+    def irb(key)
+      th, irb = search(key)
+      irb
+    end
+
+    def main_thread
+      @jobs[0][0]
+    end
+
+    def main_irb
+      @jobs[0][1]
+    end
+
+    def insert(irb)
+      @jobs.push [Thread.current, irb]
+    end
+
+    def switch(key)
+      th, irb = search(key)
+      IRB.fail IrbAlreadyDead unless th.alive?
+      IRB.fail IrbSwitchedToCurrentThread if th == Thread.current
+      @current_job = irb
+      th.run
+      Thread.stop
+      @current_job = irb(Thread.current)
+    end
+
+    def kill(*keys)
+      for key in keys
+	th, irb = search(key)
+	IRB.fail IrbAlreadyDead unless th.alive?
+	th.exit
+      end
+    end    
+
+    def search(key)
+      case key
+      when Integer
+	@jobs[key]
+      when Irb
+	@jobs.find{|k, v| v.equal?(key)}
+      when Thread
+	@jobs.assoc(key)
+      else
+	assoc = @jobs.find{|k, v| v.context.main.equal?(key)}
+	IRB.fail NoSuchJob, key if assoc.nil?
+	assoc
+      end
+    end
+
+    def delete(key)
+      case key
+      when Integer
+	IRB.fail NoSuchJob, key unless @jobs[key]
+	@jobs[key] = nil
+      else
+	catch(:EXISTS) do
+	  @jobs.each_index do
+	    |i|
+	    if @jobs[i] and (@jobs[i][0] == key ||
+			     @jobs[i][1] == key ||
+			     @jobs[i][1].context.main.equal?(key))
+	      @jobs[i] = nil
+	      throw :EXISTS
+	    end
+	  end
+	  IRB.fail NoSuchJob, key
+	end
+      end
+      until assoc = @jobs.pop; end unless @jobs.empty?
+      @jobs.push assoc
+    end
+
+    def inspect
+      ary = []
+      @jobs.each_index do
+	|i|
+	th, irb = @jobs[i]
+	next if th.nil?
+
+	if th.alive?
+	  if th.stop?
+	    t_status = "stop"
+	  else
+	    t_status = "running"
+	  end
+	else
+	  t_status = "exited"
+	end
+	ary.push format("#%d->%s on %s (%s: %s)",
+			i, 
+			irb.context.irb_name, 
+			irb.context.main,
+			th,
+			t_status)
+      end
+      ary.join("\n")
+    end
+  end
+
+  @JobManager = JobManager.new
+
+  def IRB.JobManager
+    @JobManager
+  end
+
+  def IRB.CurrentContext
+    IRB.JobManager.irb(Thread.current).context
+  end
+
+  # invoke multi-irb 
+  def IRB.irb(file = nil, *main)
+    workspace = WorkSpace.new(*main)
+    parent_thread = Thread.current
+    Thread.start do
+      begin
+	irb = Irb.new(workspace, file)
+      rescue 
+	print "Subirb can't start with context(self): ", workspace.main.inspect, "\n"
+	print "return to main irb\n"
+	Thread.pass
+	Thread.main.wakeup
+	Thread.exit
+      end
+      @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+      @JobManager.insert(irb)
+      @JobManager.current_job = irb
+      begin
+	system_exit = false
+	catch(:IRB_EXIT) do
+	  irb.eval_input
+	end
+      rescue SystemExit
+	system_exit = true
+	raise
+	#fail
+      ensure
+	unless system_exit
+	  @JobManager.delete(irb)
+	  if parent_thread.alive?
+	    @JobManager.current_job = @JobManager.irb(parent_thread)
+	    parent_thread.run
+	  else
+	    @JobManager.current_job = @JobManager.main_irb
+	    @JobManager.main_thread.run
+	  end
+	end
+      end
+    end
+    Thread.stop
+    @JobManager.current_job = @JobManager.irb(Thread.current)
+  end
+
+#   class Context
+#     def set_last_value(value)
+#       @last_value = value
+#       @workspace.evaluate "_ = IRB.JobManager.irb(Thread.current).context.last_value"
+#       if @eval_history #and !@__.equal?(@last_value)
+# 	@eval_history_values.push @line_no, @last_value
+# 	@workspace.evaluate "__ = IRB.JobManager.irb(Thread.current).context.instance_eval{@eval_history_values}"
+#       end
+#       @last_value
+#     end
+#   end
+
+#  module ExtendCommand
+#     def irb_context
+#       IRB.JobManager.irb(Thread.current).context
+#     end
+# #    alias conf irb_context
+#   end
+
+  @CONF[:SINGLE_IRB_MODE] = false
+  @JobManager.insert(@CONF[:MAIN_CONTEXT].irb)
+  @JobManager.current_job = @CONF[:MAIN_CONTEXT].irb
+
+  class Irb
+    def signal_handle
+      unless @context.ignore_sigint?
+	print "\nabort!!\n" if @context.verbose?
+	exit
+      end
+
+      case @signal_status
+      when :IN_INPUT
+	print "^C\n"
+	IRB.JobManager.thread(self).raise RubyLex::TerminateLineInput
+      when :IN_EVAL
+	IRB.irb_abort(self)
+      when :IN_LOAD
+	IRB.irb_abort(self, LoadAbort)
+      when :IN_IRB
+	# ignore
+      else
+	# ignore other cases as well
+      end
+    end
+  end
+
+  trap("SIGINT") do
+    @JobManager.current_job.signal_handle
+    Thread.stop
+  end
+
+end

data/lib/irb/ext/save-history.rb

@@ -0,0 +1,70 @@
+#!/usr/local/bin/ruby
+#
+#   save-history.rb -
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 Feb 2007) $
+#   	by Keiju ISHITSUKAkeiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "readline"
+
+module IRB
+  class Context
+    def init_save_history
+      hist = IRB.conf[:HISTORY_FILE]
+      hist = IRB.rc_file("_history") unless hist
+      if File.exist?(hist)
+        open(hist) do |f|
+          f.each {|l| Readline::HISTORY << l.chomp}
+        end
+      end
+
+      at_exit 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|
+            prev_line = nil
+            Readline::HISTORY.each do |line|
+              unless line == prev_line
+                f.puts line
+              end
+
+              prev_line = line
+            end
+          end
+        end
+      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
+end
+

data/lib/irb/ext/tracer.rb

@@ -0,0 +1,61 @@
+#
+#   irb/lib/tracer.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 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/lib/irb/ext/use-loader.rb

@@ -0,0 +1,65 @@
+#
+#   use-loader.rb - 
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 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
+
+