irb 1.4.3 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 025d4dccc426fe09dc77b79d7efb8157abc559b89a7455249e5d7e9b2ff1562c
-  data.tar.gz: fd2cffe5c013c56a5d454ce81331ac1c24b6826c81db6ae6f2240e6e2d5f8c06
+  metadata.gz: e7dc14606c6de90f8f56048a7ec6f8ca2bc83a8d4e0aa50d60dbe84141389601
+  data.tar.gz: bca1a92ee2088e483073d48dd9e0b3cdbf9b8d67768ed3fd922bb7e91da68039
 SHA512:
-  metadata.gz: 582d9176beb3f3b9a016f6d44b90b9d781066230f4c64dec93ba5d645ae54df8f7f6f1a5dcaab20899390cd048050eaed6db9b45fdcf44c55a57098013855aa9
-  data.tar.gz: ab9b30b770c677778cc4871b249a0967177805e543bd8576077099be7d3a5d93e2ef33c35362326cd7f889cd1f855d956c2cb9bd992560029e152c6293720a94
+  metadata.gz: b44c813a4fc0010423d0e7ac189dc264ea92587db1b05e16e6c8ec49ff20bc2b4c18b5cfa454543b7d894be0b6610c96a3bf17b85b31d9083d962665063c8a85
+  data.tar.gz: af7f077aa6b2c67ccbe67209a35e622bff087a28615b3086a0511188da1b09d2284b662d659d3b308bf251488547aeaecf9da2b29454c2031d52c0e902ba7889

data/Gemfile

@@ -11,4 +11,5 @@ group :development do
   gem "stackprof" if is_unix && !is_truffleruby
   gem "test-unit"
   gem "reline", github: "ruby/reline" if ENV["WITH_LATEST_RELINE"] == "true"
+  gem "debug"
 end

data/README.md

@@ -40,6 +40,59 @@ irb(main):006:1> end
 
 The Readline extension module can be used with irb. Use of Readline is default if it's installed.
 
+## Commands
+
+The following commands are available on IRB.
+
+* `cwws`
+  * Show the current workspace.
+* `cb`, `cws`, `chws`
+  * Change the current workspace to an object.
+* `bindings`, `workspaces`
+  * Show workspaces.
+* `edit`
+  * Open a file with the editor command defined with `ENV["EDITOR"]`
+    * `edit` - opens the file the current context belongs to (if applicable)
+    * `edit foo.rb` - opens `foo.rb`
+    * `edit Foo` - opens the location of `Foo`
+    * `edit Foo.bar` - opens the location of `Foo.bar`
+    * `edit Foo#bar` - opens the location of `Foo#bar`
+* `pushb`, `pushws`
+  * Push an object to the workspace stack.
+* `popb`, `popws`
+  * Pop a workspace from the workspace stack.
+* `load`
+  * Load a Ruby file.
+* `require`
+  * Require a Ruby file.
+* `source`
+  * Loads a given file in the current session.
+* `irb`
+  * Start a child IRB.
+* `jobs`
+  * List of current sessions.
+* `fg`
+  * Switches to the session of the given number.
+* `kill`
+  * Kills the session with the given number.
+* `help`
+  * Enter the mode to look up RI documents.
+* `irb_info`
+  * Show information about IRB.
+* `ls`
+  * Show methods, constants, and variables.
+    `-g [query]` or `-G [query]` allows you to filter out the output.
+* `measure`
+  * `measure` enables the mode to measure processing time. `measure :off` disables it.
+* `$`, `show_source`
+  * Show the source code of a given method or constant.
+* `@`, `whereami`
+  * Show the source code around binding.irb again.
+* `debug`
+  * Start the debugger of debug.gem.
+* `break`, `delete`, `next`, `step`, `continue`, `finish`, `backtrace`, `info`, `catch`
+  * Start the debugger of debug.gem and run the command on it.
+
 ## Documentation
 
 https://docs.ruby-lang.org/en/master/IRB.html
@@ -54,6 +107,13 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/irb.
 
+## Releasing
+
+```
+rake release
+gh release create vX.Y.Z --generate-notes
+```
+
 ## License
 
 The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/lib/irb/cmd/backtrace.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Backtrace < Debug
+      def self.transform_args(args)
+        args&.dump
+      end
+
+      def execute(*args)
+        super(pre_cmds: ["backtrace", *args].join(" "))
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/break.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Break < Debug
+      def self.transform_args(args)
+        args&.dump
+      end
+
+      def execute(args = nil)
+        super(pre_cmds: "break #{args}")
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/catch.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Catch < Debug
+      def self.transform_args(args)
+        args&.dump
+      end
+
+      def execute(*args)
+        super(pre_cmds: ["catch", *args].join(" "))
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/continue.rb

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

data/lib/irb/cmd/debug.rb

@@ -0,0 +1,112 @@
+require_relative "nop"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Debug < Nop
+      BINDING_IRB_FRAME_REGEXPS = [
+        '<internal:prelude>',
+        binding.method(:irb).source_location.first,
+      ].map { |file| /\A#{Regexp.escape(file)}:\d+:in `irb'\z/ }
+      IRB_DIR = File.expand_path('..', __dir__)
+
+      def execute(pre_cmds: nil, do_cmds: nil)
+        unless binding_irb?
+          puts "`debug` command is only available when IRB is started with binding.irb"
+          return
+        end
+
+        unless setup_debugger
+          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
+
+        options = { oneshot: true, hook_call: false }
+        if pre_cmds || do_cmds
+          options[:command] = ['irb', pre_cmds, do_cmds]
+        end
+        if DEBUGGER__::LineBreakpoint.instance_method(:initialize).parameters.include?([:key, :skip_src])
+          options[:skip_src] = true
+        end
+
+        # To make debugger commands like `next` or `continue` work without asking
+        # the user to quit IRB after that, we need to exit IRB first and then hit
+        # a TracePoint on #debug_break.
+        file, lineno = IRB::Irb.instance_method(:debug_break).source_location
+        DEBUGGER__::SESSION.add_line_breakpoint(file, lineno + 1, **options)
+        # exit current Irb#run call
+        throw :IRB_EXIT
+      end
+
+      private
+
+      def binding_irb?
+        caller.any? do |frame|
+          BINDING_IRB_FRAME_REGEXPS.any? do |regexp|
+            frame.match?(regexp)
+          end
+        end
+      end
+
+      def setup_debugger
+        unless defined?(DEBUGGER__::SESSION)
+          begin
+            require "debug/session"
+          rescue LoadError # debug.gem is not written in Gemfile
+            return false unless load_bundled_debug_gem
+          end
+          DEBUGGER__.start(nonstop: true)
+        end
+
+        unless DEBUGGER__.respond_to?(:capture_frames_without_irb)
+          DEBUGGER__.singleton_class.send(:alias_method, :capture_frames_without_irb, :capture_frames)
+
+          def DEBUGGER__.capture_frames(*args)
+            frames = capture_frames_without_irb(*args)
+            frames.reject! do |frame|
+              frame.realpath&.start_with?(IRB_DIR) || frame.path == "<internal:prelude>"
+            end
+            frames
+          end
+        end
+
+        true
+      end
+
+      # This is used when debug.gem is not written in Gemfile. Even if it's not
+      # installed by `bundle install`, debug.gem is installed by default because
+      # it's a bundled gem. This method tries to activate and load that.
+      def load_bundled_debug_gem
+        # Discover latest debug.gem under GEM_PATH
+        debug_gem = Gem.paths.path.flat_map { |path| Dir.glob("#{path}/gems/debug-*") }.select do |path|
+          File.basename(path).match?(/\Adebug-\d+\.\d+\.\d+(\w+)?\z/)
+        end.sort_by do |path|
+          Gem::Version.new(File.basename(path).delete_prefix('debug-'))
+        end.last
+        return false unless debug_gem
+
+        # Discover debug/debug.so under extensions for Ruby 3.2+
+        debug_so = Gem.paths.path.flat_map do |path|
+          Dir.glob("#{path}/extensions/**/#{File.basename(debug_gem)}/debug/debug.so")
+        end.first
+
+        # Attempt to forcibly load the bundled gem
+        if debug_so
+          $LOAD_PATH << debug_so.delete_suffix('/debug/debug.so')
+        end
+        $LOAD_PATH << "#{debug_gem}/lib"
+        begin
+          require "debug/session"
+          puts "Loaded #{File.basename(debug_gem)}"
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/irb/cmd/delete.rb

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

data/lib/irb/cmd/edit.rb

@@ -0,0 +1,65 @@
+require 'shellwords'
+require_relative "nop"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Edit < Nop
+      class << self
+        def transform_args(args)
+          # Return a string literal as is for backward compatibility
+          if args.nil? || args.empty? || string_literal?(args)
+            args
+          else # Otherwise, consider the input as a String for convenience
+            args.strip.dump
+          end
+        end
+
+        private
+
+        def string_literal?(args)
+          sexp = Ripper.sexp(args)
+          sexp && sexp.size == 2 && sexp.last&.first&.first == :string_literal
+        end
+      end
+
+      def execute(*args)
+        path = args.first
+
+        if path.nil? && (irb_path = @irb_context.irb_path)
+          path = irb_path
+        end
+
+        if !File.exist?(path)
+          require_relative "show_source"
+
+          source =
+            begin
+              ShowSource.find_source(path, @irb_context)
+            rescue NameError
+              # if user enters a path that doesn't exist, it'll cause NameError when passed here because find_source would try to evaluate it as well
+              # in this case, we should just ignore the error
+            end
+
+          if source && File.exist?(source.file)
+            path = source.file
+          else
+            puts "Can not find file: #{path}"
+            return
+          end
+        end
+
+        if editor = ENV['EDITOR']
+          puts "command: '#{editor}'"
+          puts "   path: #{path}"
+          system(*Shellwords.split(editor), path)
+        else
+          puts "Can not find editor setting: ENV['EDITOR']"
+        end
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/finish.rb

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

data/lib/irb/cmd/info.rb

@@ -1,31 +1,18 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 
-require_relative "nop"
+require_relative "debug"
 
 module IRB
   # :stopdoc:
 
   module ExtendCommand
-    class Info < Nop
-      def execute
-        Class.new {
-          def inspect
-            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 += "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?
-            str += "East Asian Ambiguous Width: #{Reline.ambiguous_width.inspect}\n"
-            if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-              codepage = `chcp`.b.sub(/.*: (\d+)\n/, '\1')
-              str += "Code page: #{codepage}\n"
-            end
-            str
-          end
-          alias_method :to_s, :inspect
-        }.new
+    class Info < Debug
+      def self.transform_args(args)
+        args&.dump
+      end
+
+      def execute(*args)
+        super(pre_cmds: ["info", *args].join(" "))
       end
     end
   end

data/lib/irb/cmd/irb_info.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: false
+
+require_relative "nop"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class IrbInfo < Nop
+      def execute
+        Class.new {
+          def inspect
+            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 += "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?
+            str += "East Asian Ambiguous Width: #{Reline.ambiguous_width.inspect}\n"
+            if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+              codepage = `chcp`.b.sub(/.*: (\d+)\n/, '\1')
+              str += "Code page: #{codepage}\n"
+            end
+            str
+          end
+          alias_method :to_s, :inspect
+        }.new
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/next.rb

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

data/lib/irb/cmd/show_source.rb

@@ -19,8 +19,50 @@ module IRB
           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
+
         def string_literal?(args)
           sexp = Ripper.sexp(args)
           sexp && sexp.size == 2 && sexp.last&.first&.first == :string_literal
@@ -32,7 +74,8 @@ module IRB
           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
@@ -53,48 +96,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,18 @@
+# frozen_string_literal: true
+
+require_relative "debug"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class Step < Debug
+      def execute(*args)
+        # Run `next` first to move out of binding.irb
+        super(pre_cmds: "next", do_cmds: ["step", *args].join(" "))
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/context.rb

@@ -486,9 +486,9 @@ module IRB
         @workspace.local_variable_set(:_, exception)
       end
 
-      # Transform a non-identifier alias (ex: @, $)
+      # Transform a non-identifier alias (@, $) or keywords (next, break)
       command, args = line.split(/\s/, 2)
-      if original = symbol_alias(command)
+      if original = command_aliases[command.to_sym]
         line = line.gsub(/\A#{Regexp.escape(command)}/, original.to_s)
         command = original
       end
@@ -545,10 +545,16 @@ module IRB
       workspace.binding.local_variables
     end
 
-    # Return a command name if it's aliased from the argument and it's not an identifier.
-    def symbol_alias(command)
+    # 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[command.to_sym]
+      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/extend-command.rb

@@ -116,13 +116,56 @@ module IRB # :nodoc:
         [:kill, OVERRIDE_PRIVATE_ONLY],
       ],
 
+      [
+        :irb_debug, :Debug, "cmd/debug",
+        [:debug, NO_OVERRIDE],
+      ],
+      [
+        :irb_edit, :Edit, "cmd/edit",
+        [:edit, NO_OVERRIDE],
+      ],
+      [
+        :irb_break, :Break, "cmd/break",
+      ],
+      [
+        :irb_catch, :Catch, "cmd/catch",
+      ],
+      [
+        :irb_next, :Next, "cmd/next",
+      ],
+      [
+        :irb_delete, :Delete, "cmd/delete",
+        [:delete, NO_OVERRIDE],
+      ],
+      [
+        :irb_step, :Step, "cmd/step",
+        [:step, NO_OVERRIDE],
+      ],
+      [
+        :irb_continue, :Continue, "cmd/continue",
+        [:continue, NO_OVERRIDE],
+      ],
+      [
+        :irb_finish, :Finish, "cmd/finish",
+        [:finish, NO_OVERRIDE],
+      ],
+      [
+        :irb_backtrace, :Backtrace, "cmd/backtrace",
+        [:backtrace, NO_OVERRIDE],
+        [:bt, NO_OVERRIDE],
+      ],
+      [
+        :irb_debug_info, :Info, "cmd/info",
+        [:info, NO_OVERRIDE],
+      ],
+
       [
         :irb_help, :Help, "cmd/help",
         [:help, NO_OVERRIDE],
       ],
 
       [
-        :irb_info, :Info, "cmd/info"
+        :irb_info, :IrbInfo, "cmd/irb_info"
       ],
 
       [
@@ -161,26 +204,7 @@ module IRB # :nodoc:
       nil
     end
 
-    # Installs the default irb commands:
-    #
-    # +irb_current_working_workspace+::   Context#main
-    # +irb_change_workspace+::            Context#change_workspace
-    # +irb_workspaces+::                  Context#workspaces
-    # +irb_push_workspace+::              Context#push_workspace
-    # +irb_pop_workspace+::               Context#pop_workspace
-    # +irb_load+::                        #irb_load
-    # +irb_require+::                     #irb_require
-    # +irb_source+::                      IrbLoader#source_file
-    # +irb+::                             IRB.irb
-    # +irb_jobs+::                        JobManager
-    # +irb_fg+::                          JobManager#switch
-    # +irb_kill+::                        JobManager#kill
-    # +irb_help+::                        IRB@Command+line+options
-    # +irb_info+::                        #inspect
-    # +irb_ls+::                          Output#dump
-    # +irb_measure+::                     IRB::unset_measure_callback
-    # +irb_show_source+::                 #find_source, #show_source
-    # +irb_whereami+::                    Workspace#code_around_binding
+    # Installs the default irb commands.
     def self.install_extend_commands
       for args in @EXTEND_COMMANDS
         def_extend_command(*args)

data/lib/irb/init.rb

@@ -160,8 +160,13 @@ module IRB # :nodoc:
     @CONF[:AT_EXIT] = []
 
     @CONF[:COMMAND_ALIASES] = {
+      # Symbol aliases
       :'$' => :show_source,
       :'@' => :whereami,
+      # Keyword aliases
+      :break => :irb_break,
+      :catch => :irb_catch,
+      :next => :irb_next,
     }
   end
 

data/lib/irb/ruby-lex.rb

@@ -65,9 +65,9 @@ class RubyLex
             false
           end
         else
-          # Accept any single-line input starting with a non-identifier alias (ex: @, $)
+          # Accept any single-line input for symbol aliases or commands that transform args
           command = code.split(/\s/, 2).first
-          if context.symbol_alias(command)
+          if context.symbol_alias?(command) || context.transform_args?(command)
             next true
           end
 

data/lib/irb/version.rb

@@ -11,7 +11,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.4.3"
+  VERSION = "1.5.1"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2022-11-17"
+  @LAST_UPDATE_DATE = "2022-11-28"
 end

data/lib/irb.rb

@@ -53,6 +53,52 @@ require_relative "irb/easter-egg"
 #
 #   :include: ./irb/lc/help-message
 #
+# == Commands
+#
+# The following commands are available on IRB.
+#
+# * cwws
+#   * Show the current workspace.
+# * cb, cws, chws
+#   * Change the current workspace to an object.
+# * bindings, workspaces
+#   * Show workspaces.
+# * pushb, pushws
+#   * Push an object to the workspace stack.
+# * popb, popws
+#   * Pop a workspace from the workspace stack.
+# * load
+#   * Load a Ruby file.
+# * require
+#   * Require a Ruby file.
+# * source
+#   * Loads a given file in the current session.
+# * irb
+#   * Start a child IRB.
+# * jobs
+#   * List of current sessions.
+# * fg
+#   * Switches to the session of the given number.
+# * kill
+#   * Kills the session with the given number.
+# * help
+#   * Enter the mode to look up RI documents.
+# * irb_info
+#   * Show information about IRB.
+# * ls
+#   * Show methods, constants, and variables.
+#     -g [query] or -G [query] allows you to filter out the output.
+# * measure
+#   * measure enables the mode to measure processing time. measure :off disables it.
+# * $, show_source
+#   * Show the source code of a given method or constant.
+# * @, whereami
+#   * Show the source code around binding.irb again.
+# * debug
+#   * Start the debugger of debug.gem.
+# * break, delete, next, step, continue, finish, backtrace, info, catch
+#   * Start the debugger of debug.gem and run the command on it.
+#
 # == Configuration
 #
 # IRB reads a personal initialization file when it's invoked.
@@ -93,9 +139,9 @@ require_relative "irb/easter-egg"
 #
 # === Autocompletion
 #
-# To enable autocompletion for irb, add the following to your +.irbrc+:
+# To disable autocompletion for irb, add the following to your +.irbrc+:
 #
-#     require 'irb/completion'
+#     IRB.conf[:USE_AUTOCOMPLETE] = false
 #
 # === History
 #
@@ -426,14 +472,21 @@ module IRB
     def initialize(workspace = nil, input_method = nil)
       @context = Context.new(self, workspace, input_method)
       @context.main.extend ExtendCommandBundle
-      @context.command_aliases.each do |alias_name, cmd_name|
-        next if @context.symbol_alias(alias_name)
-        @context.main.install_alias_method(alias_name, cmd_name)
-      end
       @signal_status = :IN_IRB
       @scanner = RubyLex.new
     end
 
+    # A hook point for `debug` command's TracePoint after :IRB_EXIT as well as its clean-up
+    def debug_break
+      # it means the debug command is executed
+      if defined?(DEBUGGER__) && DEBUGGER__.respond_to?(:capture_frames_without_irb)
+        # after leaving this initial breakpoint, revert the capture_frames patch
+        DEBUGGER__.singleton_class.send(:alias_method, :capture_frames, :capture_frames_without_irb)
+        # and remove the redundant method
+        DEBUGGER__.singleton_class.send(:undef_method, :capture_frames_without_irb)
+      end
+    end
+
     def run(conf = IRB.conf)
       conf[:IRB_RC].call(context) if conf[:IRB_RC]
       conf[:MAIN_CONTEXT] = context
@@ -924,12 +977,13 @@ class Binding
   #
   #
   # See IRB@IRB+Usage for more information.
-  def irb
+  def irb(show_code: true)
     IRB.setup(source_location[0], argv: [])
     workspace = IRB::WorkSpace.new(self)
-    STDOUT.print(workspace.code_around_binding)
+    STDOUT.print(workspace.code_around_binding) if show_code
     binding_irb = IRB::Irb.new(workspace)
     binding_irb.context.irb_path = File.expand_path(source_location[0])
     binding_irb.run(IRB.conf)
+    binding_irb.debug_break
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: irb
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.5.1
 platform: ruby
 authors:
 - aycabta
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-17 00:00:00.000000000 Z
+date: 2022-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reline
@@ -46,16 +46,27 @@ files:
 - exe/irb
 - irb.gemspec
 - lib/irb.rb
+- lib/irb/cmd/backtrace.rb
+- lib/irb/cmd/break.rb
+- lib/irb/cmd/catch.rb
 - lib/irb/cmd/chws.rb
+- lib/irb/cmd/continue.rb
+- lib/irb/cmd/debug.rb
+- lib/irb/cmd/delete.rb
+- lib/irb/cmd/edit.rb
+- lib/irb/cmd/finish.rb
 - lib/irb/cmd/fork.rb
 - lib/irb/cmd/help.rb
 - lib/irb/cmd/info.rb
+- lib/irb/cmd/irb_info.rb
 - lib/irb/cmd/load.rb
 - lib/irb/cmd/ls.rb
 - lib/irb/cmd/measure.rb
+- lib/irb/cmd/next.rb
 - lib/irb/cmd/nop.rb
 - lib/irb/cmd/pushws.rb
 - lib/irb/cmd/show_source.rb
+- lib/irb/cmd/step.rb
 - lib/irb/cmd/subirb.rb
 - lib/irb/cmd/whereami.rb
 - lib/irb/color.rb
@@ -114,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Interactive Ruby command-line tool for REPL (Read Eval Print Loop).