irb 1.4.2 → 1.6.1

data/lib/irb/cmd/next.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Next < DebugCommand
+      def execute(*args)
+        super(do_cmds: ["next", *args].join(" "))
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/nop.rb

@@ -13,17 +13,41 @@ module IRB
   # :stopdoc:
 
   module ExtendCommand
+    class CommandArgumentError < StandardError; end
+
     class Nop
+      class << self
+        def category(category = nil)
+          @category = category if category
+          @category
+        end
+
+        def description(description = nil)
+          @description = description if description
+          @description
+        end
+
+        private
+
+        def string_literal?(args)
+          sexp = Ripper.sexp(args)
+          sexp && sexp.size == 2 && sexp.last&.first&.first == :string_literal
+        end
+      end
 
       if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.7.0"
         def self.execute(conf, *opts, **kwargs, &block)
           command = new(conf)
           command.execute(*opts, **kwargs, &block)
+        rescue CommandArgumentError => e
+          puts e.message
         end
       else
         def self.execute(conf, *opts, &block)
           command = new(conf)
           command.execute(*opts, &block)
+        rescue CommandArgumentError => e
+          puts e.message
         end
       end
 

data/lib/irb/cmd/pushws.rb

@@ -18,12 +18,18 @@ module IRB
 
   module ExtendCommand
     class Workspaces < Nop
+      category "IRB"
+      description "Show workspaces."
+
       def execute(*obj)
         irb_context.workspaces.collect{|ws| ws.main}
       end
     end
 
     class PushWorkspace < Workspaces
+      category "IRB"
+      description "Push an object to the workspace stack."
+
       def execute(*obj)
         irb_context.push_workspace(*obj)
         super
@@ -31,6 +37,9 @@ module IRB
     end
 
     class PopWorkspace < Workspaces
+      category "IRB"
+      description "Pop a workspace from the workspace stack."
+
       def execute(*obj)
         irb_context.pop_workspace(*obj)
         super

data/lib/irb/cmd/show_cmds.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "nop"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class ShowCmds < Nop
+      category "IRB"
+      description "List all available commands and their description."
+
+      def execute(*args)
+        commands_info = IRB::ExtendCommandBundle.all_commands_info
+        commands_grouped_by_categories = commands_info.group_by { |cmd| cmd[:category] }
+        longest_cmd_name_length = commands_info.map { |c| c[:display_name] }.max { |a, b| a.length <=> b.length }.length
+
+        output = StringIO.new
+
+        commands_grouped_by_categories.each do |category, cmds|
+          output.puts Color.colorize(category, [:BOLD])
+
+          cmds.each do |cmd|
+            output.puts "  #{cmd[:display_name].to_s.ljust(longest_cmd_name_length)}    #{cmd[:description]}"
+          end
+
+          output.puts
+        end
+
+        puts output.string
+
+        nil
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/show_source.rb

@@ -9,12 +9,71 @@ module IRB
 
   module ExtendCommand
     class ShowSource < Nop
+      category "Context"
+      description "Show the source code of a given method or constant."
+
+      class << self
+        def transform_args(args)
+          # Return a string literal as is for backward compatibility
+          if args.empty? || string_literal?(args)
+            args
+          else # Otherwise, consider the input as a String for convenience
+            args.strip.dump
+          end
+        end
+
+        def find_source(str, irb_context)
+          case str
+          when /\A[A-Z]\w*(::[A-Z]\w*)*\z/ # Const::Name
+            eval(str, irb_context.workspace.binding) # trigger autoload
+            base = irb_context.workspace.binding.receiver.yield_self { |r| r.is_a?(Module) ? r : Object }
+            file, line = base.const_source_location(str) if base.respond_to?(:const_source_location) # Ruby 2.7+
+          when /\A(?<owner>[A-Z]\w*(::[A-Z]\w*)*)#(?<method>[^ :.]+)\z/ # Class#method
+            owner = eval(Regexp.last_match[:owner], irb_context.workspace.binding)
+            method = Regexp.last_match[:method]
+            if owner.respond_to?(:instance_method) && owner.instance_methods.include?(method.to_sym)
+              file, line = owner.instance_method(method).source_location
+            end
+          when /\A((?<receiver>.+)(\.|::))?(?<method>[^ :.]+)\z/ # method, receiver.method, receiver::method
+            receiver = eval(Regexp.last_match[:receiver] || 'self', irb_context.workspace.binding)
+            method = Regexp.last_match[:method]
+            file, line = receiver.method(method).source_location if receiver.respond_to?(method)
+          end
+          if file && line
+            Source.new(file: file, first_line: line, last_line: find_end(file, line))
+          end
+        end
+
+        private
+
+        def find_end(file, first_line)
+          return first_line unless File.exist?(file)
+          lex = RubyLex.new
+          lines = File.read(file).lines[(first_line - 1)..-1]
+          tokens = RubyLex.ripper_lex_without_warning(lines.join)
+          prev_tokens = []
+
+          # chunk with line number
+          tokens.chunk { |tok| tok.pos[0] }.each do |lnum, chunk|
+            code = lines[0..lnum].join
+            prev_tokens.concat chunk
+            continue = lex.process_continue(prev_tokens)
+            code_block_open = lex.check_code_block(code, prev_tokens)
+            if !continue && !code_block_open
+              return first_line + lnum
+            end
+          end
+          first_line
+        end
+      end
+
       def execute(str = nil)
         unless str.is_a?(String)
           puts "Error: Expected a string but got #{str.inspect}"
           return
         end
-        source = find_source(str)
+
+        source = self.class.find_source(str, @irb_context)
         if source && File.exist?(source.file)
           show_source(source)
         else
@@ -35,48 +94,6 @@ module IRB
         puts
       end
 
-      def find_source(str)
-        case str
-        when /\A[A-Z]\w*(::[A-Z]\w*)*\z/ # Const::Name
-          eval(str, irb_context.workspace.binding) # trigger autoload
-          base = irb_context.workspace.binding.receiver.yield_self { |r| r.is_a?(Module) ? r : Object }
-          file, line = base.const_source_location(str) if base.respond_to?(:const_source_location) # Ruby 2.7+
-        when /\A(?<owner>[A-Z]\w*(::[A-Z]\w*)*)#(?<method>[^ :.]+)\z/ # Class#method
-          owner = eval(Regexp.last_match[:owner], irb_context.workspace.binding)
-          method = Regexp.last_match[:method]
-          if owner.respond_to?(:instance_method) && owner.instance_methods.include?(method.to_sym)
-            file, line = owner.instance_method(method).source_location
-          end
-        when /\A((?<receiver>.+)(\.|::))?(?<method>[^ :.]+)\z/ # method, receiver.method, receiver::method
-          receiver = eval(Regexp.last_match[:receiver] || 'self', irb_context.workspace.binding)
-          method = Regexp.last_match[:method]
-          file, line = receiver.method(method).source_location if receiver.respond_to?(method)
-        end
-        if file && line
-          Source.new(file: file, first_line: line, last_line: find_end(file, line))
-        end
-      end
-
-      def find_end(file, first_line)
-        return first_line unless File.exist?(file)
-        lex = RubyLex.new
-        lines = File.read(file).lines[(first_line - 1)..-1]
-        tokens = RubyLex.ripper_lex_without_warning(lines.join)
-        prev_tokens = []
-
-        # chunk with line number
-        tokens.chunk { |tok| tok.pos[0] }.each do |lnum, chunk|
-          code = lines[0..lnum].join
-          prev_tokens.concat chunk
-          continue = lex.process_continue(prev_tokens)
-          code_block_open = lex.check_code_block(code, prev_tokens)
-          if !continue && !code_block_open
-            return first_line + lnum
-          end
-        end
-        first_line
-      end
-
       def bold(str)
         Color.colorize(str, [:BOLD])
       end

data/lib/irb/cmd/step.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Step < DebugCommand
+      def execute(*args)
+        super(do_cmds: ["step", *args].join(" "))
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/subirb.rb

@@ -10,31 +10,57 @@
 #
 
 require_relative "nop"
-require_relative "../ext/multi-irb"
 
 module IRB
   # :stopdoc:
 
   module ExtendCommand
-    class IrbCommand < Nop
+    class MultiIRBCommand < Nop
+      def initialize(conf)
+        super
+        extend_irb_context
+      end
+
+      private
+
+      def extend_irb_context
+        # this extension patches IRB context like IRB.CurrentContext
+        require_relative "../ext/multi-irb"
+      end
+    end
+
+    class IrbCommand < MultiIRBCommand
+      category "IRB"
+      description "Start a child IRB."
+
       def execute(*obj)
         IRB.irb(nil, *obj)
       end
     end
 
-    class Jobs < Nop
+    class Jobs < MultiIRBCommand
+      category "IRB"
+      description "List of current sessions."
+
       def execute
         IRB.JobManager
       end
     end
 
-    class Foreground < Nop
-      def execute(key)
+    class Foreground < MultiIRBCommand
+      category "IRB"
+      description "Switches to the session of the given number."
+
+      def execute(key = nil)
+        raise CommandArgumentError.new("Please specify the id of target IRB job (listed in the `jobs` command).") unless key
         IRB.JobManager.switch(key)
       end
     end
 
-    class Kill < Nop
+    class Kill < MultiIRBCommand
+      category "IRB"
+      description "Kills the session with the given number."
+
       def execute(*keys)
         IRB.JobManager.kill(*keys)
       end

data/lib/irb/cmd/whereami.rb

@@ -7,6 +7,9 @@ module IRB
 
   module ExtendCommand
     class Whereami < Nop
+      category "Context"
+      description "Show the source code around binding.irb again."
+
       def execute(*)
         code = irb_context.workspace.code_around_binding
         if code

data/lib/irb/color.rb

@@ -123,13 +123,15 @@ 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, ignore_error: false, colorable: colorable?)
+      def colorize_code(code, complete: true, ignore_error: false, colorable: colorable?, local_variables: [])
         return code unless colorable
 
         symbol_state = SymbolState.new
         colored = +''
+        lvars_code = RubyLex.generate_local_variables_assign_code(local_variables)
+        code_with_lvars = lvars_code ? "#{lvars_code}\n#{code}" : code
 
-        scan(code, allow_last_error: !complete) do |token, str, expr|
+        scan(code_with_lvars, allow_last_error: !complete) do |token, str, expr|
           # handle uncolorable code
           if token.nil?
             colored << Reline::Unicode.escape_for_print(str)
@@ -152,6 +154,11 @@ module IRB # :nodoc:
             end
           end
         end
+
+        if lvars_code
+          raise "#{lvars_code.dump} should have no \\n" if lvars_code.include?("\n")
+          colored.sub!(/\A.+\n/, '') # delete_prefix lvars_code with colors
+        end
         colored
       end
 

data/lib/irb/completion.rb

@@ -64,25 +64,27 @@ module IRB
       if File.respond_to?(:absolute_path?)
         File.absolute_path?(p)
       else
-        if File.absolute_path(p) == p
-          true
-        else
-          false
-        end
+        File.absolute_path(p) == p
       end
     end
 
+    GEM_PATHS =
+      if defined?(Gem::Specification)
+        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
+      else
+        []
+      end.freeze
+
     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)
-      candidates = (gem_paths.to_a | $LOAD_PATH)
+      candidates = (GEM_PATHS | $LOAD_PATH)
       candidates.map do |p|
         if p.respond_to?(:to_path)
           p.to_path
@@ -171,10 +173,10 @@ module IRB
         receiver = $1
         message = $3
 
-        candidates = String.instance_methods.collect{|m| m.to_s}
         if doc_namespace
           "String.#{message}"
         else
+          candidates = String.instance_methods.collect{|m| m.to_s}
           select_message(receiver, message, candidates)
         end
 
@@ -183,10 +185,10 @@ module IRB
         receiver = $1
         message = $2
 
-        candidates = Regexp.instance_methods.collect{|m| m.to_s}
         if doc_namespace
           "Regexp.#{message}"
         else
+          candidates = Regexp.instance_methods.collect{|m| m.to_s}
           select_message(receiver, message, candidates)
         end
 
@@ -195,10 +197,10 @@ module IRB
         receiver = $1
         message = $2
 
-        candidates = Array.instance_methods.collect{|m| m.to_s}
         if doc_namespace
           "Array.#{message}"
         else
+          candidates = Array.instance_methods.collect{|m| m.to_s}
           select_message(receiver, message, candidates)
         end
 
@@ -207,29 +209,33 @@ module IRB
         receiver = $1
         message = $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
+          proc_candidates = Proc.instance_methods.collect{|m| m.to_s}
+          hash_candidates = Hash.instance_methods.collect{|m| m.to_s}
           select_message(receiver, message, proc_candidates | hash_candidates)
         end
 
       when /^(:[^:.]*)$/
         # Symbol
-        return nil if doc_namespace
-        sym = $1
-        candidates = Symbol.all_symbols.collect do |s|
-          ":" + s.id2name.encode(Encoding.default_external)
-        rescue EncodingError
-          # ignore
+        if doc_namespace
+          nil
+        else
+          sym = $1
+          candidates = Symbol.all_symbols.collect do |s|
+            ":" + s.id2name.encode(Encoding.default_external)
+          rescue EncodingError
+            # ignore
+          end
+          candidates.grep(/^#{Regexp.quote(sym)}/)
         end
-        candidates.grep(/^#{Regexp.quote(sym)}/)
-
       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
@@ -240,16 +246,18 @@ module IRB
         # Constant or class methods
         receiver = $1
         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
+
         if doc_namespace
           "#{receiver}::#{message}"
         else
-          select_message(receiver, message, candidates, "::")
+          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.sort, "::")
         end
 
       when /^(:[^:.]+)(\.|::)([^.]*)$/
@@ -258,10 +266,10 @@ module IRB
         sep = $2
         message = $3
 
-        candidates = Symbol.instance_methods.collect{|m| m.to_s}
         if doc_namespace
           "Symbol.#{message}"
         else
+          candidates = Symbol.instance_methods.collect{|m| m.to_s}
           select_message(receiver, message, candidates, sep)
         end
 
@@ -273,6 +281,7 @@ module IRB
 
         begin
           instance = eval(receiver, bind)
+
           if doc_namespace
             "#{instance.class.name}.#{message}"
           else
@@ -283,7 +292,7 @@ module IRB
           if doc_namespace
             nil
           else
-            candidates = []
+            []
           end
         end
 
@@ -305,7 +314,7 @@ module IRB
           if doc_namespace
             nil
           else
-            candidates = []
+            []
           end
         end
 
@@ -313,6 +322,7 @@ module IRB
         # global var
         gvar = $1
         all_gvars = global_variables.collect{|m| m.to_s}
+
         if doc_namespace
           all_gvars.find{ |i| i == gvar }
         else
@@ -351,11 +361,13 @@ module IRB
           to_ignore = ignored_modules
           ObjectSpace.each_object(Module){|m|
             next if (to_ignore.include?(m) rescue true)
+            next unless m.respond_to?(:instance_methods) # JRuby has modules that represent java packages. They don't include many common ruby methods
             candidates.concat m.instance_methods(false).collect{|x| x.to_s}
           }
           candidates.sort!
           candidates.uniq!
         end
+
         if doc_namespace
           rec_class = rec.is_a?(Module) ? rec : rec.class
           "#{rec_class.name}#{sep}#{candidates.find{ |i| i == message }}"
@@ -370,10 +382,11 @@ module IRB
         message = $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)
+          select_message(receiver, message, candidates.sort)
         end
 
       else
@@ -390,7 +403,7 @@ module IRB
         else
           candidates = (bind.eval_methods | bind.eval_private_methods | bind.local_variables | bind.eval_instance_variables | bind.eval_class_constants).collect{|m| m.to_s}
           candidates |= ReservedWords
-          candidates.grep(/^#{Regexp.quote(input)}/)
+          candidates.grep(/^#{Regexp.quote(input)}/).sort
         end
       end
     end

data/lib/irb/context.rb

@@ -49,12 +49,15 @@ module IRB
       if IRB.conf.has_key?(:USE_MULTILINE)
         @use_multiline = IRB.conf[:USE_MULTILINE]
       elsif IRB.conf.has_key?(:USE_RELINE) # backward compatibility
+        warn <<~MSG.strip
+          USE_RELINE is deprecated, please use USE_MULTILINE instead.
+        MSG
         @use_multiline = IRB.conf[:USE_RELINE]
       elsif IRB.conf.has_key?(:USE_REIDLINE)
         warn <<~MSG.strip
-          USE_REIDLINE is deprecated, please use USE_RELINE instead.
+          USE_REIDLINE is deprecated, please use USE_MULTILINE instead.
         MSG
-        @use_multiline = IRB.conf[:USE_RELINE]
+        @use_multiline = IRB.conf[:USE_REIDLINE]
       else
         @use_multiline = nil
       end
@@ -149,6 +152,8 @@ module IRB
       if @newline_before_multiline_output.nil?
         @newline_before_multiline_output = true
       end
+
+      @command_aliases = IRB.conf[:COMMAND_ALIASES]
     end
 
     # The top-level workspace, see WorkSpace#main
@@ -326,6 +331,9 @@ module IRB
     # See IRB@Command+line+options for more command line options.
     attr_accessor :back_trace_limit
 
+    # User-defined IRB command aliases
+    attr_accessor :command_aliases
+
     # Alias for #use_multiline
     alias use_multiline? use_multiline
     # Alias for #use_singleline
@@ -477,6 +485,20 @@ module IRB
         line = "begin ::Kernel.raise _; rescue _.class\n#{line}\n""end"
         @workspace.local_variable_set(:_, exception)
       end
+
+      # Transform a non-identifier alias (@, $) or keywords (next, break)
+      command, args = line.split(/\s/, 2)
+      if original = command_aliases[command.to_sym]
+        line = line.gsub(/\A#{Regexp.escape(command)}/, original.to_s)
+        command = original
+      end
+
+      # Hook command-specific transformation
+      command_class = ExtendCommandBundle.load_command(command)
+      if command_class&.respond_to?(:transform_args)
+        line = "#{command} #{command_class.transform_args(args)}"
+      end
+
       set_last_value(@workspace.evaluate(self, line, irb_path, line_no))
     end
 
@@ -518,5 +540,21 @@ module IRB
     end
     alias __to_s__ to_s
     alias to_s inspect
+
+    def local_variables # :nodoc:
+      workspace.binding.local_variables
+    end
+
+    # Return true if it's aliased from the argument and it's not an identifier.
+    def symbol_alias?(command)
+      return nil if command.match?(/\A\w+\z/)
+      command_aliases.key?(command.to_sym)
+    end
+
+    # Return true if the command supports transforming args
+    def transform_args?(command)
+      command = command_aliases.fetch(command.to_sym, command)
+      ExtendCommandBundle.load_command(command)&.respond_to?(:transform_args)
+    end
   end
 end

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

@@ -70,10 +70,10 @@ module IRB
       end
       history_file = IRB.rc_file("_history") unless history_file
       if File.exist?(history_file)
-        open(history_file, "r:#{IRB.conf[:LC_MESSAGES].encoding}") do |f|
+        File.open(history_file, "r:#{IRB.conf[:LC_MESSAGES].encoding}") do |f|
           f.each { |l|
             l = l.chomp
-            if self.class == ReidlineInputMethod and history.last&.end_with?("\\")
+            if self.class == RelineInputMethod and history.last&.end_with?("\\")
               history.last.delete_suffix!("\\")
               history.last << "\n" << l
             else