IRB

 
               # File irb.rb, line 45
def IRB.CurrentContext
  IRB.conf[:MAIN_CONTEXT]
end
            

 
               # File irb/inspector.rb, line 15
def IRB::Inspector(inspect, init = nil)
  Inspector.new(inspect, init)
end
            

 
               # File irb/ext/multi-irb.rb, line 138
def IRB.JobManager
  @JobManager
end
            

 
               # File irb.rb, line 32
def IRB.conf
  @CONF
end
            

 
               # File irb/workspace.rb, line 105
def IRB.delete_caller
end
            

 
               # File irb/init.rb, line 28
  def IRB.init_config(ap_path)
    # class instance variables
    @TRACER_INITIALIZED = false

    # default configurations
    unless ap_path and @CONF[:AP_NAME]
      ap_path = File.join(File.dirname(File.dirname(__FILE__)), "irb.rb")
    end
    @CONF[:AP_NAME] = File::basename(ap_path, ".rb")

    @CONF[:IRB_NAME] = "irb"
    @CONF[:IRB_LIB_PATH] = File.dirname(__FILE__)

    @CONF[:RC] = true
    @CONF[:LOAD_MODULES] = []
    @CONF[:IRB_RC] = nil

    @CONF[:MATH_MODE] = false
    @CONF[:USE_READLINE] = false unless defined?(ReadlineInputMethod)
    @CONF[:INSPECT_MODE] = true
    @CONF[:USE_TRACER] = false
    @CONF[:USE_LOADER] = false
    @CONF[:IGNORE_SIGINT] = true
    @CONF[:IGNORE_EOF] = false
    @CONF[:ECHO] = nil
    @CONF[:VERBOSE] = nil

    @CONF[:EVAL_HISTORY] = nil
    @CONF[:SAVE_HISTORY] = nil

    @CONF[:BACK_TRACE_LIMIT] = 16

    @CONF[:PROMPT] = {
      :NULL => {
        :PROMPT_I => nil,
        :PROMPT_N => nil,
        :PROMPT_S => nil,
        :PROMPT_C => nil,
        :RETURN => "%s\n"
      },
      :DEFAULT => {
        :PROMPT_I => "%N(%m):%03n:%i> ",
        :PROMPT_N => "%N(%m):%03n:%i> ",
        :PROMPT_S => "%N(%m):%03n:%i%l ",
        :PROMPT_C => "%N(%m):%03n:%i* ",
        :RETURN => "=> %s\n"
      },
      :CLASSIC => {
        :PROMPT_I => "%N(%m):%03n:%i> ",
        :PROMPT_N => "%N(%m):%03n:%i> ",
        :PROMPT_S => "%N(%m):%03n:%i%l ",
        :PROMPT_C => "%N(%m):%03n:%i* ",
        :RETURN => "%s\n"
      },
      :SIMPLE => {
        :PROMPT_I => ">> ",
        :PROMPT_N => ">> ",
        :PROMPT_S => nil,
        :PROMPT_C => "?> ",
        :RETURN => "=> %s\n"
      },
      :INF_RUBY => {
        :PROMPT_I => "%N(%m):%03n:%i> ",
#       :PROMPT_N => "%N(%m):%03n:%i> ",
        :PROMPT_N => nil,
        :PROMPT_S => nil,
        :PROMPT_C => nil,
        :RETURN => "%s\n",
        :AUTO_INDENT => true
      },
      :XMP => {
        :PROMPT_I => nil,
        :PROMPT_N => nil,
        :PROMPT_S => nil,
        :PROMPT_C => nil,
        :RETURN => "    ==>%s\n"
      }
    }

    @CONF[:PROMPT_MODE] = (STDIN.tty? ? :DEFAULT : :NULL)
    @CONF[:AUTO_INDENT] = false

    @CONF[:CONTEXT_MODE] = 3 # use binding in function on TOPLEVEL_BINDING
    @CONF[:SINGLE_IRB] = false

#    @CONF[:LC_MESSAGES] = "en"
    @CONF[:LC_MESSAGES] = Locale.new

    @CONF[:AT_EXIT] = []

    @CONF[:DEBUG_LEVEL] = 1
  end
            

 
               # File irb/init.rb, line 121
def IRB.init_error
  @CONF[:LC_MESSAGES].load("irb/error.rb")
end
            

 
               # File irb/ext/tracer.rb, line 16
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
            

 
               # File irb/ext/multi-irb.rb, line 147
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 @JobManager.current_job == 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
  end
  Thread.stop
  @JobManager.current_job = @JobManager.irb(Thread.current)
end
            

 
               # File irb.rb, line 86
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
            

 
               # File irb.rb, line 78
def IRB.irb_at_exit
  @CONF[:AT_EXIT].each{|hook| hook.call}
end
            

 
               # File irb.rb, line 82
def IRB.irb_exit(irb, ret)
  throw :IRB_EXIT, ret
end
            

 
               # File irb/init.rb, line 278
def IRB.load_modules
  for m in @CONF[:LOAD_MODULES]
    begin
      require m
    rescue LoadError => err
      warn err.backtrace[0] << ":#{err.class}: #{err}"
    end
  end
end
            

 
               # File irb/init.rb, line 128
def IRB.parse_opts
  load_path = []
  while opt = ARGV.shift
    case opt
    when "-f"
      @CONF[:RC] = false
    when "-m"
      @CONF[:MATH_MODE] = true
    when "-d"
      $DEBUG = true
      $VERBOSE = true
    when "-w"
      $VERBOSE = true
    when /^-W(.+)?/
      opt = $1 || ARGV.shift
      case opt
      when "0"
        $VERBOSE = nil
      when "1"
        $VERBOSE = false
      else
        $VERBOSE = true
      end
    when /^-r(.+)?/
      opt = $1 || ARGV.shift
      @CONF[:LOAD_MODULES].push opt if opt
    when /^-I(.+)?/
      opt = $1 || ARGV.shift
      load_path.concat(opt.split(File::PATH_SEPARATOR)) if opt
    when '-U'
      set_encoding("UTF-8", "UTF-8")
    when /^-E(.+)?/, /^--encoding(?:=(.+))?/
      opt = $1 || ARGV.shift
      set_encoding(*opt.split(':', 2))
    when "--inspect"
      if /^-/ !~ ARGV.first
        @CONF[:INSPECT_MODE] = ARGV.shift
      else
        @CONF[:INSPECT_MODE] = true
      end
    when "--noinspect"
      @CONF[:INSPECT_MODE] = false
    when "--readline"
      @CONF[:USE_READLINE] = true
    when "--noreadline"
      @CONF[:USE_READLINE] = false
    when "--echo"
      @CONF[:ECHO] = true
    when "--noecho"
      @CONF[:ECHO] = false
    when "--verbose"
      @CONF[:VERBOSE] = true
    when "--noverbose"
      @CONF[:VERBOSE] = false
    when /^--prompt-mode(?:=(.+))?/, /^--prompt(?:=(.+))?/
      opt = $1 || ARGV.shift
      prompt_mode = opt.upcase.tr("-", "_").intern
      @CONF[:PROMPT_MODE] = prompt_mode
    when "--noprompt"
      @CONF[:PROMPT_MODE] = :NULL
    when "--inf-ruby-mode"
      @CONF[:PROMPT_MODE] = :INF_RUBY
    when "--sample-book-mode", "--simple-prompt"
      @CONF[:PROMPT_MODE] = :SIMPLE
    when "--tracer"
      @CONF[:USE_TRACER] = true
    when /^--back-trace-limit(?:=(.+))?/
      @CONF[:BACK_TRACE_LIMIT] = ($1 || ARGV.shift).to_i
    when /^--context-mode(?:=(.+))?/
      @CONF[:CONTEXT_MODE] = ($1 || ARGV.shift).to_i
    when "--single-irb"
      @CONF[:SINGLE_IRB] = true
    when /^--irb_debug=(?:=(.+))?/
      @CONF[:DEBUG_LEVEL] = ($1 || ARGV.shift).to_i
    when "-v", "--version"
      print IRB.version, "\n"
      exit 0
    when "-h", "--help"
      require "irb/help"
      IRB.print_usage
      exit 0
    when "--"
      if opt = ARGV.shift
        @CONF[:SCRIPT] = opt
        $0 = opt
      end
      break
    when /^-/
      IRB.fail UnrecognizedSwitch, opt
    else
      @CONF[:SCRIPT] = opt
      $0 = opt
      break
    end
  end
  if RUBY_VERSION >= FEATURE_IOPT_CHANGE_VERSION
    load_path.collect! do |path|
      /\A\.\// =~ path ? path : File.expand_path(path)
    end
  end
  $LOAD_PATH.unshift(*load_path)

end
            

 
               # File irb/help.rb, line 15
def IRB.print_usage
  lc = IRB.conf[:LC_MESSAGES]
  path = lc.find("irb/help-message")
  space_line = false
  IRB::MagicFile.open(path){|f|
    f.each_line do |l|
      if /^\s*$/ =~ l
        lc.puts l unless space_line
        space_line = true
        next
      end
      space_line = false

      l.sub!(/#.*$/, "")
        next if /^\s*$/ =~ l
      lc.puts l
    end
  }
end
            

 
               # File irb/init.rb, line 249
def IRB.rc_file(ext = IRBRC_EXT)
  if !@CONF[:RC_NAME_GENERATOR]
    rc_file_generators do |rcgen|
      @CONF[:RC_NAME_GENERATOR] ||= rcgen
      if File.exist?(rcgen.call(IRBRC_EXT))
        @CONF[:RC_NAME_GENERATOR] = rcgen
        break
      end
    end
  end
  @CONF[:RC_NAME_GENERATOR].call ext
end
            

 
               # File irb/init.rb, line 263
def IRB.rc_file_generators
  if irbrc = ENV["IRBRC"]
    yield proc{|rc| rc == "rc" ? irbrc : irbrc+rc}
  end
  if home = ENV["HOME"]
    yield proc{|rc| home+"/.irb#{rc}"}
  end
  home = Dir.pwd
  yield proc{|rc| home+"/.irb#{rc}"}
  yield proc{|rc| home+"/irb#{rc.sub(/\A_?/, '.')}"}
  yield proc{|rc| home+"/_irb#{rc}"}
  yield proc{|rc| home+"/$irb#{rc}"}
end
            

 
               # File irb/init.rb, line 233
def IRB.run_config
  if @CONF[:RC]
    begin
      load rc_file
    rescue LoadError, Errno::ENOENT
    rescue # StandardError, ScriptError
      print "load error: #{rc_file}\n"
      print $!.class, ": ", $!, "\n"
      for err in $@[0, $@.size - 2]
        print "\t", err, "\n"
      end
    end
  end
end
            

 
               # File irb/init.rb, line 15
def IRB.setup(ap_path)
  IRB.init_config(ap_path)
  IRB.init_error
  IRB.parse_opts
  IRB.run_config
  IRB.load_modules

  unless @CONF[:PROMPT][@CONF[:PROMPT_MODE]]
    IRB.fail(UndefinedPromptMode, @CONF[:PROMPT_MODE])
  end
end
            

 
               # File irb.rb, line 50
  def IRB.start(ap_path = nil)
    $0 = File::basename(ap_path, ".rb") if ap_path

    IRB.setup(ap_path)

    if @CONF[:SCRIPT]
      irb = Irb.new(nil, @CONF[:SCRIPT])
    else
      irb = Irb.new
    end

    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
    @CONF[:MAIN_CONTEXT] = irb.context

    trap("SIGINT") do
      irb.signal_handle
    end

    begin
      catch(:IRB_EXIT) do
        irb.eval_input
      end
    ensure
      irb_at_exit
    end
#    print "\n"
  end
            

 
               # File irb.rb, line 37
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