irb 1.7.1 → 1.13.2

data/lib/irb/command/chws.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+#
+#   change-ws.rb -
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+require_relative "../ext/change-ws"
+
+module IRB
+  # :stopdoc:
+
+  module Command
+
+    class CurrentWorkingWorkspace < Base
+      category "Workspace"
+      description "Show the current workspace."
+
+      def execute(_arg)
+        puts "Current workspace: #{irb_context.main}"
+      end
+    end
+
+    class ChangeWorkspace < Base
+      category "Workspace"
+      description "Change the current workspace to an object."
+
+      def execute(arg)
+        if arg.empty?
+          irb_context.change_workspace
+        else
+          obj = eval(arg, irb_context.workspace.binding)
+          irb_context.change_workspace(obj)
+        end
+
+        puts "Current workspace: #{irb_context.main}"
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/command/context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module IRB
+  module Command
+    class Context < Base
+      category "IRB"
+      description "Displays current configuration."
+
+      def execute(_arg)
+        # This command just displays the configuration.
+        # Modifying the configuration is achieved by sending a message to IRB.conf.
+        Pager.page_content(IRB.CurrentContext.inspect)
+      end
+    end
+  end
+end

data/lib/irb/{cmd → command}/continue.rb

@@ -5,10 +5,10 @@ require_relative "debug"
 module IRB
   # :stopdoc:
 
-  module ExtendCommand
+  module Command
     class Continue < DebugCommand
-      def execute(*args)
-        super(do_cmds: ["continue", *args].join(" "))
+      def execute(arg)
+        execute_debug_command(do_cmds: "continue #{arg}")
       end
     end
   end

data/lib/irb/command/debug.rb

@@ -0,0 +1,71 @@
+require_relative "../debug"
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class Debug < Base
+      category "Debugging"
+      description "Start the debugger of debug.gem."
+
+      def execute(_arg)
+        execute_debug_command
+      end
+
+      def execute_debug_command(pre_cmds: nil, do_cmds: nil)
+        pre_cmds = pre_cmds&.rstrip
+        do_cmds = do_cmds&.rstrip
+
+        if irb_context.with_debugger
+          # If IRB is already running with a debug session, throw the command and IRB.debug_readline will pass it to the debugger.
+          if cmd = pre_cmds || do_cmds
+            throw :IRB_EXIT, cmd
+          else
+            puts "IRB is already running with a debug session."
+            return
+          end
+        else
+          # If IRB is not running with a debug session yet, then:
+          # 1. Check if the debugging command is run from a `binding.irb` call.
+          # 2. If so, try setting up the debug gem.
+          # 3. Insert a debug breakpoint at `Irb#debug_break` with the intended command.
+          # 4. Exit the current Irb#run call via `throw :IRB_EXIT`.
+          # 5. `Irb#debug_break` will be called and trigger the breakpoint, which will run the intended command.
+          unless irb_context.from_binding?
+            puts "Debugging commands are only available when IRB is started with binding.irb"
+            return
+          end
+
+          if IRB.respond_to?(:JobManager)
+            warn "Can't start the debugger when IRB is running in a multi-IRB session."
+            return
+          end
+
+          unless IRB::Debug.setup(irb_context.irb)
+            puts <<~MSG
+              You need to install the debug gem before using this command.
+              If you use `bundle exec`, please add `gem "debug"` into your Gemfile.
+            MSG
+            return
+          end
+
+          IRB::Debug.insert_debug_break(pre_cmds: pre_cmds, do_cmds: do_cmds)
+
+          # exit current Irb#run call
+          throw :IRB_EXIT
+        end
+      end
+    end
+
+    class DebugCommand < Debug
+      def self.category
+        "Debugging"
+      end
+
+      def self.description
+        command_name = self.name.split("::").last.downcase
+        "Start the debugger of debug.gem and run its `#{command_name}` command."
+      end
+    end
+  end
+end

data/lib/irb/{cmd → command}/delete.rb

@@ -5,10 +5,10 @@ require_relative "debug"
 module IRB
   # :stopdoc:
 
-  module ExtendCommand
+  module Command
     class Delete < DebugCommand
-      def execute(*args)
-        super(pre_cmds: ["delete", *args].join(" "))
+      def execute(arg)
+        execute_debug_command(pre_cmds: "delete #{arg}")
       end
     end
   end

data/lib/irb/command/disable_irb.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class DisableIrb < Base
+      category "IRB"
+      description "Disable binding.irb."
+
+      def execute(*)
+        ::Binding.define_method(:irb) {}
+        IRB.irb_exit
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/command/edit.rb

@@ -0,0 +1,63 @@
+require 'shellwords'
+
+require_relative "../color"
+require_relative "../source_finder"
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class Edit < Base
+      include RubyArgsExtractor
+
+      category "Misc"
+      description 'Open a file or source location.'
+      help_message <<~HELP_MESSAGE
+        Usage: edit [FILE or constant or method signature]
+
+        Open a file in the editor specified in #{highlight('ENV["VISUAL"]')} or #{highlight('ENV["EDITOR"]')}
+
+        - If no arguments are provided, IRB will attempt to open the file the current context was defined in.
+        - If FILE is provided, IRB will open the file.
+        - If a constant or method signature is provided, IRB will attempt to locate the source file and open it.
+
+        Examples:
+
+          edit
+          edit foo.rb
+          edit Foo
+          edit Foo#bar
+      HELP_MESSAGE
+
+      def execute(arg)
+        # Accept string literal for backward compatibility
+        path = unwrap_string_literal(arg)
+
+        if path.nil?
+          path = @irb_context.irb_path
+        elsif !File.exist?(path)
+          source = SourceFinder.new(@irb_context).find_source(path)
+
+          if source&.file_exist? && !source.binary_file?
+            path = source.file
+          end
+        end
+
+        unless File.exist?(path)
+          puts "Can not find file: #{path}"
+          return
+        end
+
+        if editor = (ENV['VISUAL'] || ENV['EDITOR'])
+          puts "command: '#{editor}'"
+          puts "   path: #{path}"
+          system(*Shellwords.split(editor), path)
+        else
+          puts "Can not find editor setting: ENV['VISUAL'] or ENV['EDITOR']"
+        end
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/command/exit.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class Exit < Base
+      category "IRB"
+      description "Exit the current irb session."
+
+      def execute(_arg)
+        IRB.irb_exit
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/{cmd → command}/finish.rb

@@ -5,10 +5,10 @@ require_relative "debug"
 module IRB
   # :stopdoc:
 
-  module ExtendCommand
+  module Command
     class Finish < DebugCommand
-      def execute(*args)
-        super(do_cmds: ["finish", *args].join(" "))
+      def execute(arg)
+        execute_debug_command(do_cmds: "finish #{arg}")
       end
     end
   end

data/lib/irb/command/force_exit.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class ForceExit < Base
+      category "IRB"
+      description "Exit the current process."
+
+      def execute(_arg)
+        throw :IRB_EXIT, true
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/command/help.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module IRB
+  module Command
+    class Help < Base
+      category "Help"
+      description "List all available commands. Use `help <command>` to get information about a specific command."
+
+      def execute(command_name)
+        content =
+          if command_name.empty?
+            help_message
+          else
+            if command_class = Command.load_command(command_name)
+              command_class.help_message || command_class.description
+            else
+              "Can't find command `#{command_name}`. Please check the command name and try again.\n\n"
+            end
+          end
+        Pager.page_content(content)
+      end
+
+      private
+
+      def help_message
+        commands_info = IRB::Command.all_commands_info
+        helper_methods_info = IRB::HelperMethod.all_helper_methods_info
+        commands_grouped_by_categories = commands_info.group_by { |cmd| cmd[:category] }
+        commands_grouped_by_categories["Helper methods"] = helper_methods_info
+
+        if irb_context.with_debugger
+          # Remove the original "Debugging" category
+          commands_grouped_by_categories.delete("Debugging")
+        end
+
+        longest_cmd_name_length = commands_info.map { |c| c[:display_name].length }.max
+
+        output = StringIO.new
+
+        help_cmds = commands_grouped_by_categories.delete("Help")
+        no_category_cmds = commands_grouped_by_categories.delete("No category")
+        aliases = irb_context.instance_variable_get(:@user_aliases).map do |alias_name, target|
+          { display_name: alias_name, description: "Alias for `#{target}`" }
+        end
+
+        # Display help commands first
+        add_category_to_output("Help", help_cmds, output, longest_cmd_name_length)
+
+        # Display the rest of the commands grouped by categories
+        commands_grouped_by_categories.each do |category, cmds|
+          add_category_to_output(category, cmds, output, longest_cmd_name_length)
+        end
+
+        # Display commands without a category
+        if no_category_cmds
+          add_category_to_output("No category", no_category_cmds, output, longest_cmd_name_length)
+        end
+
+        # Display aliases
+        add_category_to_output("Aliases", aliases, output, longest_cmd_name_length)
+
+        # Append the debugger help at the end
+        if irb_context.with_debugger
+          # Add "Debugging (from debug.gem)" category as title
+          add_category_to_output("Debugging (from debug.gem)", [], output, longest_cmd_name_length)
+          output.puts DEBUGGER__.help
+        end
+
+        output.string
+      end
+
+      def add_category_to_output(category, cmds, output, longest_cmd_name_length)
+        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
+    end
+  end
+end

data/lib/irb/command/history.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+require_relative "../pager"
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class History < Base
+      category "IRB"
+      description "Shows the input history. `-g [query]` or `-G [query]` allows you to filter the output."
+
+      def execute(arg)
+
+        if (match = arg&.match(/(-g|-G)\s+(?<grep>.+)\s*\n\z/))
+          grep = Regexp.new(match[:grep])
+        end
+
+        formatted_inputs = irb_context.io.class::HISTORY.each_with_index.reverse_each.filter_map do |input, index|
+          next if grep && !input.match?(grep)
+
+          header = "#{index}: "
+
+          first_line, *other_lines = input.split("\n")
+          first_line = "#{header}#{first_line}"
+
+          truncated_lines = other_lines.slice!(1..) # Show 1 additional line (2 total)
+          other_lines << "..." if truncated_lines&.any?
+
+          other_lines.map! do |line|
+            " " * header.length + line
+          end
+
+          [first_line, *other_lines].join("\n") + "\n"
+        end
+
+        Pager.page_content(formatted_inputs.join)
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/command/info.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module Command
+    class Info < DebugCommand
+      def execute(arg)
+        execute_debug_command(pre_cmds: "info #{arg}")
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/command/internal_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module IRB
+  module Command
+    # Internal use only, for default command's backward compatibility.
+    module RubyArgsExtractor # :nodoc:
+      def unwrap_string_literal(str)
+        return if str.empty?
+
+        sexp = Ripper.sexp(str)
+        if sexp && sexp.size == 2 && sexp.last&.first&.first == :string_literal
+          @irb_context.workspace.binding.eval(str).to_s
+        else
+          str
+        end
+      end
+
+      def ruby_args(arg)
+        # Use throw and catch to handle arg that includes `;`
+        # For example: "1, kw: (2; 3); 4" will be parsed to [[1], { kw: 3 }]
+        catch(:EXTRACT_RUBY_ARGS) do
+          @irb_context.workspace.binding.eval "IRB::Command.extract_ruby_args #{arg}"
+        end || [[], {}]
+      end
+    end
+  end
+end

data/lib/irb/{cmd → command}/irb_info.rb

@@ -1,20 +1,20 @@
-# frozen_string_literal: false
-
-require_relative "nop"
+# frozen_string_literal: true
 
 module IRB
   # :stopdoc:
 
-  module ExtendCommand
-    class IrbInfo < Nop
+  module Command
+    class IrbInfo < Base
       category "IRB"
       description "Show information about IRB."
 
-      def execute
+      def execute(_arg)
         str  = "Ruby version: #{RUBY_VERSION}\n"
         str += "IRB version: #{IRB.version}\n"
         str += "InputMethod: #{IRB.CurrentContext.io.inspect}\n"
-        str += ".irbrc path: #{IRB.rc_file}\n" if File.exist?(IRB.rc_file)
+        str += "Completion: #{IRB.CurrentContext.io.respond_to?(:completion_info) ? IRB.CurrentContext.io.completion_info : 'off'}\n"
+        rc_files = IRB.irbrc_files
+        str += ".irbrc paths: #{rc_files.join(", ")}\n" if rc_files.any?
         str += "RUBY_PLATFORM: #{RUBY_PLATFORM}\n"
         str += "LANG env: #{ENV["LANG"]}\n" if ENV["LANG"] && !ENV["LANG"].empty?
         str += "LC_ALL env: #{ENV["LC_ALL"]}\n" if ENV["LC_ALL"] && !ENV["LC_ALL"].empty?

data/lib/irb/{cmd → command}/load.rb

@@ -1,17 +1,16 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 #
 #   load.rb -
 #   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
 #
-
-require_relative "nop"
 require_relative "../ext/loader"
 
 module IRB
   # :stopdoc:
 
-  module ExtendCommand
-    class LoaderCommand < Nop
+  module Command
+    class LoaderCommand < Base
+      include RubyArgsExtractor
       include IrbLoader
 
       def raise_cmd_argument_error
@@ -23,7 +22,12 @@ module IRB
       category "IRB"
       description "Load a Ruby file."
 
-      def execute(file_name = nil, priv = nil)
+      def execute(arg)
+        args, kwargs = ruby_args(arg)
+        execute_internal(*args, **kwargs)
+      end
+
+      def execute_internal(file_name = nil, priv = nil)
         raise_cmd_argument_error unless file_name
         irb_load(file_name, priv)
       end
@@ -32,7 +36,13 @@ module IRB
     class Require < LoaderCommand
       category "IRB"
       description "Require a Ruby file."
-      def execute(file_name = nil)
+
+      def execute(arg)
+        args, kwargs = ruby_args(arg)
+        execute_internal(*args, **kwargs)
+      end
+
+      def execute_internal(file_name = nil)
         raise_cmd_argument_error unless file_name
 
         rex = Regexp.new("#{Regexp.quote(file_name)}(\.o|\.rb)?")
@@ -65,7 +75,12 @@ module IRB
       category "IRB"
       description "Loads a given file in the current session."
 
-      def execute(file_name = nil)
+      def execute(arg)
+        args, kwargs = ruby_args(arg)
+        execute_internal(*args, **kwargs)
+      end
+
+      def execute_internal(file_name = nil)
         raise_cmd_argument_error unless file_name
 
         source_file(file_name)

data/lib/irb/{cmd → command}/ls.rb

@@ -1,39 +1,57 @@
 # frozen_string_literal: true
 
 require "reline"
-require_relative "nop"
+require "stringio"
+
+require_relative "../pager"
 require_relative "../color"
 
 module IRB
   # :stopdoc:
 
-  module ExtendCommand
-    class Ls < Nop
+  module Command
+    class Ls < Base
+      include RubyArgsExtractor
+
       category "Context"
-      description "Show methods, constants, and variables. `-g [query]` or `-G [query]` allows you to filter out the output."
+      description "Show methods, constants, and variables."
+
+      help_message <<~HELP_MESSAGE
+        Usage: ls [obj] [-g [query]]
 
-      def self.transform_args(args)
-        if match = args&.match(/\A(?<args>.+\s|)(-g|-G)\s+(?<grep>[^\s]+)\s*\n\z/)
-          args = match[:args]
-          "#{args}#{',' unless args.chomp.empty?} grep: /#{match[:grep]}/"
+          -g [query]  Filter the output with a query.
+      HELP_MESSAGE
+
+      def execute(arg)
+        if match = arg.match(/\A(?<target>.+\s|)(-g|-G)\s+(?<grep>.+)$/)
+          if match[:target].empty?
+            use_main = true
+          else
+            obj = @irb_context.workspace.binding.eval(match[:target])
+          end
+          grep = Regexp.new(match[:grep])
         else
-          args
+          args, kwargs = ruby_args(arg)
+          use_main = args.empty?
+          obj = args.first
+          grep = kwargs[:grep]
+        end
+
+        if use_main
+          obj = irb_context.workspace.main
+          locals = irb_context.workspace.binding.local_variables
         end
-      end
 
-      def execute(*arg, grep: nil)
         o = Output.new(grep: grep)
 
-        obj    = arg.empty? ? irb_context.workspace.main : arg.first
-        locals = arg.empty? ? irb_context.workspace.binding.local_variables : []
         klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)
 
         o.dump("constants", obj.constants) if obj.respond_to?(:constants)
         dump_methods(o, klass, obj)
         o.dump("instance variables", obj.instance_variables)
         o.dump("class variables", klass.class_variables)
-        o.dump("locals", locals)
-        nil
+        o.dump("locals", locals) if locals
+        o.print_result
       end
 
       def dump_methods(o, klass, obj)
@@ -77,6 +95,11 @@ module IRB
         def initialize(grep: nil)
           @grep = grep
           @line_width = screen_width - MARGIN.length # right padding
+          @io = StringIO.new
+        end
+
+        def print_result
+          Pager.page_content(@io.string)
         end
 
         def dump(name, strs)
@@ -85,12 +108,12 @@ module IRB
           return if strs.empty?
 
           # Attempt a single line
-          print "#{Color.colorize(name, [:BOLD, :BLUE])}: "
+          @io.print "#{Color.colorize(name, [:BOLD, :BLUE])}: "
           if fits_on_line?(strs, cols: strs.size, offset: "#{name}: ".length)
-            puts strs.join(MARGIN)
+            @io.puts strs.join(MARGIN)
             return
           end
-          puts
+          @io.puts
 
           # Dump with the largest # of columns that fits on a line
           cols = strs.size
@@ -99,7 +122,7 @@ module IRB
           end
           widths = col_widths(strs, cols: cols)
           strs.each_slice(cols) do |ss|
-            puts ss.map.with_index { |s, i| "#{MARGIN}%-#{widths[i]}s" % s }.join
+            @io.puts ss.map.with_index { |s, i| "#{MARGIN}%-#{widths[i]}s" % s }.join
           end
         end