irb 1.1.0.pre.4

data/lib/irb/completion.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: false
+#
+#   irb/completion.rb -
+#   	$Release Version: 0.9$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#       From Original Idea of shugo@ruby-lang.org
+#
+
+require "readline"
+autoload :RDoc, "rdoc"
+
+module IRB
+  module InputCompletor # :nodoc:
+
+
+    # Set of reserved words used by Ruby, you should not use these for
+    # constants or variables
+    ReservedWords = %w[
+      BEGIN END
+      alias and
+      begin break
+      case class
+      def defined do
+      else elsif end ensure
+      false for
+      if in
+      module
+      next nil not
+      or
+      redo rescue retry return
+      self super
+      then true
+      undef unless until
+      when while
+      yield
+    ]
+
+    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+
+    CompletionProc = proc { |input|
+      retrieve_completion_data(input).compact.map{ |i| i.encode(Encoding.default_external) }
+    }
+
+    def self.retrieve_completion_data(input, doc_namespace = false)
+      bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+
+      case input
+      when /^((["'`]).*\2)\.([^.]*)$/
+        # String
+        receiver = $1
+        message = Regexp.quote($3)
+
+        candidates = String.instance_methods.collect{|m| m.to_s}
+        if doc_namespace
+          "String.#{message}"
+        else
+          select_message(receiver, message, candidates)
+        end
+
+      when /^(\/[^\/]*\/)\.([^.]*)$/
+        # Regexp
+        receiver = $1
+        message = Regexp.quote($2)
+
+        candidates = Regexp.instance_methods.collect{|m| m.to_s}
+        if doc_namespace
+          "Regexp.#{message}"
+        else
+          select_message(receiver, message, candidates)
+        end
+
+      when /^([^\]]*\])\.([^.]*)$/
+        # Array
+        receiver = $1
+        message = Regexp.quote($2)
+
+        candidates = Array.instance_methods.collect{|m| m.to_s}
+        if doc_namespace
+          "Array.#{message}"
+        else
+          select_message(receiver, message, candidates)
+        end
+
+      when /^([^\}]*\})\.([^.]*)$/
+        # Proc or Hash
+        receiver = $1
+        message = Regexp.quote($2)
+
+        proc_candidates = Proc.instance_methods.collect{|m| m.to_s}
+        hash_candidates = Hash.instance_methods.collect{|m| m.to_s}
+        if doc_namespace
+          ["Proc.#{message}", "Hash.#{message}"]
+        else
+          select_message(receiver, message, proc_candidates | hash_candidates)
+        end
+
+      when /^(:[^:.]*)$/
+        # Symbol
+        return nil if doc_namespace
+        if Symbol.respond_to?(:all_symbols)
+          sym = $1
+          candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+          candidates.grep(/^#{Regexp.quote(sym)}/)
+        else
+          []
+        end
+
+      when /^::([A-Z][^:\.\(]*)$/
+        # Absolute Constant or class methods
+        receiver = $1
+        candidates = Object.constants.collect{|m| m.to_s}
+        if doc_namespace
+          candidates.find { |i| i == receiver }
+        else
+          candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
+        end
+
+      when /^([A-Z].*)::([^:.]*)$/
+        # Constant or class methods
+        receiver = $1
+        message = Regexp.quote($2)
+        begin
+          candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
+          candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
+        rescue Exception
+          candidates = []
+        end
+        if doc_namespace
+          "#{receiver}::#{message}"
+        else
+          select_message(receiver, message, candidates, "::")
+        end
+
+      when /^(:[^:.]+)(\.|::)([^.]*)$/
+        # Symbol
+        receiver = $1
+        sep = $2
+        message = Regexp.quote($3)
+
+        candidates = Symbol.instance_methods.collect{|m| m.to_s}
+        if doc_namespace
+          "Symbol.#{message}"
+        else
+          select_message(receiver, message, candidates, sep)
+        end
+
+      when /^(?<num>-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE][+-]?[0-9]+i?|r)?)(?<sep>\.|::)(?<mes>[^.]*)$/
+        # Numeric
+        receiver = $~[:num]
+        sep = $~[:sep]
+        message = Regexp.quote($~[:mes])
+
+        begin
+          instance = eval(receiver, bind)
+          if doc_namespace
+            "#{instance.class.name}.#{message}"
+          else
+            candidates = instance.methods.collect{|m| m.to_s}
+            select_message(receiver, message, candidates, sep)
+          end
+        rescue Exception
+          if doc_namespace
+            nil
+          else
+            candidates = []
+          end
+        end
+
+      when /^(-?0x[0-9a-fA-F_]+)(\.|::)([^.]*)$/
+        # Numeric(0xFFFF)
+        receiver = $1
+        sep = $2
+        message = Regexp.quote($3)
+
+        begin
+          instance = eval(receiver, bind)
+          if doc_namespace
+            "#{instance.class.name}.#{message}"
+          else
+            candidates = instance.methods.collect{|m| m.to_s}
+            select_message(receiver, message, candidates, sep)
+          end
+        rescue Exception
+          if doc_namespace
+            nil
+          else
+            candidates = []
+          end
+        end
+
+      when /^(\$[^.]*)$/
+        # global var
+        gvar = $1
+        all_gvars = global_variables.collect{|m| m.to_s}
+        if doc_namespace
+          all_gvars.find{ |i| i == gvar }
+        else
+          all_gvars.grep(Regexp.new(Regexp.quote(gvar)))
+        end
+
+      when /^([^."].*)(\.|::)([^.]*)$/
+        # variable.func or func.func
+        receiver = $1
+        sep = $2
+        message = Regexp.quote($3)
+
+        gv = eval("global_variables", bind).collect{|m| m.to_s}.append("true", "false", "nil")
+        lv = eval("local_variables", bind).collect{|m| m.to_s}
+        iv = eval("instance_variables", bind).collect{|m| m.to_s}
+        cv = eval("self.class.constants", bind).collect{|m| m.to_s}
+
+        if (gv | lv | iv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
+          # foo.func and foo is var. OR
+          # foo::func and foo is var. OR
+          # foo::Const and foo is var. OR
+          # Foo::Bar.func
+          begin
+            candidates = []
+            rec = eval(receiver, bind)
+            if sep == "::" and rec.kind_of?(Module)
+              candidates = rec.constants.collect{|m| m.to_s}
+            end
+            candidates |= rec.methods.collect{|m| m.to_s}
+          rescue Exception
+            candidates = []
+          end
+        else
+          # func1.func2
+          candidates = []
+          to_ignore = ignored_modules
+          ObjectSpace.each_object(Module){|m|
+            next if (to_ignore.include?(m) rescue true)
+            candidates.concat m.instance_methods(false).collect{|x| x.to_s}
+          }
+          candidates.sort!
+          candidates.uniq!
+        end
+        if doc_namespace
+          "#{rec.class.name}#{sep}#{candidates.find{ |i| i == message }}"
+        else
+          select_message(receiver, message, candidates, sep)
+        end
+
+      when /^\.([^.]*)$/
+        # unknown(maybe String)
+
+        receiver = ""
+        message = Regexp.quote($1)
+
+        candidates = String.instance_methods(true).collect{|m| m.to_s}
+        if doc_namespace
+          "String.#{candidates.find{ |i| i == message }}"
+        else
+          select_message(receiver, message, candidates)
+        end
+
+      else
+        candidates = eval("methods | private_methods | local_variables | instance_variables | self.class.constants", bind).collect{|m| m.to_s}
+        conditions |= ReservedWords
+
+        if doc_namespace
+          candidates.find{ |i| i == input }
+        else
+          candidates.grep(/^#{Regexp.quote(input)}/)
+        end
+      end
+    end
+
+    PerfectMatchedProc = ->(matched) {
+      RDocRIDriver ||= RDoc::RI::Driver.new
+      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        File.open(File.join(__dir__, 'ruby_logo.aa')) do |f|
+          RDocRIDriver.page do |io|
+            IO.copy_stream(f, io)
+          end
+        end
+        return
+      end
+      namespace = retrieve_completion_data(matched, true)
+      return unless matched
+      if namespace.is_a?(Array)
+        out = RDoc::Markup::Document.new
+        namespace.each do |m|
+          begin
+            RDocRIDriver.add_method(out, m)
+          rescue RDoc::RI::Driver::NotFoundError
+          end
+        end
+        RDocRIDriver.display(out)
+      else
+        begin
+          RDocRIDriver.display_names([namespace])
+        rescue RDoc::RI::Driver::NotFoundError
+        end
+      end
+    }
+
+    # Set of available operators in Ruby
+    Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
+
+    def self.select_message(receiver, message, candidates, sep = ".")
+      candidates.grep(/^#{message}/).collect do |e|
+        case e
+        when /^[a-zA-Z_]/
+          receiver + sep + e
+        when /^[0-9]/
+        when *Operators
+          #receiver + " " + e
+        end
+      end
+    end
+
+    def self.ignored_modules
+      # We could cache the result, but this is very fast already.
+      # By using this approach, we avoid Module#name calls, which are
+      # relatively slow when there are a lot of anonymous modules defined.
+      s = {}
+
+      scanner = lambda do |m|
+        next if s.include?(m) # IRB::ExtendCommandBundle::EXCB recurses.
+        s[m] = true
+        m.constants(false).each do |c|
+          value = m.const_get(c)
+          scanner.call(value) if value.is_a?(Module)
+        end
+      end
+
+      %i(IRB SLex RubyLex RubyToken).each do |sym|
+        next unless Object.const_defined?(sym)
+        scanner.call(Object.const_get(sym))
+      end
+
+      s.delete(IRB::Context) if defined?(IRB::Context)
+
+      s
+    end
+  end
+end

data/lib/irb/context.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: false
+#
+#   irb/context.rb - irb context
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+require_relative "workspace"
+require_relative "inspector"
+require_relative "input-method"
+require_relative "output-method"
+
+module IRB
+  # A class that wraps the current state of the irb session, including the
+  # configuration of IRB.conf.
+  class Context
+    # Creates a new IRB context.
+    #
+    # The optional +input_method+ argument:
+    #
+    # +nil+::     uses stdin or Reidline or Readline
+    # +String+::  uses a File
+    # +other+::   uses this as InputMethod
+    def initialize(irb, workspace = nil, input_method = nil)
+      @irb = irb
+      if workspace
+        @workspace = workspace
+      else
+        @workspace = WorkSpace.new
+      end
+      @thread = Thread.current if defined? Thread
+
+      # copy of default configuration
+      @ap_name = IRB.conf[:AP_NAME]
+      @rc = IRB.conf[:RC]
+      @load_modules = IRB.conf[:LOAD_MODULES]
+
+      if IRB.conf.has_key?(:USE_SINGLELINE)
+        @use_singleline = IRB.conf[:USE_SINGLELINE]
+      elsif IRB.conf.has_key?(:USE_READLINE) # backward compatibility
+        @use_singleline = IRB.conf[:USE_READLINE]
+      else
+        @use_singleline = nil
+      end
+      if IRB.conf.has_key?(:USE_MULTILINE)
+        @use_multiline = IRB.conf[:USE_MULTILINE]
+      elsif IRB.conf.has_key?(:USE_REIDLINE) # backward compatibility
+        @use_multiline = IRB.conf[:USE_REIDLINE]
+      else
+        @use_multiline = nil
+      end
+      @use_colorize = IRB.conf[:USE_COLORIZE]
+      @verbose = IRB.conf[:VERBOSE]
+      @io = nil
+
+      self.inspect_mode = IRB.conf[:INSPECT_MODE]
+      self.use_tracer = IRB.conf[:USE_TRACER] if IRB.conf[:USE_TRACER]
+      self.use_loader = IRB.conf[:USE_LOADER] if IRB.conf[:USE_LOADER]
+      self.eval_history = IRB.conf[:EVAL_HISTORY] if IRB.conf[:EVAL_HISTORY]
+
+      @ignore_sigint = IRB.conf[:IGNORE_SIGINT]
+      @ignore_eof = IRB.conf[:IGNORE_EOF]
+
+      @back_trace_limit = IRB.conf[:BACK_TRACE_LIMIT]
+
+      self.prompt_mode = IRB.conf[:PROMPT_MODE]
+
+      if IRB.conf[:SINGLE_IRB] or !defined?(IRB::JobManager)
+        @irb_name = IRB.conf[:IRB_NAME]
+      else
+        @irb_name = IRB.conf[:IRB_NAME]+"#"+IRB.JobManager.n_jobs.to_s
+      end
+      @irb_path = "(" + @irb_name + ")"
+
+      case input_method
+      when nil
+        @io = nil
+        case use_multiline?
+        when nil
+          if STDIN.tty? && IRB.conf[:PROMPT_MODE] != :INF_RUBY && !use_singleline?
+            @io = ReidlineInputMethod.new
+          else
+            @io = nil
+          end
+        when false
+          @io = nil
+        when true
+          @io = ReidlineInputMethod.new
+        end
+        unless @io
+          case use_singleline?
+          when nil
+            if (defined?(ReadlineInputMethod) && STDIN.tty? &&
+                IRB.conf[:PROMPT_MODE] != :INF_RUBY)
+              @io = ReadlineInputMethod.new
+            else
+              @io = nil
+            end
+          when false
+            @io = nil
+          when true
+            if defined?(ReadlineInputMethod)
+              @io = ReadlineInputMethod.new
+            else
+              @io = nil
+            end
+          else
+            @io = nil
+          end
+        end
+        @io = StdioInputMethod.new unless @io
+
+      when String
+        @io = FileInputMethod.new(input_method)
+        @irb_name = File.basename(input_method)
+        @irb_path = input_method
+      else
+        @io = input_method
+      end
+      self.save_history = IRB.conf[:SAVE_HISTORY] if IRB.conf[:SAVE_HISTORY]
+
+      @echo = IRB.conf[:ECHO]
+      if @echo.nil?
+        @echo = true
+      end
+
+      @echo_on_assignment = IRB.conf[:ECHO_ON_ASSIGNMENT]
+      if @echo_on_assignment.nil?
+        @echo_on_assignment = false
+      end
+    end
+
+    # The top-level workspace, see WorkSpace#main
+    def main
+      @workspace.main
+    end
+
+    # The toplevel workspace, see #home_workspace
+    attr_reader :workspace_home
+    # WorkSpace in the current context
+    attr_accessor :workspace
+    # The current thread in this context
+    attr_reader :thread
+    # The current input method
+    #
+    # Can be either StdioInputMethod, ReadlineInputMethod,
+    # ReidlineInputMethod, FileInputMethod or other specified when the
+    # context is created. See ::new for more # information on +input_method+.
+    attr_accessor :io
+
+    # Current irb session
+    attr_accessor :irb
+    # A copy of the default <code>IRB.conf[:AP_NAME]</code>
+    attr_accessor :ap_name
+    # A copy of the default <code>IRB.conf[:RC]</code>
+    attr_accessor :rc
+    # A copy of the default <code>IRB.conf[:LOAD_MODULES]</code>
+    attr_accessor :load_modules
+    # Can be either name from <code>IRB.conf[:IRB_NAME]</code>, or the number of
+    # the current job set by JobManager, such as <code>irb#2</code>
+    attr_accessor :irb_name
+    # Can be either the #irb_name surrounded by parenthesis, or the
+    # +input_method+ passed to Context.new
+    attr_accessor :irb_path
+
+    # Whether multiline editor mode is enabled or not.
+    #
+    # A copy of the default <code>IRB.conf[:USE_MULTILINE]</code>
+    attr_reader :use_multiline
+    # Whether singleline editor mode is enabled or not.
+    #
+    # A copy of the default <code>IRB.conf[:USE_SINGLELINE]</code>
+    attr_reader :use_singleline
+    # Whether colorization is enabled or not.
+    #
+    # A copy of the default <code>IRB.conf[:USE_COLORIZE]</code>
+    attr_reader :use_colorize
+    # A copy of the default <code>IRB.conf[:INSPECT_MODE]</code>
+    attr_reader :inspect_mode
+
+    # A copy of the default <code>IRB.conf[:PROMPT_MODE]</code>
+    attr_reader :prompt_mode
+    # Standard IRB prompt
+    #
+    # See IRB@Customizing+the+IRB+Prompt for more information.
+    attr_accessor :prompt_i
+    # IRB prompt for continuated strings
+    #
+    # See IRB@Customizing+the+IRB+Prompt for more information.
+    attr_accessor :prompt_s
+    # IRB prompt for continuated statement (e.g. immediately after an +if+)
+    #
+    # See IRB@Customizing+the+IRB+Prompt for more information.
+    attr_accessor :prompt_c
+    # See IRB@Customizing+the+IRB+Prompt for more information.
+    attr_accessor :prompt_n
+    # Can be either the default <code>IRB.conf[:AUTO_INDENT]</code>, or the
+    # mode set by #prompt_mode=
+    #
+    # To disable auto-indentation in irb:
+    #
+    #     IRB.conf[:AUTO_INDENT] = false
+    #
+    # or
+    #
+    #     irb_context.auto_indent_mode = false
+    #
+    # or
+    #
+    #     IRB.CurrentContext.auto_indent_mode = false
+    #
+    # See IRB@Configuration for more information.
+    attr_accessor :auto_indent_mode
+    # The format of the return statement, set by #prompt_mode= using the
+    # +:RETURN+ of the +mode+ passed to set the current #prompt_mode.
+    attr_accessor :return_format
+
+    # Whether <code>^C</code> (+control-c+) will be ignored or not.
+    #
+    # If set to +false+, <code>^C</code> will quit irb.
+    #
+    # If set to +true+,
+    #
+    # * during input:   cancel input then return to top level.
+    # * during execute: abandon current execution.
+    attr_accessor :ignore_sigint
+    # Whether <code>^D</code> (+control-d+) will be ignored or not.
+    #
+    # If set to +false+, <code>^D</code> will quit irb.
+    attr_accessor :ignore_eof
+    # Whether to echo the return value to output or not.
+    #
+    # Uses IRB.conf[:ECHO] if available, or defaults to +true+.
+    #
+    #     puts "hello"
+    #     # hello
+    #     #=> nil
+    #     IRB.CurrentContext.echo = false
+    #     puts "omg"
+    #     # omg
+    attr_accessor :echo
+    # Whether to echo for assignment expressions
+    #
+    # Uses IRB.conf[:ECHO_ON_ASSIGNMENT] if available, or defaults to +false+.
+    #
+    #     a = "omg"
+    #     IRB.CurrentContext.echo_on_assignment = true
+    #     a = "omg"
+    #     #=> omg
+    attr_accessor :echo_on_assignment
+    # Whether verbose messages are displayed or not.
+    #
+    # A copy of the default <code>IRB.conf[:VERBOSE]</code>
+    attr_accessor :verbose
+
+    # The limit of backtrace lines displayed as top +n+ and tail +n+.
+    #
+    # The default value is 16.
+    #
+    # Can also be set using the +--back-trace-limit+ command line option.
+    #
+    # See IRB@Command+line+options for more command line options.
+    attr_accessor :back_trace_limit
+
+    # Alias for #use_multiline
+    alias use_multiline? use_multiline
+    # Alias for #use_singleline
+    alias use_singleline? use_singleline
+    # backward compatibility
+    alias use_reidline use_multiline
+    # backward compatibility
+    alias use_reidline? use_multiline
+    # backward compatibility
+    alias use_readline use_singleline
+    # backward compatibility
+    alias use_readline? use_singleline
+    # Alias for #use_colorize
+    alias use_colorize? use_colorize
+    # Alias for #rc
+    alias rc? rc
+    alias ignore_sigint? ignore_sigint
+    alias ignore_eof? ignore_eof
+    alias echo? echo
+    alias echo_on_assignment? echo_on_assignment
+
+    # Returns whether messages are displayed or not.
+    def verbose?
+      if @verbose.nil?
+        if @io.kind_of?(ReidlineInputMethod)
+          false
+        elsif defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)
+          false
+        elsif !STDIN.tty? or @io.kind_of?(FileInputMethod)
+          true
+        else
+          false
+        end
+      else
+        @verbose
+      end
+    end
+
+    # Whether #verbose? is +true+, and +input_method+ is either
+    # StdioInputMethod or ReidlineInputMethod or ReadlineInputMethod, see #io
+    # for more information.
+    def prompting?
+      verbose? || (STDIN.tty? && @io.kind_of?(StdioInputMethod) ||
+                   @io.kind_of?(ReidlineInputMethod) ||
+                   (defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)))
+    end
+
+    # The return value of the last statement evaluated.
+    attr_reader :last_value
+
+    # Sets the return value from the last statement evaluated in this context
+    # to #last_value.
+    def set_last_value(value)
+      @last_value = value
+      @workspace.local_variable_set :_, value
+    end
+
+    # Sets the +mode+ of the prompt in this context.
+    #
+    # See IRB@Customizing+the+IRB+Prompt for more information.
+    def prompt_mode=(mode)
+      @prompt_mode = mode
+      pconf = IRB.conf[:PROMPT][mode]
+      @prompt_i = pconf[:PROMPT_I]
+      @prompt_s = pconf[:PROMPT_S]
+      @prompt_c = pconf[:PROMPT_C]
+      @prompt_n = pconf[:PROMPT_N]
+      @return_format = pconf[:RETURN]
+      if ai = pconf.include?(:AUTO_INDENT)
+        @auto_indent_mode = ai
+      else
+        @auto_indent_mode = IRB.conf[:AUTO_INDENT]
+      end
+    end
+
+    # Whether #inspect_mode is set or not, see #inspect_mode= for more detail.
+    def inspect?
+      @inspect_mode.nil? or @inspect_mode
+    end
+
+    # Whether #io uses a File for the +input_method+ passed when creating the
+    # current context, see ::new
+    def file_input?
+      @io.class == FileInputMethod
+    end
+
+    # Specifies the inspect mode with +opt+:
+    #
+    # +true+::  display +inspect+
+    # +false+:: display +to_s+
+    # +nil+::   inspect mode in non-math mode,
+    #           non-inspect mode in math mode
+    #
+    # See IRB::Inspector for more information.
+    #
+    # Can also be set using the +--inspect+ and +--noinspect+ command line
+    # options.
+    #
+    # See IRB@Command+line+options for more command line options.
+    def inspect_mode=(opt)
+
+      if i = Inspector::INSPECTORS[opt]
+        @inspect_mode = opt
+        @inspect_method = i
+        i.init
+      else
+        case opt
+        when nil
+          if Inspector.keys_with_inspector(Inspector::INSPECTORS[true]).include?(@inspect_mode)
+            self.inspect_mode = false
+          elsif Inspector.keys_with_inspector(Inspector::INSPECTORS[false]).include?(@inspect_mode)
+            self.inspect_mode = true
+          else
+            puts "Can't switch inspect mode."
+            return
+          end
+        when /^\s*\{.*\}\s*$/
+          begin
+            inspector = eval "proc#{opt}"
+          rescue Exception
+            puts "Can't switch inspect mode(#{opt})."
+            return
+          end
+          self.inspect_mode = inspector
+        when Proc
+          self.inspect_mode = IRB::Inspector(opt)
+        when Inspector
+          prefix = "usr%d"
+          i = 1
+          while Inspector::INSPECTORS[format(prefix, i)]; i += 1; end
+          @inspect_mode = format(prefix, i)
+          @inspect_method = opt
+          Inspector.def_inspector(format(prefix, i), @inspect_method)
+        else
+          puts "Can't switch inspect mode(#{opt})."
+          return
+        end
+      end
+      print "Switch to#{unless @inspect_mode; ' non';end} inspect mode.\n" if verbose?
+      @inspect_mode
+    end
+
+    def evaluate(line, line_no, exception: nil) # :nodoc:
+      @line_no = line_no
+      if exception
+        line_no -= 1
+        line = "begin ::Kernel.raise _; rescue _.class\n#{line}\n""end"
+        @workspace.local_variable_set(:_, exception)
+      end
+      set_last_value(@workspace.evaluate(self, line, irb_path, line_no))
+    end
+
+    def inspect_last_value # :nodoc:
+      @inspect_method.inspect_value(@last_value)
+    end
+
+    alias __exit__ exit
+    # Exits the current session, see IRB.irb_exit
+    def exit(ret = 0)
+      IRB.irb_exit(@irb, ret)
+    end
+
+    NOPRINTING_IVARS = ["@last_value"] # :nodoc:
+    NO_INSPECTING_IVARS = ["@irb", "@io"] # :nodoc:
+    IDNAME_IVARS = ["@prompt_mode"] # :nodoc:
+
+    alias __inspect__ inspect
+    def inspect # :nodoc:
+      array = []
+      for ivar in instance_variables.sort{|e1, e2| e1 <=> e2}
+        ivar = ivar.to_s
+        name = ivar.sub(/^@(.*)$/, '\1')
+        val = instance_eval(ivar)
+        case ivar
+        when *NOPRINTING_IVARS
+          array.push format("conf.%s=%s", name, "...")
+        when *NO_INSPECTING_IVARS
+          array.push format("conf.%s=%s", name, val.to_s)
+        when *IDNAME_IVARS
+          array.push format("conf.%s=:%s", name, val.id2name)
+        else
+          array.push format("conf.%s=%s", name, val.inspect)
+        end
+      end
+      array.join("\n")
+    end
+    alias __to_s__ to_s
+    alias to_s inspect
+  end
+end