irb 1.0.0 → 1.4.1

data/lib/irb/color_printer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'pp'
+require 'irb/color'
+
+module IRB
+  class ColorPrinter < ::PP
+    class << self
+      def pp(obj, out = $>, width = screen_width)
+        q = ColorPrinter.new(out, width)
+        q.guard_inspect_key {q.pp obj}
+        q.flush
+        out << "\n"
+      end
+
+      private
+
+      def screen_width
+        Reline.get_screen_size.last
+      rescue Errno::EINVAL # in `winsize': Invalid argument - <STDIN>
+        79
+      end
+    end
+
+    def pp(obj)
+      if obj.is_a?(String)
+        # Avoid calling Ruby 2.4+ String#pretty_print that splits a string by "\n"
+        text(obj.inspect)
+      else
+        super
+      end
+    end
+
+    def text(str, width = nil)
+      unless str.is_a?(String)
+        str = str.inspect
+      end
+      width ||= str.length
+
+      case str
+      when /\A#</, '=', '>'
+        super(Color.colorize(str, [:GREEN]), width)
+      else
+        super(Color.colorize_code(str, ignore_error: true), width)
+      end
+    end
+  end
+end

data/lib/irb/completion.rb

@@ -7,7 +7,7 @@
 #       From Original Idea of shugo@ruby-lang.org
 #
 
-require "readline"
+require_relative 'ruby-lex'
 
 module IRB
   module InputCompletor # :nodoc:
@@ -16,11 +16,12 @@ module IRB
     # Set of reserved words used by Ruby, you should not use these for
     # constants or variables
     ReservedWords = %w[
+      __ENCODING__ __LINE__ __FILE__
       BEGIN END
       alias and
       begin break
       case class
-      def defined do
+      def defined? do
       else elsif end ensure
       false for
       if in
@@ -35,118 +36,267 @@ module IRB
       yield
     ]
 
-    CompletionProc = proc { |input|
-      bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
 
+    def self.absolute_path?(p) # TODO Remove this method after 2.6 EOL.
+      if File.respond_to?(:absolute_path?)
+        File.absolute_path?(p)
+      else
+        if File.absolute_path(p) == p
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def self.retrieve_gem_and_system_load_path
+      gem_paths = Gem::Specification.latest_specs(true).map { |s|
+        s.require_paths.map { |p|
+          if absolute_path?(p)
+            p
+          else
+            File.join(s.full_gem_path, p)
+          end
+        }
+      }.flatten if defined?(Gem::Specification)
+      (gem_paths.to_a | $LOAD_PATH).sort
+    end
+
+    def self.retrieve_files_to_require_from_load_path
+      @@files_from_load_path ||=
+        (
+          shortest = []
+          rest = retrieve_gem_and_system_load_path.each_with_object([]) { |path, result|
+            begin
+              names = Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: path)
+            rescue Errno::ENOENT
+              nil
+            end
+            next if names.empty?
+            names.map! { |n| n.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '') }.sort!
+            shortest << names.shift
+            result.concat(names)
+          }
+          shortest.sort! | rest
+        )
+    end
+
+    def self.retrieve_files_to_require_relative_from_current_dir
+      @@files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
+        path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
+      }
+    end
+
+    CompletionRequireProc = lambda { |target, preposing = nil, postposing = nil|
+      if target =~ /\A(['"])([^'"]+)\Z/
+        quote = $1
+        actual_target = $2
+      else
+        return nil # It's not String literal
+      end
+      tokens = RubyLex.ripper_lex_without_warning(preposing.gsub(/\s*\z/, ''))
+      tok = nil
+      tokens.reverse_each do |t|
+        unless [:on_lparen, :on_sp, :on_ignored_sp, :on_nl, :on_ignored_nl, :on_comment].include?(t.event)
+          tok = t
+          break
+        end
+      end
+      result = []
+      if tok && tok.event == :on_ident && tok.state == Ripper::EXPR_CMDARG
+        case tok.tok
+        when 'require'
+          result = retrieve_files_to_require_from_load_path.select { |path|
+            path.start_with?(actual_target)
+          }.map { |path|
+            quote + path
+          }
+        when 'require_relative'
+          result = retrieve_files_to_require_relative_from_current_dir.select { |path|
+            path.start_with?(actual_target)
+          }.map { |path|
+            quote + path
+          }
+        end
+      end
+      result
+    }
+
+    CompletionProc = lambda { |target, preposing = nil, postposing = nil|
+      if preposing && postposing
+        result = CompletionRequireProc.(target, preposing, postposing)
+        unless result
+          result = retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
+        end
+        result
+      else
+        retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
+      end
+    }
+
+    def self.retrieve_completion_data(input, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
       case input
       when /^((["'`]).*\2)\.([^.]*)$/
         # String
         receiver = $1
-        message = Regexp.quote($3)
+        message = $3
 
         candidates = String.instance_methods.collect{|m| m.to_s}
-        select_message(receiver, message, candidates)
+        if doc_namespace
+          "String.#{message}"
+        else
+          select_message(receiver, message, candidates)
+        end
 
       when /^(\/[^\/]*\/)\.([^.]*)$/
         # Regexp
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         candidates = Regexp.instance_methods.collect{|m| m.to_s}
-        select_message(receiver, message, candidates)
+        if doc_namespace
+          "Regexp.#{message}"
+        else
+          select_message(receiver, message, candidates)
+        end
 
       when /^([^\]]*\])\.([^.]*)$/
         # Array
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         candidates = Array.instance_methods.collect{|m| m.to_s}
-        select_message(receiver, message, candidates)
+        if doc_namespace
+          "Array.#{message}"
+        else
+          select_message(receiver, message, candidates)
+        end
 
       when /^([^\}]*\})\.([^.]*)$/
         # Proc or Hash
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
-        candidates = Proc.instance_methods.collect{|m| m.to_s}
-        candidates |= Hash.instance_methods.collect{|m| m.to_s}
-        select_message(receiver, message, candidates)
+        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
-        if Symbol.respond_to?(:all_symbols)
-          sym = $1
-          candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
-          candidates.grep(/^#{Regexp.quote(sym)}/)
-        else
-          []
+        return nil if doc_namespace
+        sym = $1
+        candidates = Symbol.all_symbols.collect do |s|
+          ":" + s.id2name.encode(Encoding.default_external)
+        rescue EncodingError
+          # ignore
         end
+        candidates.grep(/^#{Regexp.quote(sym)}/)
 
-      when /^::([A-Z][^:\.\(]*)$/
+      when /^::([A-Z][^:\.\(\)]*)$/
         # Absolute Constant or class methods
         receiver = $1
         candidates = Object.constants.collect{|m| m.to_s}
-        candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
+        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)
+        message = $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
-        select_message(receiver, message, candidates, "::")
+        if doc_namespace
+          "#{receiver}::#{message}"
+        else
+          select_message(receiver, message, candidates, "::")
+        end
 
       when /^(:[^:.]+)(\.|::)([^.]*)$/
         # Symbol
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         candidates = Symbol.instance_methods.collect{|m| m.to_s}
-        select_message(receiver, message, candidates, sep)
+        if doc_namespace
+          "Symbol.#{message}"
+        else
+          select_message(receiver, message, candidates, sep)
+        end
 
-      when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)(\.|::)([^.]*)$/
+      when /^(?<num>-?(?:0[dbo])?[0-9_]+(?:\.[0-9_]+)?(?:(?:[eE][+-]?[0-9]+)?i?|r)?)(?<sep>\.|::)(?<mes>[^.]*)$/
         # Numeric
-        receiver = $1
-        sep = $5
-        message = Regexp.quote($6)
+        receiver = $~[:num]
+        sep = $~[:sep]
+        message = $~[:mes]
 
         begin
-          candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+          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
-          candidates = []
+          if doc_namespace
+            nil
+          else
+            candidates = []
+          end
         end
-        select_message(receiver, message, candidates, sep)
 
       when /^(-?0x[0-9a-fA-F_]+)(\.|::)([^.]*)$/
         # Numeric(0xFFFF)
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         begin
-          candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+          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
-          candidates = []
+          if doc_namespace
+            nil
+          else
+            candidates = []
+          end
         end
-        select_message(receiver, message, candidates, sep)
 
       when /^(\$[^.]*)$/
         # global var
-        regmessage = Regexp.new(Regexp.quote($1))
-        candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+        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 /^([^."].*)(\.|::)([^.]*)$/
+      when /^([^.:"].*)(\.|::)([^.]*)$/
         # variable.func or func.func
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
-        gv = eval("global_variables", bind).collect{|m| m.to_s}
+        gv = eval("global_variables", bind).collect{|m| m.to_s}.push("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}
@@ -177,21 +327,76 @@ module IRB
           candidates.sort!
           candidates.uniq!
         end
-        select_message(receiver, message, candidates, sep)
+        if doc_namespace
+          rec_class = rec.is_a?(Module) ? rec : rec.class
+          "#{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)
+        message = $1
 
         candidates = String.instance_methods(true).collect{|m| m.to_s}
-        select_message(receiver, message, candidates)
+        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}
+        if doc_namespace
+          vars = eval("local_variables | instance_variables", bind).collect{|m| m.to_s}
+          perfect_match_var = vars.find{|m| m.to_s == input}
+          if perfect_match_var
+            eval("#{perfect_match_var}.class.name", bind)
+          else
+            candidates = eval("methods | private_methods | local_variables | instance_variables | self.class.constants", bind).collect{|m| m.to_s}
+            candidates |= ReservedWords
+            candidates.find{ |i| i == input }
+          end
+        else
+          candidates = eval("methods | private_methods | local_variables | instance_variables | self.class.constants", bind).collect{|m| m.to_s}
+          candidates |= ReservedWords
+          candidates.grep(/^#{Regexp.quote(input)}/)
+        end
+      end
+    end
 
-        (candidates|ReservedWords).grep(/^#{Regexp.quote(input)}/)
+    PerfectMatchedProc = ->(matched, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding) {
+      begin
+        require 'rdoc'
+      rescue LoadError
+        return
+      end
+
+      RDocRIDriver ||= RDoc::RI::Driver.new
+
+      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        IRB.__send__(:easter_egg)
+        return
+      end
+
+      namespace = retrieve_completion_data(matched, bind: bind, doc_namespace: true)
+      return unless namespace
+
+      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
     }
 
@@ -199,7 +404,7 @@ module IRB
     Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
 
     def self.select_message(receiver, message, candidates, sep = ".")
-      candidates.grep(/^#{message}/).collect do |e|
+      candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
         case e
         when /^[a-zA-Z_]/
           receiver + sep + e
@@ -225,7 +430,7 @@ module IRB
         end
       end
 
-      %i(IRB SLex RubyLex RubyToken).each do |sym|
+      %i(IRB RubyLex).each do |sym|
         next unless Object.const_defined?(sym)
         scanner.call(Object.const_get(sym))
       end
@@ -236,9 +441,3 @@ module IRB
     end
   end
 end
-
-if Readline.respond_to?("basic_word_break_characters=")
-  Readline.basic_word_break_characters= " \t\n`><=;|&{("
-end
-Readline.completion_append_character = nil
-Readline.completion_proc = IRB::InputCompletor::CompletionProc