rubysl-irb 1.0.0

data/lib/irb/version.rb

@@ -0,0 +1,16 @@
+#
+#   irb/version.rb - irb version definition file
+#   	$Release Version: 0.9.5$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 Feb 2007) $
+#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#
+# --
+#
+#   
+#
+
+module IRB
+  @RELEASE_VERSION = "0.9.5"
+  @LAST_UPDATE_DATE = "05/04/13"
+end

data/lib/irb/workspace.rb

@@ -0,0 +1,107 @@
+#
+#   irb/workspace-binding.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)
+#
+# --
+#
+#   
+#
+module IRB
+  class WorkSpace
+    # create new workspace. set self to main if specified, otherwise
+    # inherit main from TOPLEVEL_BINDING.
+    def initialize(*main)
+      if main[0].kind_of?(Binding)
+	@binding = main.shift
+      elsif IRB.conf[:SINGLE_IRB]
+	@binding = TOPLEVEL_BINDING
+      else
+	case IRB.conf[:CONTEXT_MODE]
+	when 0	# binding in proc on TOPLEVEL_BINDING
+	  @binding = eval("proc{binding}.call",
+		      TOPLEVEL_BINDING, 
+		      __FILE__,
+		      __LINE__)
+	when 1	# binding in loaded file
+	  require "tempfile"
+	  f = Tempfile.open("irb-binding")
+	  f.print <<EOF
+	  $binding = binding
+EOF
+	  f.close
+	  load f.path
+	  @binding = $binding
+
+	when 2	# binding in loaded file(thread use)
+	  unless defined? BINDING_QUEUE
+	    require "thread"
+	    
+	    IRB.const_set("BINDING_QUEUE", SizedQueue.new(1))
+	    Thread.abort_on_exception = true
+	    Thread.start do
+	      eval "require \"irb/ws-for-case-2\"", TOPLEVEL_BINDING, __FILE__, __LINE__
+	    end
+	    Thread.pass
+	  end
+	  @binding = BINDING_QUEUE.pop
+
+	when 3	# binging in function on TOPLEVEL_BINDING(default)
+	  @binding = eval("def irb_binding; binding; end; irb_binding",
+		      TOPLEVEL_BINDING, 
+		      __FILE__,
+		      __LINE__ - 3)
+	end
+      end
+      if main.empty?
+	@main = eval("self", @binding)
+      else
+	@main = main[0]
+	IRB.conf[:__MAIN__] = @main
+	case @main
+	when Module
+	  @binding = eval("IRB.conf[:__MAIN__].module_eval('binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
+	else
+	  begin 
+	    @binding = eval("IRB.conf[:__MAIN__].instance_eval('binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
+	  rescue TypeError
+	    IRB.fail CantChangeBinding, @main.inspect
+	  end
+	end
+      end
+      eval("_=nil", @binding)
+    end
+
+    attr_reader :binding
+    attr_reader :main
+
+    def evaluate(context, statements, file = __FILE__, line = __LINE__)
+      eval(statements, @binding, file, line)
+    end
+  
+    # error message manipulator
+    def filter_backtrace(bt)
+      case IRB.conf[:CONTEXT_MODE]
+      when 0
+	return nil if bt =~ /\(irb_local_binding\)/
+      when 1
+	if(bt =~ %r!/tmp/irb-binding! or
+	   bt =~ %r!irb/.*\.rb! or
+	   bt =~ /irb\.rb/)
+	  return nil
+	end
+      when 2
+	return nil if bt =~ /irb\/.*\.rb/
+      when 3
+	return nil if bt =~ /irb\/.*\.rb/
+	bt.sub!(/:\s*in `irb_binding'/){""} 
+      end
+      bt
+    end
+
+    def IRB.delete_caller
+    end
+  end
+end

data/lib/irb/ws-for-case-2.rb

@@ -0,0 +1,15 @@
+#
+#   irb/ws-for-case-2.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)
+#
+# --
+#
+#   
+#
+
+while true
+  IRB::BINDING_QUEUE.push b = binding
+end

data/lib/irb/xmp.rb

@@ -0,0 +1,86 @@
+#
+#   xmp.rb - irb version of gotoken xmp
+#   	$Release Version: 0.9$
+#   	$Revision: 11708 $
+#   	$Date: 2007-02-12 15:01:19 -0800 (Mon, 12 Feb 2007) $
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+require "irb"
+require "irb/frame"
+
+class XMP
+  @RCS_ID='-$Id: xmp.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
+
+  def initialize(bind = nil)
+    IRB.init_config(nil)
+    #IRB.parse_opts
+    #IRB.load_modules
+
+    IRB.conf[:PROMPT_MODE] = :XMP
+
+    bind = IRB::Frame.top(1) unless bind
+    ws = IRB::WorkSpace.new(bind)
+    @io = StringInputMethod.new
+    @irb = IRB::Irb.new(ws, @io)
+    @irb.context.ignore_sigint = false
+
+#    IRB.conf[:IRB_RC].call(@irb.context) if IRB.conf[:IRB_RC]
+    IRB.conf[:MAIN_CONTEXT] = @irb.context
+  end
+
+  def puts(exps)
+    @io.puts exps
+
+    if @irb.context.ignore_sigint
+      begin
+	trap_proc_b = trap("SIGINT"){@irb.signal_handle}
+	catch(:IRB_EXIT) do
+	  @irb.eval_input
+	end
+      ensure
+	trap("SIGINT", trap_proc_b)
+      end
+    else
+      catch(:IRB_EXIT) do
+	@irb.eval_input
+      end
+    end
+  end
+
+  class StringInputMethod < IRB::InputMethod
+    def initialize
+      super
+      @exps = []
+    end
+
+    def eof?
+      @exps.empty?
+    end
+
+    def gets
+      while l = @exps.shift
+	next if /^\s+$/ =~ l
+	l.concat "\n"
+	print @prompt, l
+	break
+      end
+      l
+    end
+
+    def puts(exps)
+      @exps.concat exps.split(/\n/)
+    end
+  end
+end
+
+def xmp(exps, bind = nil)
+  bind = IRB::Frame.top(1) unless bind
+  xmp = XMP.new(bind)
+  xmp.puts exps
+  xmp
+end

data/lib/irb.rb

@@ -0,0 +1 @@
+require "rubysl/irb"

data/lib/rubysl/irb/irb.rb

@@ -0,0 +1,356 @@
+#
+#   irb.rb - irb main module
+#   	$Release Version: 0.9.5 $
+#   	$Revision: 15408 $
+#   	$Date: 2008-02-08 07:44:54 -0800 (Fri, 08 Feb 2008) $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+require "e2mmap"
+
+require "irb/init"
+require "irb/context"
+require "irb/extend-command"
+#require "irb/workspace"
+
+require "irb/ruby-lex"
+require "irb/input-method"
+require "irb/locale"
+
+STDOUT.sync = true
+
+module IRB
+  @RCS_ID='-$Id: irb.rb 15408 2008-02-08 15:44:54Z nobu $-'
+
+  class Abort < Exception;end
+
+  #
+  @CONF = {}
+
+  def IRB.conf
+    @CONF
+  end
+
+  # IRB version method
+  def IRB.version
+    if v = @CONF[:VERSION] then return v end
+
+    require "irb/version"
+    rv = @RELEASE_VERSION.sub(/\.0/, "")
+    @CONF[:VERSION] = format("irb %s(%s)", rv, @LAST_UPDATE_DATE)
+  end
+
+  def IRB.CurrentContext
+    IRB.conf[:MAIN_CONTEXT]
+  end
+
+  # initialize IRB and start TOP_LEVEL irb
+  def IRB.start(ap_path = nil)
+    $0 = File::basename(ap_path, ".rb") if ap_path
+
+    IRB.setup(ap_path)
+
+    if @CONF[:IRB_CLASS]
+      klass = @CONF[:IRB_CLASS]
+    else
+      klass = Irb
+    end
+
+    if @CONF[:SCRIPT]
+      irb = klass.new(nil, @CONF[:SCRIPT])
+    else
+      irb = klass.new
+    end
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+    
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+#    print "\n"
+  end
+
+  def IRB.irb_exit(irb, ret)
+    throw :IRB_EXIT, ret
+  end
+
+  def IRB.irb_abort(irb, exception = Abort)
+    if defined? Thread
+      irb.context.thread.raise exception, "abort then interrupt!!"
+    else
+      raise exception, "abort then interrupt!!"
+    end
+  end
+
+  #
+  # irb interpriter main routine 
+  #
+  class Irb
+    def initialize(workspace = nil, input_method = nil, output_method = nil)
+      @context = Context.new(self, workspace, input_method, output_method)
+      @context.main.extend ExtendCommandBundle
+      @signal_status = :IN_IRB
+
+      @scanner = RubyLex.new
+      @scanner.exception_on_syntax_error = false
+    end
+    attr_reader :context
+    attr_accessor :scanner
+
+    def eval_input
+      @scanner.set_prompt do
+	|ltype, indent, continue, line_no|
+	if ltype
+	  f = @context.prompt_s
+	elsif continue
+	  f = @context.prompt_c
+	elsif indent > 0
+	  f = @context.prompt_n
+	else @context.prompt_i
+	  f = @context.prompt_i
+	end
+	f = "" unless f
+	if @context.prompting?
+	  @context.io.prompt = p = prompt(f, ltype, indent, line_no)
+	else
+	  @context.io.prompt = p = ""
+	end
+	if @context.auto_indent_mode
+	  unless ltype
+            ind = prompt(@context.prompt_i, ltype, indent, line_no)[/.*\z/].size +
+	      indent * 2 - p.size
+	    ind += 2 if continue
+	    @context.io.prompt = p + " " * ind if ind > 0
+	  end
+	end
+      end
+       
+      @scanner.set_input(@context.io) do
+	signal_status(:IN_INPUT) do
+	  if l = @context.io.gets
+	    print l if @context.verbose?
+	  else
+	    if @context.ignore_eof? and @context.io.readable_atfer_eof?
+	      l = "\n"
+	      if @context.verbose?
+		printf "Use \"exit\" to leave %s\n", @context.ap_name
+	      end
+	    end
+	  end
+	  l
+	end
+      end
+
+      process_statements
+    end
+
+    def process_statements
+      @scanner.each_top_level_statement do |line, line_no|
+	signal_status(:IN_EVAL) do
+	  begin
+            line.untaint
+	    @context.evaluate(line, line_no)
+	    output_value if @context.echo?
+	    exc = nil
+	  rescue Interrupt => exc
+	  rescue SystemExit, SignalException
+	    raise
+	  rescue Exception => exc
+	  end
+	  if exc
+	    print exc.class, ": ", exc, "\n"
+	    if exc.backtrace[0] =~ /irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/
+	      irb_bug = true 
+	    else
+	      irb_bug = false
+	    end
+	    
+	    messages = []
+	    lasts = []
+	    levels = 0
+	    for m in exc.backtrace
+	      m = @context.workspace.filter_backtrace(m) unless irb_bug
+	      if m
+		if messages.size < @context.back_trace_limit
+		  messages.push "\tfrom "+m
+		else
+		  lasts.push "\tfrom "+m
+		  if lasts.size > @context.back_trace_limit
+		    lasts.shift 
+		    levels += 1
+		  end
+		end
+	      end
+	    end
+	    print messages.join("\n"), "\n"
+	    unless lasts.empty?
+	      printf "... %d levels...\n", levels if levels > 0
+	      print lasts.join("\n")
+	    end
+	    print "Maybe IRB bug!!\n" if irb_bug
+	  end
+          if $SAFE > 2
+            abort "Error: irb does not work for $SAFE level higher than 2"
+          end
+	end
+      end
+    end
+
+    def suspend_name(path = nil, name = nil)
+      @context.irb_path, back_path = path, @context.irb_path if path
+      @context.irb_name, back_name = name, @context.irb_name if name
+      begin
+	yield back_path, back_name
+      ensure
+	@context.irb_path = back_path if path
+	@context.irb_name = back_name if name
+      end
+    end
+
+    def suspend_workspace(workspace)
+      @context.workspace, back_workspace = workspace, @context.workspace
+      begin
+	yield back_workspace
+      ensure
+	@context.workspace = back_workspace
+      end
+    end
+
+    def suspend_input_method(input_method)
+      back_io = @context.io
+      @context.instance_eval{@io = input_method}
+      begin
+	yield back_io
+      ensure
+	@context.instance_eval{@io = back_io}
+      end
+    end
+
+    def suspend_context(context)
+      @context, back_context = context, @context
+      begin
+	yield back_context
+      ensure
+	@context = back_context
+      end
+    end
+
+    def signal_handle
+      unless @context.ignore_sigint?
+	print "\nabort!!\n" if @context.verbose?
+	exit
+      end
+
+      case @signal_status
+      when :IN_INPUT
+	print "^C\n"
+	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
+
+    def signal_status(status)
+      return yield if @signal_status == :IN_LOAD
+
+      signal_status_back = @signal_status
+      @signal_status = status
+      begin
+	yield
+      ensure
+	@signal_status = signal_status_back
+      end
+    end
+
+    def prompt(prompt, ltype, indent, line_no)
+      p = prompt.dup
+      p.gsub!(/%([0-9]+)?([a-zA-Z])/) do
+	case $2
+	when "N"
+	  @context.irb_name
+	when "m"
+	  @context.main.to_s
+	when "M"
+	  @context.main.inspect
+	when "l"
+	  ltype
+	when "i"
+	  if $1 
+	    format("%" + $1 + "d", indent)
+	  else
+	    indent.to_s
+	  end
+	when "n"
+	  if $1 
+	    format("%" + $1 + "d", line_no)
+	  else
+	    line_no.to_s
+	  end
+	when "%"
+	  "%"
+	end
+      end
+      p
+    end
+
+    def output_value
+      if @context.inspect?
+        printf @context.return_format, @context.last_value.inspect
+      else
+        printf @context.return_format, @context.last_value
+      end
+    end
+
+    def inspect
+      ary = []
+      for iv in instance_variables
+	case iv
+	when "@signal_status"
+	  ary.push format("%s=:%s", iv, @signal_status.id2name)
+	when "@context"
+	  ary.push format("%s=%s", iv, eval(iv).__to_s__)
+	else
+	  ary.push format("%s=%s", iv, eval(iv))
+	end
+      end
+      format("#<%s: %s>", self.class, ary.join(", "))
+    end
+  end
+
+  # Singleton method
+  def @CONF.inspect
+    IRB.version unless self[:VERSION]
+
+    array = []
+    for k, v in sort{|a1, a2| a1[0].id2name <=> a2[0].id2name}
+      case k
+      when :MAIN_CONTEXT, :__TMP__EHV__
+	array.push format("CONF[:%s]=...myself...", k.id2name)
+      when :PROMPT
+	s = v.collect{
+	  |kk, vv|
+	  ss = vv.collect{|kkk, vvv| ":#{kkk.id2name}=>#{vvv.inspect}"}
+	  format(":%s=>{%s}", kk.id2name, ss.join(", "))
+	}
+	array.push format("CONF[:%s]={%s}", k.id2name, s.join(", "))
+      else
+	array.push format("CONF[:%s]=%s", k.id2name, v.inspect)
+      end
+    end
+    array.join("\n")
+  end
+end