irb 0.9.6 → 1.4.1

data/lib/irb/init.rb

@@ -21,7 +21,7 @@ module IRB # :nodoc:
     IRB.load_modules
 
     unless @CONF[:PROMPT][@CONF[:PROMPT_MODE]]
-      IRB.fail(UndefinedPromptMode, @CONF[:PROMPT_MODE])
+      fail UndefinedPromptMode, @CONF[:PROMPT_MODE]
     end
   end
 
@@ -43,17 +43,21 @@ module IRB # :nodoc:
     @CONF[:LOAD_MODULES] = []
     @CONF[:IRB_RC] = nil
 
-    @CONF[:USE_READLINE] = false unless defined?(ReadlineInputMethod)
+    @CONF[:USE_SINGLELINE] = false unless defined?(ReadlineInputMethod)
+    @CONF[:USE_COLORIZE] = !ENV['NO_COLOR']
+    @CONF[:USE_AUTOCOMPLETE] = true
     @CONF[:INSPECT_MODE] = true
     @CONF[:USE_TRACER] = false
     @CONF[:USE_LOADER] = false
     @CONF[:IGNORE_SIGINT] = true
     @CONF[:IGNORE_EOF] = false
+    @CONF[:EXTRA_DOC_DIRS] = []
     @CONF[:ECHO] = nil
+    @CONF[:ECHO_ON_ASSIGNMENT] = nil
     @CONF[:VERBOSE] = nil
 
     @CONF[:EVAL_HISTORY] = nil
-    @CONF[:SAVE_HISTORY] = nil
+    @CONF[:SAVE_HISTORY] = 1000
 
     @CONF[:BACK_TRACE_LIMIT] = 16
 
@@ -82,7 +86,7 @@ module IRB # :nodoc:
       :SIMPLE => {
         :PROMPT_I => ">> ",
         :PROMPT_N => ">> ",
-        :PROMPT_S => nil,
+        :PROMPT_S => "%l> ",
         :PROMPT_C => "?> ",
         :RETURN => "=> %s\n"
       },
@@ -104,16 +108,101 @@ module IRB # :nodoc:
     }
 
     @CONF[:PROMPT_MODE] = (STDIN.tty? ? :DEFAULT : :NULL)
-    @CONF[:AUTO_INDENT] = false
+    @CONF[:AUTO_INDENT] = true
 
-    @CONF[:CONTEXT_MODE] = 3 # use binding in function on TOPLEVEL_BINDING
+    @CONF[:CONTEXT_MODE] = 4 # use a copy of TOPLEVEL_BINDING
     @CONF[:SINGLE_IRB] = false
 
+    @CONF[:MEASURE] = false
+    @CONF[:MEASURE_PROC] = {}
+    @CONF[:MEASURE_PROC][:TIME] = proc { |context, code, line_no, &block|
+      time = Time.now
+      result = block.()
+      now = Time.now
+      puts 'processing time: %fs' % (now - time) if IRB.conf[:MEASURE]
+      result
+    }
+    # arg can be either a symbol for the mode (:cpu, :wall, ..) or a hash for
+    # a more complete configuration.
+    # See https://github.com/tmm1/stackprof#all-options.
+    @CONF[:MEASURE_PROC][:STACKPROF] = proc { |context, code, line_no, arg, &block|
+      return block.() unless IRB.conf[:MEASURE]
+      success = false
+      begin
+        require 'stackprof'
+        success = true
+      rescue LoadError
+        puts 'Please run "gem install stackprof" before measuring by StackProf.'
+      end
+      if success
+        result = nil
+        arg = { mode: arg || :cpu } unless arg.is_a?(Hash)
+        stackprof_result = StackProf.run(**arg) do
+          result = block.()
+        end
+        case stackprof_result
+        when File
+          puts "StackProf report saved to #{stackprof_result.path}"
+        when Hash
+          StackProf::Report.new(stackprof_result).print_text
+        else
+          puts "Stackprof ran with #{arg.inspect}"
+        end
+        result
+      else
+        block.()
+      end
+    }
+    @CONF[:MEASURE_CALLBACKS] = []
+
     @CONF[:LC_MESSAGES] = Locale.new
 
     @CONF[:AT_EXIT] = []
+  end
 
-    @CONF[:DEBUG_LEVEL] = 0
+  def IRB.set_measure_callback(type = nil, arg = nil, &block)
+    added = nil
+    if type
+      type_sym = type.upcase.to_sym
+      if IRB.conf[:MEASURE_PROC][type_sym]
+        added = [type_sym, IRB.conf[:MEASURE_PROC][type_sym], arg]
+      end
+    elsif IRB.conf[:MEASURE_PROC][:CUSTOM]
+      added = [:CUSTOM, IRB.conf[:MEASURE_PROC][:CUSTOM], arg]
+    elsif block_given?
+      added = [:BLOCK, block, arg]
+      found = IRB.conf[:MEASURE_CALLBACKS].find{ |m| m[0] == added[0] && m[2] == added[2] }
+      if found
+        found[1] = block
+        return added
+      else
+        IRB.conf[:MEASURE_CALLBACKS] << added
+        return added
+      end
+    else
+      added = [:TIME, IRB.conf[:MEASURE_PROC][:TIME], arg]
+    end
+    if added
+      found = IRB.conf[:MEASURE_CALLBACKS].find{ |m| m[0] == added[0] && m[2] == added[2] }
+      if found
+        # already added
+        nil
+      else
+        IRB.conf[:MEASURE_CALLBACKS] << added if added
+        added
+      end
+    else
+      nil
+    end
+  end
+
+  def IRB.unset_measure_callback(type = nil)
+    if type.nil?
+      IRB.conf[:MEASURE_CALLBACKS].clear
+    else
+      type_sym = type.upcase.to_sym
+      IRB.conf[:MEASURE_CALLBACKS].reject!{ |t, | t == type_sym }
+    end
   end
 
   def IRB.init_error
@@ -131,7 +220,7 @@ module IRB # :nodoc:
         $DEBUG = true
         $VERBOSE = true
       when "-w"
-        $VERBOSE = true
+        Warning[:deprecated] = $VERBOSE = true
       when /^-W(.+)?/
         opt = $1 || argv.shift
         case opt
@@ -140,7 +229,7 @@ module IRB # :nodoc:
         when "1"
           $VERBOSE = false
         else
-          $VERBOSE = true
+          Warning[:deprecated] = $VERBOSE = true
         end
       when /^-r(.+)?/
         opt = $1 || argv.shift
@@ -161,18 +250,39 @@ module IRB # :nodoc:
         end
       when "--noinspect"
         @CONF[:INSPECT_MODE] = false
-      when "--readline"
-        @CONF[:USE_READLINE] = true
-      when "--noreadline"
-        @CONF[:USE_READLINE] = false
+      when "--singleline", "--readline", "--legacy"
+        @CONF[:USE_SINGLELINE] = true
+      when "--nosingleline", "--noreadline"
+        @CONF[:USE_SINGLELINE] = false
+      when "--multiline", "--reidline"
+        @CONF[:USE_MULTILINE] = true
+      when "--nomultiline", "--noreidline"
+        @CONF[:USE_MULTILINE] = false
+      when /^--extra-doc-dir(?:=(.+))?/
+        opt = $1 || argv.shift
+        @CONF[:EXTRA_DOC_DIRS] << opt
       when "--echo"
         @CONF[:ECHO] = true
       when "--noecho"
         @CONF[:ECHO] = false
+      when "--echo-on-assignment"
+        @CONF[:ECHO_ON_ASSIGNMENT] = true
+      when "--noecho-on-assignment"
+        @CONF[:ECHO_ON_ASSIGNMENT] = false
+      when "--truncate-echo-on-assignment"
+        @CONF[:ECHO_ON_ASSIGNMENT] = :truncate
       when "--verbose"
         @CONF[:VERBOSE] = true
       when "--noverbose"
         @CONF[:VERBOSE] = false
+      when "--colorize"
+        @CONF[:USE_COLORIZE] = true
+      when "--nocolorize"
+        @CONF[:USE_COLORIZE] = false
+      when "--autocomplete"
+        @CONF[:USE_AUTOCOMPLETE] = true
+      when "--noautocomplete"
+        @CONF[:USE_AUTOCOMPLETE] = false
       when /^--prompt-mode(?:=(.+))?/, /^--prompt(?:=(.+))?/
         opt = $1 || argv.shift
         prompt_mode = opt.upcase.tr("-", "_").intern
@@ -191,8 +301,6 @@ module IRB # :nodoc:
         @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
@@ -207,18 +315,18 @@ module IRB # :nodoc:
         end
         break
       when /^-/
-        IRB.fail UnrecognizedSwitch, opt
+        fail UnrecognizedSwitch, opt
       else
         @CONF[:SCRIPT] = opt
         $0 = opt
         break
       end
     end
+
     load_path.collect! do |path|
       /\A\.\// =~ path ? path : File.expand_path(path)
     end
     $LOAD_PATH.unshift(*load_path)
-
   end
 
   # running config
@@ -252,7 +360,7 @@ module IRB # :nodoc:
     when String
       return rc_file
     else
-      IRB.fail IllegalRCNameGenerator
+      fail IllegalRCNameGenerator
     end
   end
 
@@ -261,14 +369,23 @@ module IRB # :nodoc:
     if irbrc = ENV["IRBRC"]
       yield proc{|rc| rc == "rc" ? irbrc : irbrc+rc}
     end
+    if xdg_config_home = ENV["XDG_CONFIG_HOME"]
+      irb_home = File.join(xdg_config_home, "irb")
+      unless File.exist? irb_home
+        require 'fileutils'
+        FileUtils.mkdir_p irb_home
+      end
+      yield proc{|rc| irb_home + "/irb#{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}"}
+    current_dir = Dir.pwd
+    yield proc{|rc| current_dir+"/.config/irb/irb#{rc}"}
+    yield proc{|rc| current_dir+"/.irb#{rc}"}
+    yield proc{|rc| current_dir+"/irb#{rc.sub(/\A_?/, '.')}"}
+    yield proc{|rc| current_dir+"/_irb#{rc}"}
+    yield proc{|rc| current_dir+"/$irb#{rc}"}
   end
 
   # loading modules
@@ -286,15 +403,18 @@ module IRB # :nodoc:
   DefaultEncodings = Struct.new(:external, :internal)
   class << IRB
     private
-    def set_encoding(extern, intern = nil)
+    def set_encoding(extern, intern = nil, override: true)
       verbose, $VERBOSE = $VERBOSE, nil
       Encoding.default_external = extern unless extern.nil? || extern.empty?
       Encoding.default_internal = intern unless intern.nil? || intern.empty?
-      @CONF[:ENCODINGS] = IRB::DefaultEncodings.new(extern, intern)
       [$stdin, $stdout, $stderr].each do |io|
         io.set_encoding(extern, intern)
       end
-      @CONF[:LC_MESSAGES].instance_variable_set(:@encoding, extern)
+      if override
+        @CONF[:LC_MESSAGES].instance_variable_set(:@override_encoding, extern)
+      else
+        @CONF[:LC_MESSAGES].instance_variable_set(:@encoding, extern)
+      end
     ensure
       $VERBOSE = verbose
     end

data/lib/irb/input-method.rb

@@ -11,6 +11,10 @@
 #
 require_relative 'src_encoding'
 require_relative 'magic-file'
+require_relative 'completion'
+require 'io/console'
+require 'reline'
+require 'rdoc'
 
 module IRB
   STDIN_FILE_NAME = "(line)" # :nodoc:
@@ -30,10 +34,18 @@ module IRB
     #
     # See IO#gets for more information.
     def gets
-      IRB.fail NotImplementedError, "gets"
+      fail NotImplementedError, "gets"
     end
     public :gets
 
+    def winsize
+      if instance_variable_defined?(:@stdout)
+        @stdout.winsize
+      else
+        [24, 80]
+      end
+    end
+
     # Whether this input method is still readable when there is no more data to
     # read.
     #
@@ -41,6 +53,11 @@ module IRB
     def readable_after_eof?
       false
     end
+
+    # For debug message
+    def inspect
+      'Abstract InputMethod'
+    end
   end
 
   class StdioInputMethod < InputMethod
@@ -67,7 +84,15 @@ module IRB
     #
     # See IO#eof? for more information.
     def eof?
-      @stdin.eof?
+      rs, = IO.select([@stdin], [], [], 0.00001)
+      if rs and rs[0]
+        c = @stdin.getc
+        result = c.nil? ? true : false
+        @stdin.ungetc(c) unless c.nil?
+        result
+      else # buffer is empty
+        false
+      end
     end
 
     # Whether this input method is still readable when there is no more data to
@@ -91,14 +116,31 @@ module IRB
     def encoding
       @stdin.external_encoding
     end
+
+    # For debug message
+    def inspect
+      'StdioInputMethod'
+    end
   end
 
   # Use a File for IO with irb, see InputMethod
   class FileInputMethod < InputMethod
+    class << self
+      def open(file, &block)
+        begin
+          io = new(file)
+          block.call(io)
+        ensure
+          io&.close
+        end
+      end
+    end
+
     # Creates a new input method object
     def initialize(file)
       super
       @io = IRB::MagicFile.open(file)
+      @external_encoding = @io.external_encoding
     end
     # The file name of this input method, usually given during initialization.
     attr_reader :file_name
@@ -108,7 +150,7 @@ module IRB
     #
     # See IO#eof? for more information.
     def eof?
-      @io.eof?
+      @io.closed? || @io.eof?
     end
 
     # Reads the next line from this input method.
@@ -116,22 +158,39 @@ module IRB
     # See IO#gets for more information.
     def gets
       print @prompt
-      l = @io.gets
-      l
+      @io.gets
     end
 
     # The external encoding for standard input.
     def encoding
-      @io.external_encoding
+      @external_encoding
+    end
+
+    # For debug message
+    def inspect
+      'FileInputMethod'
+    end
+
+    def close
+      @io.close
     end
   end
 
   begin
-    require "readline"
     class ReadlineInputMethod < InputMethod
-      include Readline
+      def self.initialize_readline
+        require "readline"
+      rescue LoadError
+      else
+        include ::Readline
+      end
+
       # Creates a new input method object using Readline
       def initialize
+        self.class.initialize_readline
+        if Readline.respond_to?(:encoding_system_needs)
+          IRB.__send__(:set_encoding, Readline.encoding_system_needs.name, override: false)
+        end
         super
 
         @line_no = 0
@@ -140,6 +199,12 @@ module IRB
 
         @stdin = IO.open(STDIN.to_i, :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
         @stdout = IO.open(STDOUT.to_i, 'w', :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+
+        if Readline.respond_to?("basic_word_break_characters=")
+          Readline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
+        end
+        Readline.completion_append_character = nil
+        Readline.completion_proc = IRB::InputCompletor::CompletionProc
       end
 
       # Reads the next line from this input method.
@@ -186,7 +251,220 @@ module IRB
       def encoding
         @stdin.external_encoding
       end
+
+      # For debug message
+      def inspect
+        readline_impl = (defined?(Reline) && Readline == Reline) ? 'Reline' : 'ext/readline'
+        str = "ReadlineInputMethod with #{readline_impl} #{Readline::VERSION}"
+        inputrc_path = File.expand_path(ENV['INPUTRC'] || '~/.inputrc')
+        str += " and #{inputrc_path}" if File.exist?(inputrc_path)
+        str
+      end
+    end
+  end
+
+  class ReidlineInputMethod < InputMethod
+    include Reline
+
+    # Creates a new input method object using Reline
+    def initialize
+      IRB.__send__(:set_encoding, Reline.encoding_system_needs.name, override: false)
+      super
+
+      @line_no = 0
+      @line = []
+      @eof = false
+
+      @stdin = ::IO.open(STDIN.to_i, :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+      @stdout = ::IO.open(STDOUT.to_i, 'w', :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+
+      if Reline.respond_to?("basic_word_break_characters=")
+        Reline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
+      end
+      Reline.completion_append_character = nil
+      Reline.completer_quote_characters = ''
+      Reline.completion_proc = IRB::InputCompletor::CompletionProc
+      Reline.output_modifier_proc =
+        if IRB.conf[:USE_COLORIZE]
+          proc do |output, complete: |
+            next unless IRB::Color.colorable?
+            IRB::Color.colorize_code(output, complete: complete)
+          end
+        else
+          proc do |output|
+            Reline::Unicode.escape_for_print(output)
+          end
+        end
+      Reline.dig_perfect_match_proc = IRB::InputCompletor::PerfectMatchedProc
+      Reline.autocompletion = IRB.conf[:USE_AUTOCOMPLETE]
+      if IRB.conf[:USE_AUTOCOMPLETE]
+        Reline.add_dialog_proc(:show_doc, SHOW_DOC_DIALOG, Reline::DEFAULT_DIALOG_CONTEXT)
+      end
+    end
+
+    def check_termination(&block)
+      @check_termination_proc = block
+    end
+
+    def dynamic_prompt(&block)
+      @prompt_proc = block
+    end
+
+    def auto_indent(&block)
+      @auto_indent_proc = block
+    end
+
+    SHOW_DOC_DIALOG = ->() {
+      dialog.trap_key = nil
+      alt_d = [
+        [Reline::Key.new(nil, 0xE4, true)], # Normal Alt+d.
+        [27, 100], # Normal Alt+d when convert-meta isn't used.
+        [195, 164], # The "ä" that appears when Alt+d is pressed on xterm.
+        [226, 136, 130] # The "∂" that appears when Alt+d in pressed on iTerm2.
+      ]
+
+      if just_cursor_moving and completion_journey_data.nil?
+        return nil
+      end
+      cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
+      return nil if result.nil? or pointer.nil? or pointer < 0
+      name = result[pointer]
+      name = IRB::InputCompletor.retrieve_completion_data(name, doc_namespace: true)
+
+      options = {}
+      options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
+      driver = RDoc::RI::Driver.new(options)
+
+      if key.match?(dialog.name)
+        begin
+          driver.display_names([name])
+        rescue RDoc::RI::Driver::NotFoundError
+        end
+      end
+
+      begin
+        name = driver.expand_name(name)
+      rescue RDoc::RI::Driver::NotFoundError
+        return nil
+      rescue
+        return nil # unknown error
+      end
+      doc = nil
+      used_for_class = false
+      if not name =~ /#|\./
+        found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
+        if not found.empty?
+          doc = driver.class_document(name, found, klasses, includes, extends)
+          used_for_class = true
+        end
+      end
+      unless used_for_class
+        doc = RDoc::Markup::Document.new
+        begin
+          driver.add_method(doc, name)
+        rescue RDoc::RI::Driver::NotFoundError
+          doc = nil
+        rescue
+          return nil # unknown error
+        end
+      end
+      return nil if doc.nil?
+      width = 40
+
+      right_x = cursor_pos_to_render.x + autocomplete_dialog.width
+      if right_x + width > screen_width
+        right_width = screen_width - (right_x + 1)
+        left_x = autocomplete_dialog.column - width
+        left_x = 0 if left_x < 0
+        left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
+        if right_width.positive? and left_width.positive?
+          if right_width >= left_width
+            width = right_width
+            x = right_x
+          else
+            width = left_width
+            x = left_x
+          end
+        elsif right_width.positive? and left_width <= 0
+          width = right_width
+          x = right_x
+        elsif right_width <= 0 and left_width.positive?
+          width = left_width
+          x = left_x
+        else # Both are negative width.
+          return nil
+        end
+      else
+        x = right_x
+      end
+      formatter = RDoc::Markup::ToAnsi.new
+      formatter.width = width
+      dialog.trap_key = alt_d
+      message = 'Press Alt+d to read the full document'
+      contents = [message] + doc.accept(formatter).split("\n")
+
+      y = cursor_pos_to_render.y
+      DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
+    }
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      Reline.input = @stdin
+      Reline.output = @stdout
+      Reline.prompt_proc = @prompt_proc
+      Reline.auto_indent_proc = @auto_indent_proc if @auto_indent_proc
+      if l = readmultiline(@prompt, false, &@check_termination_proc)
+        HISTORY.push(l) if !l.empty?
+        @line[@line_no += 1] = l + "\n"
+      else
+        @eof = true
+        l
+      end
+    end
+
+    # Whether the end of this input method has been reached, returns +true+
+    # if there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      @eof
+    end
+
+    # Whether this input method is still readable when there is no more data to
+    # read.
+    #
+    # See IO#eof for more information.
+    def readable_after_eof?
+      true
+    end
+
+    # Returns the current line number for #io.
+    #
+    # #line counts the number of times #gets is called.
+    #
+    # See IO#lineno for more information.
+    def line(line_no)
+      @line[line_no]
+    end
+
+    # The external encoding for standard input.
+    def encoding
+      @stdin.external_encoding
+    end
+
+    # For debug message
+    def inspect
+      config = Reline::Config.new
+      str = "ReidlineInputMethod with Reline #{Reline::VERSION}"
+      if config.respond_to?(:inputrc_path)
+        inputrc_path = File.expand_path(config.inputrc_path)
+      else
+        inputrc_path = File.expand_path(ENV['INPUTRC'] || '~/.inputrc')
+      end
+      str += " and #{inputrc_path}" if File.exist?(inputrc_path)
+      str
     end
-  rescue LoadError
   end
 end

data/lib/irb/inspector.rb

@@ -100,18 +100,27 @@ module IRB # :nodoc:
     # Proc to call when the input is evaluated and output in irb.
     def inspect_value(v)
       @inspect.call(v)
+    rescue
+      puts "(Object doesn't support #inspect)"
+      ''
     end
   end
 
   Inspector.def_inspector([false, :to_s, :raw]){|v| v.to_s}
-  Inspector.def_inspector([true, :p, :inspect]){|v|
-    begin
-      v.inspect
-    rescue NoMethodError
-      puts "(Object doesn't support #inspect)"
+  Inspector.def_inspector([:p, :inspect]){|v|
+    result = v.inspect
+    if IRB.conf[:MAIN_CONTEXT]&.use_colorize? && Color.inspect_colorable?(v)
+      result = Color.colorize_code(result)
+    end
+    result
+  }
+  Inspector.def_inspector([true, :pp, :pretty_inspect], proc{require "irb/color_printer"}){|v|
+    if IRB.conf[:MAIN_CONTEXT]&.use_colorize?
+      IRB::ColorPrinter.pp(v, '').chomp
+    else
+      v.pretty_inspect.chomp
     end
   }
-  Inspector.def_inspector([:pp, :pretty_inspect], proc{require "pp"}){|v| v.pretty_inspect.chomp}
   Inspector.def_inspector([:yaml, :YAML], proc{require "yaml"}){|v|
     begin
       YAML.dump(v)
@@ -125,8 +134,3 @@ module IRB # :nodoc:
     Marshal.dump(v)
   }
 end
-
-
-
-
-