irb 1.3.0 → 1.3.5

data/lib/irb/cmd/whereami.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Whereami < Nop
+      def execute(*)
+        code = irb_context.workspace.code_around_binding
+        if code
+          puts code
+        else
+          puts "The current context doesn't have code."
+        end
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/color.rb

@@ -17,7 +17,7 @@ module IRB # :nodoc:
     CYAN      = 36
 
     TOKEN_KEYWORDS = {
-      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__'],
+      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__', '__ENCODING__'],
       on_const: ['ENV'],
     }
     private_constant :TOKEN_KEYWORDS
@@ -60,6 +60,11 @@ module IRB # :nodoc:
         on_words_beg:       [[RED, BOLD],             ALL],
         on_parse_error:     [[RED, REVERSE],          ALL],
         compile_error:      [[RED, REVERSE],          ALL],
+        on_assign_error:    [[RED, REVERSE],          ALL],
+        on_alias_error:     [[RED, REVERSE],          ALL],
+        on_class_name_error:[[RED, REVERSE],          ALL],
+        on_param_error:     [[RED, REVERSE],          ALL],
+        on___end__:         [[GREEN],                 ALL],
       }
     rescue NameError
       # Give up highlighting Ripper-incompatible older Ruby
@@ -67,6 +72,9 @@ module IRB # :nodoc:
     end
     private_constant :TOKEN_SEQ_EXPRS
 
+    ERROR_TOKENS = TOKEN_SEQ_EXPRS.keys.select { |k| k.to_s.end_with?('error') }
+    private_constant :ERROR_TOKENS
+
     class << self
       def colorable?
         $stdout.tty? && supported? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
@@ -107,14 +115,20 @@ module IRB # :nodoc:
       # If `complete` is false (code is incomplete), this does not warn compile_error.
       # This option is needed to avoid warning a user when the compile_error is happening
       # because the input is not wrong but just incomplete.
-      def colorize_code(code, complete: true)
+      def colorize_code(code, complete: true, ignore_error: false)
         return code unless colorable?
 
         symbol_state = SymbolState.new
         colored = +''
         length = 0
+        end_seen = false
 
         scan(code, allow_last_error: !complete) do |token, str, expr|
+          # IRB::ColorPrinter skips colorizing fragments with any invalid token
+          if ignore_error && ERROR_TOKENS.include?(token)
+            return Reline::Unicode.escape_for_print(code)
+          end
+
           in_symbol = symbol_state.scan_token(token)
           str.each_line do |line|
             line = Reline::Unicode.escape_for_print(line)
@@ -126,10 +140,11 @@ module IRB # :nodoc:
             end
           end
           length += str.bytesize
+          end_seen = true if token == :on___end__
         end
 
         # give up colorizing incomplete Ripper tokens
-        if length != code.bytesize
+        unless end_seen or length == code.bytesize
           return Reline::Unicode.escape_for_print(code)
         end
 
@@ -180,11 +195,12 @@ module IRB # :nodoc:
             end
           end
         end
+      ensure
         $VERBOSE = verbose
       end
 
       def dispatch_seq(token, expr, str, in_symbol:)
-        if token == :on_parse_error or token == :compile_error
+        if ERROR_TOKENS.include?(token)
           TOKEN_SEQ_EXPRS[token][0]
         elsif in_symbol
           [YELLOW]

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
 #
 
-autoload :RDoc, "rdoc"
+require_relative 'ruby-lex'
 
 module IRB
   module InputCompletor # :nodoc:
@@ -38,8 +38,69 @@ module IRB
 
     BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
 
-    CompletionProc = proc { |input|
-      retrieve_completion_data(input).compact.map{ |i| i.encode(Encoding.default_external) }
+    def self.retrieve_files_to_require_from_load_path
+      @@files_from_load_path ||= $LOAD_PATH.flat_map { |path|
+        begin
+          Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: path)
+        rescue Errno::ENOENT
+          []
+        end
+      }.uniq.map { |path|
+        path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
+      }
+    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)
@@ -47,7 +108,7 @@ module IRB
       when /^((["'`]).*\2)\.([^.]*)$/
         # String
         receiver = $1
-        message = Regexp.quote($3)
+        message = $3
 
         candidates = String.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -59,7 +120,7 @@ module IRB
       when /^(\/[^\/]*\/)\.([^.]*)$/
         # Regexp
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         candidates = Regexp.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -71,7 +132,7 @@ module IRB
       when /^([^\]]*\])\.([^.]*)$/
         # Array
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         candidates = Array.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -83,7 +144,7 @@ module IRB
       when /^([^\}]*\})\.([^.]*)$/
         # Proc or Hash
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         proc_candidates = Proc.instance_methods.collect{|m| m.to_s}
         hash_candidates = Hash.instance_methods.collect{|m| m.to_s}
@@ -117,7 +178,7 @@ module IRB
       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)
@@ -134,7 +195,7 @@ module IRB
         # Symbol
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         candidates = Symbol.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -147,7 +208,7 @@ module IRB
         # Numeric
         receiver = $~[:num]
         sep = $~[:sep]
-        message = Regexp.quote($~[:mes])
+        message = $~[:mes]
 
         begin
           instance = eval(receiver, bind)
@@ -169,7 +230,7 @@ module IRB
         # Numeric(0xFFFF)
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         begin
           instance = eval(receiver, bind)
@@ -201,7 +262,7 @@ module IRB
         # 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}.push("true", "false", "nil")
         lv = eval("local_variables", bind).collect{|m| m.to_s}
@@ -244,7 +305,7 @@ module IRB
         # unknown(maybe String)
 
         receiver = ""
-        message = Regexp.quote($1)
+        message = $1
 
         candidates = String.instance_methods(true).collect{|m| m.to_s}
         if doc_namespace
@@ -266,13 +327,22 @@ module IRB
     end
 
     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|
@@ -294,7 +364,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

data/lib/irb/ext/loader.rb

@@ -31,8 +31,31 @@ module IRB # :nodoc:
       load_file(path, priv)
     end
 
+    if File.respond_to?(:absolute_path?)
+      def absolute_path?(path)
+        File.absolute_path?(path)
+      end
+    else
+      separator =
+        if File::ALT_SEPARATOR
+          "[#{Regexp.quote(File::SEPARATOR + File::ALT_SEPARATOR)}]"
+        else
+          File::SEPARATOR
+        end
+      ABSOLUTE_PATH_PATTERN = # :nodoc:
+        case Dir.pwd
+        when /\A\w:/, /\A#{separator}{2}/
+          /\A(?:\w:|#{separator})#{separator}/
+        else
+          /\A#{separator}/
+        end
+      def absolute_path?(path)
+        ABSOLUTE_PATH_PATTERN =~ path
+      end
+    end
+
     def search_file_from_ruby_path(fn) # :nodoc:
-      if /^#{Regexp.quote(File::Separator)}/ =~ fn
+      if absolute_path?(fn)
         return fn if File.exist?(fn)
         return nil
       end
@@ -50,16 +73,18 @@ module IRB # :nodoc:
     # See Irb#suspend_input_method for more information.
     def source_file(path)
       irb.suspend_name(path, File.basename(path)) do
-        irb.suspend_input_method(FileInputMethod.new(path)) do
-          |back_io|
-          irb.signal_status(:IN_LOAD) do
-            if back_io.kind_of?(FileInputMethod)
-              irb.eval_input
-            else
-              begin
+        FileInputMethod.open(path) do |io|
+          irb.suspend_input_method(io) do
+            |back_io|
+            irb.signal_status(:IN_LOAD) do
+              if back_io.kind_of?(FileInputMethod)
                 irb.eval_input
-              rescue LoadAbort
-                print "load abort!!\n"
+              else
+                begin
+                  irb.eval_input
+                rescue LoadAbort
+                  print "load abort!!\n"
+                end
               end
             end
           end
@@ -79,16 +104,18 @@ module IRB # :nodoc:
           ws = WorkSpace.new
         end
         irb.suspend_workspace(ws) do
-          irb.suspend_input_method(FileInputMethod.new(path)) do
-            |back_io|
-            irb.signal_status(:IN_LOAD) do
-              if back_io.kind_of?(FileInputMethod)
-                irb.eval_input
-              else
-                begin
+          FileInputMethod.open(path) do |io|
+            irb.suspend_input_method(io) do
+              |back_io|
+              irb.signal_status(:IN_LOAD) do
+                if back_io.kind_of?(FileInputMethod)
                   irb.eval_input
-                rescue LoadAbort
-                  print "load abort!!\n"
+                else
+                  begin
+                    irb.eval_input
+                  rescue LoadAbort
+                    print "load abort!!\n"
+                  end
                 end
               end
             end

data/lib/irb/ext/save-history.rb

@@ -81,6 +81,8 @@ module IRB
             end
           }
         end
+        @loaded_history_lines = history.size
+        @loaded_history_mtime = File.mtime(history_file)
       end
     end
 
@@ -105,12 +107,20 @@ module IRB
           raise
         end
 
-        open(history_file, "w:#{IRB.conf[:LC_MESSAGES].encoding}", 0600) do |f|
+        if File.exist?(history_file) && @loaded_history_mtime &&
+           File.mtime(history_file) != @loaded_history_mtime
+          history = history[@loaded_history_lines..-1]
+          append_history = true
+        end
+
+        open(history_file, "#{append_history ? 'a' : 'w'}:#{IRB.conf[:LC_MESSAGES].encoding}", 0600) do |f|
           hist = history.map{ |l| l.split("\n").join("\\\n") }
-          begin
-            hist = hist.last(num) if hist.size > num and num > 0
-          rescue RangeError # bignum too big to convert into `long'
-            # Do nothing because the bignum should be treated as inifinity
+          unless append_history
+            begin
+              hist = hist.last(num) if hist.size > num and num > 0
+            rescue RangeError # bignum too big to convert into `long'
+              # Do nothing because the bignum should be treated as inifinity
+            end
           end
           f.puts(hist)
         end