debug 1.9.1 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbc923d5ce88d6092dbc8125ee988ec386fffdc3409b8bca4113ab925bc61311
-  data.tar.gz: 2e0a5013263c3c220dfee989af1a87c224f36bf03504fef120785717df5b9ef7
+  metadata.gz: 0abb44ebe9baa650e6fe0b811044aa50a5d3f7cf0636579ae4991193cf1467ec
+  data.tar.gz: 5decf010f8c581a30fe2543f6118541d0a34768b0d4f83451a728c47eeb6321c
 SHA512:
-  metadata.gz: eb62ffd4d8111449f618b8a91a4ab9b89237916eeb71e0fd57dd1d78d4ddadff4a3897cbdf989cd989b9c0a52103f8bfd02f1e6cd9d2453b70bd72025f1b63aa
-  data.tar.gz: 81607797fa369d2eeed0fe35335d078ea04be3ab653dea8b653b0c25453c2000407a532c17246d41be175f1df34d7bebc069deb83fef976b39a79df2a399b79c
+  metadata.gz: 1aad7e61ccedcb91f208a6edd92e0a255d8fb9e564b3b72dafceebbd88aff37b03500b63dc2e375874d27d7ad3767f174d70d3679cb3c47f31e29270952a5999
+  data.tar.gz: 87d2cf298f30052fb0b4f91abea28d5310d7a235173ef04deb3dd27a66c1b9016add6714a2ff29a6483670a5b3245b38091d0a437ede4db61a0a0d45ecfcb773

data/Gemfile

@@ -7,3 +7,4 @@ gem "rake-compiler"
 gem "test-unit", "~> 3.0"
 gem "test-unit-rr"
 gem "json-schema"
+gem "test-unit-launchable"

data/README.md

@@ -13,10 +13,10 @@ New debug.rb has several advantages:
   * TCP/IP
   * Integration with rich debugger frontends
 
-     Frontend |  [Console](https://github.com/ruby/debug#invoke-as-a-remote-debuggee) | [VSCode](https://github.com/ruby/debug#vscode-integration) | [Chrome DevTool](#chrome-devtool-integration) |
-     ---|---|---|---|
-     Connection | UDS, TCP/IP | UDS, TCP/IP | TCP/IP |
-     Requirement | No | [vscode-rdbg](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) | Chrome |
+     | Frontend    | [Console](https://github.com/ruby/debug#invoke-as-a-remote-debuggee) | [VSCode](https://github.com/ruby/debug#vscode-integration)                                  | [Chrome DevTool](#chrome-devtool-integration) |
+     | ----------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------- |
+     | Connection  | UDS, TCP/IP                                                          | UDS, TCP/IP                                                                                 | TCP/IP                                        |
+     | Requirement | No                                                                   | [vscode-rdbg](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) | Chrome                                        |
 
 * Extensible: application can introduce debugging support in several ways:
   * By `rdbg` command
@@ -244,16 +244,16 @@ It will help if you want to know what the program is doing.
 
 If you want to run a command written in Ruby like `rake`, `rails`, `bundle`, `rspec`, and so on, you can use `rdbg -c` option.
 
-* Without `-c` option, `rdbg <name>` means that `<name>` is Ruby script and invoke it like `ruby <name>` with the debugger.
-* With `-c` option, `rdbg -c <name>` means that `<name>` is a command in `PATH` and simply invokes it with the debugger.
+* Without the `-c` option, `rdbg <name>` means that `<name>` is a Ruby script and invokes it like `ruby <name>` with the debugger.
+* With the `-c` option, `rdbg -c <name>` means that `<name>` is a command in `PATH` and simply invokes it with the debugger.
 
 Examples:
 * `rdbg -c -- rails server`
 * `rdbg -c -- bundle exec ruby foo.rb`
 * `rdbg -c -- bundle exec rake test`
-* `rdbg -c -- ruby target.rb` is same as `rdbg target.rb`
+* `rdbg -c -- ruby target.rb` is the same as `rdbg target.rb`
 
-NOTE: `--` is needed to separate the command line options for `rdbg` and invoking command. For example, `rdbg -c rake -T` is recognized like `rdbg -c -T -- rake`. It should be `rdbg -c -- rake -T`.
+NOTE: `--` is needed to separate the command line options for `rdbg` and the invoking command. For example, `rdbg -c rake -T` is recognized like `rdbg -c -T -- rake`. It should be `rdbg -c -- rake -T`.
 
 NOTE: If you want to use bundler (`bundle` command), you need to write `gem debug` line in your `Gemfile`.
 
@@ -289,10 +289,10 @@ You can run your application as a remote debuggee, and the remote debugger conso
 
 There are multiple ways to run your program as a debuggee:
 
-Stop at program start | [`rdbg` option](https://github.com/ruby/debug#rdbg---open-or-rdbg--o-for-short) | [require](https://github.com/ruby/debug#require-debugopen-in-a-program) | [debugger API](https://github.com/ruby/debug#start-by-method)
----|---|---|---|
-Yes | `rdbg --open` | `require "debug/open"` | `DEBUGGER__.open`
-No | `rdbg --open --nonstop` | `require "debug/open_nonstop"` | `DEBUGGER__.open(nonstop: true)`
+| Stop at program start | [`rdbg` option](https://github.com/ruby/debug#rdbg---open-or-rdbg--o-for-short) | [require](https://github.com/ruby/debug#require-debugopen-in-a-program) | [debugger API](https://github.com/ruby/debug#start-by-method) |
+| --------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------- |
+| Yes                   | `rdbg --open`                                                                   | `require "debug/open"`                                                  | `DEBUGGER__.open`                                             |
+| No                    | `rdbg --open --nonstop`                                                         | `require "debug/open_nonstop"`                                          | `DEBUGGER__.open(nonstop: true)`                              |
 
 #### `rdbg --open` (or `rdbg -O` for short)
 
@@ -330,7 +330,9 @@ When `rdbg --attach` connects to the debuggee, you can use any debug commands (s
 
 NOTE: If you use the `quit` command, only the remote console exits and the debuggee program continues to run (and you can connect it again). If you want to exit the debuggee program, use `kill` command.
 
-If you want to use TCP/IP for the remote debugging, you need to specify the port and host with `--port` like `rdbg --open --port 12345` and it binds to `localhost:12345`.
+If you want to use TCP/IP for the remote debugging, you need to specify the port and host with `--port` like `rdbg --open --port 12345` and it binds to `localhost:12345`. You can add an optional `--port_range` option to try multiple ports in a reliable way. For example, `rdbg --open --port 12345 --port_range 10` will try to bind to 12345, 12346, 12347, ... until it finds an available port.
+
+```shell
 
 To connect to the debuggee, you need to specify the port.
 
@@ -499,6 +501,7 @@ config set no_color true
 * REMOTE
   * `RUBY_DEBUG_OPEN` (`open`): Open remote port (same as `rdbg --open` option)
   * `RUBY_DEBUG_PORT` (`port`): TCP/IP remote debugging: port
+  * `RUBY_DEBUG_PORT_RANGE` (`port_range`): TCP/IP remote debugging: length of port range
   * `RUBY_DEBUG_HOST` (`host`): TCP/IP remote debugging: host (default: 127.0.0.1)
   * `RUBY_DEBUG_SOCK_PATH` (`sock_path`): UNIX Domain Socket remote debugging: socket path
   * `RUBY_DEBUG_SOCK_DIR` (`sock_dir`): UNIX Domain Socket remote debugging: socket directory
@@ -713,7 +716,7 @@ The `<...>` notation means the argument.
 * `eval <expr>`
   * Evaluate `<expr>` on the current frame.
 * `irb`
-  * Invoke `irb` on the current frame.
+  * Activate and switch to `irb:rdbg` console
 
 ### Trace
 
@@ -784,6 +787,30 @@ The `<...>` notation means the argument.
   * Show help for the given command.
 
 
+### Using IRB as the Debug Console
+
+Starting from version `v1.9`, you can now use IRB as the debug console. This integration brings additional features such as:
+
+* Autocompletion
+* Support for multi-line input
+* Access to commands not available in `debug`, like `show_source` or `show_doc`
+* [Configurable command aliases](https://docs.ruby-lang.org/en/master/IRB.html#module-IRB-label-Command+Aliases)
+
+To switch to the IRB console, simply use the `irb` command in the debug console.
+
+Once activated, you'll notice the prompt changes to:
+
+```txt
+irb:rdbg(main):001>
+```
+
+If you want to make IRB the default console for all sessions, configure the `irb_console` setting by either:
+
+* Setting the `RUBY_DEBUG_IRB_CONSOLE=true` environment variable
+* Or adding `config set irb_console 1` to your `~/.rdbgrc`
+
+To disable the IRB console in the current session, execute `config set irb_console 0` in the console.
+
 ## Debugger API
 
 ### Start debugging
@@ -883,6 +910,7 @@ Debug console mode:
                                      Now rdbg, vscode and chrome is supported.
         --sock-path=SOCK_PATH        UNIX Domain socket path
         --port=PORT                  Listening TCP/IP port
+        --port-range=PORT_RANGE      Number of ports to try to connect to
         --host=HOST                  Listening TCP/IP host
         --cookie=COOKIE              Set a cookie for connection
         --session-name=NAME          Session name

data/debug.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases/tag/v#{spec.version}"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/ext/debug/debug.c

@@ -8,13 +8,13 @@ static VALUE rb_mDebugger;
 
 // iseq
 typedef struct rb_iseq_struct rb_iseq_t;
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
 VALUE rb_iseq_realpath(const rb_iseq_t *iseq);
 
 static VALUE
 iseq_realpath(VALUE iseqw)
 {
-    rb_iseq_t *iseq = DATA_PTR(iseqw);
-    return rb_iseq_realpath(iseq);
+    return rb_iseq_realpath(rb_iseqw_to_iseq(iseqw));
 }
 
 static VALUE rb_cFrameInfo;
@@ -121,26 +121,26 @@ frame_depth(VALUE self)
 
 // iseq
 
-const struct rb_iseq *rb_iseqw_to_iseq(VALUE iseqw);
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
 
 #ifdef HAVE_RB_ISEQ_TYPE
-VALUE rb_iseq_type(const struct rb_iseq *);
+VALUE rb_iseq_type(const rb_iseq_t *);
 
 static VALUE
 iseq_type(VALUE iseqw)
 {
-    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
     return rb_iseq_type(iseq);
 }
 #endif
 
 #ifdef HAVE_RB_ISEQ_PARAMETERS
-VALUE rb_iseq_parameters(const struct rb_iseq *, int is_proc);
+VALUE rb_iseq_parameters(const rb_iseq_t *, int is_proc);
 
 static VALUE
 iseq_parameters_symbols(VALUE iseqw)
 {
-    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
     VALUE params = rb_iseq_parameters(iseq, 0);
     VALUE ary = rb_ary_new();
 
@@ -167,12 +167,12 @@ iseq_parameters_symbols(VALUE iseqw)
 #endif
 
 #ifdef HAVE_RB_ISEQ_CODE_LOCATION
-void rb_iseq_code_location(const struct rb_iseq *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
+void rb_iseq_code_location(const rb_iseq_t *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
 
 static VALUE
 iseq_first_line(VALUE iseqw)
 {
-    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
     int line;
     rb_iseq_code_location(iseq, &line, NULL, NULL, NULL);
     return INT2NUM(line);
@@ -181,7 +181,7 @@ iseq_first_line(VALUE iseqw)
 static VALUE
 iseq_last_line(VALUE iseqw)
 {
-    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
     int line;
     rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
     return INT2NUM(line);

data/lib/debug/config.rb

@@ -44,6 +44,7 @@ module DEBUGGER__
     # remote setting
     open:           ['RUBY_DEBUG_OPEN',         "REMOTE: Open remote port (same as `rdbg --open` option)"],
     port:           ['RUBY_DEBUG_PORT',         "REMOTE: TCP/IP remote debugging: port"],
+    port_range:     ['RUBY_DEBUG_PORT_RANGE',   "REMOTE: TCP/IP remote debugging: length of port range"],
     host:           ['RUBY_DEBUG_HOST',         "REMOTE: TCP/IP remote debugging: host", :string, "127.0.0.1"],
     sock_path:      ['RUBY_DEBUG_SOCK_PATH',    "REMOTE: UNIX Domain Socket remote debugging: socket path"],
     sock_dir:       ['RUBY_DEBUG_SOCK_DIR',     "REMOTE: UNIX Domain Socket remote debugging: socket directory"],
@@ -158,6 +159,22 @@ module DEBUGGER__
           SESSION.set_no_sigint_hook old, new
         end
       end
+
+      if_updated old_conf, conf, :irb_console do |old, new|
+        if defined?(SESSION) && SESSION.active?
+          # irb_console is switched from true to false
+          if old
+            SESSION.deactivate_irb_integration
+          # irb_console is switched from false to true
+          else
+            if CONFIG[:open]
+              SESSION.instance_variable_get(:@ui).puts "\nIRB is not supported on the remote console."
+            else
+              SESSION.activate_irb_integration
+            end
+          end
+        end
+      end
     end
 
     private def if_updated old_conf, new_conf, key
@@ -336,6 +353,9 @@ module DEBUGGER__
         o.on('--port=PORT', 'Listening TCP/IP port') do |port|
           config[:port] = port
         end
+        o.on('--port-range=PORT_RANGE', 'Number of ports to try to connect to') do |port_range|
+          config[:port_range] = port_range
+        end
         o.on('--host=HOST', 'Listening TCP/IP host') do |host|
           config[:host] = host
         end

data/lib/debug/console.rb

@@ -143,7 +143,7 @@ module DEBUGGER__
       rescue LoadError
         def readline prompt
           print prompt
-          gets
+          $stdin.gets
         end
 
         def history

data/lib/debug/irb_integration.rb

@@ -24,4 +24,14 @@ module DEBUGGER__
       IRB::Context.prepend(IrbPatch)
     end
   end
+
+  class Session
+    def deactivate_irb_integration
+      Reline.completion_proc = nil
+      Reline.output_modifier_proc = nil
+      Reline.autocompletion = false
+      Reline.dig_perfect_match_proc = nil
+      reset_ui UI_LocalConsole.new
+    end
+  end
 end

data/lib/debug/prelude.rb

@@ -5,7 +5,7 @@ return if defined?(::DEBUGGER__::Session)
 
 # Put the following line in your login script (e.g. ~/.bash_profile) with modified path:
 #
-#   export RUBYOPT="-r /path/to/debug/prelude $(RUBYOPT)"
+#   export RUBYOPT="-r /path/to/debug/prelude ${RUBYOPT}"
 #
 module Kernel
   def debugger(*a, up_level: 0, **kw)

data/lib/debug/server.rb

@@ -399,6 +399,13 @@ module DEBUGGER__
           raise "Specify digits for port number"
         end
       end
+      @port_range = if @port.zero?
+        0
+      else
+        port_range_str = (CONFIG[:port_range] || "0").to_s
+        raise "Specify a positive integer <=16 for port range" unless port_range_str.match?(/\A\d+\z/) && port_range_str.to_i <= 16
+        port_range_str.to_i
+      end
       @uuid = nil # for CDP
 
       super()
@@ -452,7 +459,9 @@ module DEBUGGER__
           end
         end
       rescue Errno::EADDRINUSE
-        if retry_cnt < 10
+        number_of_retries = @port_range.zero? ? 10 : @port_range
+        if retry_cnt < number_of_retries
+          @port += 1 unless @port_range.zero?
           retry_cnt += 1
           sleep 0.1
           retry

data/lib/debug/server_cdp.rb

@@ -2,7 +2,6 @@
 
 require 'json'
 require 'digest/sha1'
-require 'base64'
 require 'securerandom'
 require 'stringio'
 require 'open3'
@@ -131,7 +130,7 @@ module DEBUGGER__
           stdout.close
           data = stderr.readpartial 4096
           stderr.close
-          if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
+          if data.match(/DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/)
             port = $1
             path = $2
           end
@@ -158,7 +157,7 @@ module DEBUGGER__
             raise NotFoundChromeEndpointError
           end
           stderr.close
-          if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
+          if data.match(/DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/)
             port = $1
             path = $2
           end
@@ -190,7 +189,7 @@ module DEBUGGER__
         while i < ITERATIONS
           i += 1
           if File.exist?(tf) && data = File.read(tf)
-            if data.match /DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/
+            if data.match(/DevTools listening on ws:\/\/127.0.0.1:(\d+)(.*)/)
               port = $1
               path = $2
               return [port, path]
@@ -297,8 +296,8 @@ module DEBUGGER__
         res = @sock.readpartial 4092
         show_protocol :<, res
 
-        if res.match /^Sec-WebSocket-Accept: (.*)\r\n/
-          correct_key = Base64.strict_encode64 Digest::SHA1.digest "#{key}==258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+        if res.match(/^Sec-WebSocket-Accept: (.*)\r\n/)
+          correct_key = Digest::SHA1.base64digest "#{key}==258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
           raise "The Sec-WebSocket-Accept value: #{$1} is not valid" unless $1 == correct_key
         else
           raise "Unknown response: #{res}"
@@ -378,8 +377,8 @@ module DEBUGGER__
         req = @sock.readpartial 4096
         show_protocol '>', req
 
-        if req.match /^Sec-WebSocket-Key: (.*)\r\n/
-          accept = Base64.strict_encode64 Digest::SHA1.digest "#{$1}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+        if req.match(/^Sec-WebSocket-Key: (.*)\r\n/)
+          accept = Digest::SHA1.base64digest "#{$1}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
           res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: #{accept}\r\n\r\n"
           @sock.print res
           show_protocol :<, res
@@ -658,7 +657,7 @@ module DEBUGGER__
 
     def activate_bp bps
       bps.each_key{|k|
-        if k.match /^\d+:(\d+):(.*)/
+        if k.match(/^\d+:(\d+):(.*)/)
           line = $1
           path = $2
           SESSION.add_line_breakpoint(path, line.to_i + 1)
@@ -689,7 +688,7 @@ module DEBUGGER__
       yield $stderr
     end
 
-    def puts result=''
+    def puts result = ""
       # STDERR.puts "puts: #{result}"
       # send_event 'output', category: 'stderr', output: "PUTS!!: " + result.to_s
     end

data/lib/debug/server_dap.rb

@@ -501,7 +501,7 @@ module DEBUGGER__
       send_response(req, **res)
     end
 
-    def puts result
+    def puts result = ""
       # STDERR.puts "puts: #{result}"
       send_event 'output', category: 'console', output: "#{result&.chomp}\n"
     end

data/lib/debug/session.rb

@@ -202,11 +202,6 @@ module DEBUGGER__
         end
         @tp_thread_end.enable
 
-        if CONFIG[:irb_console] && !CONFIG[:open]
-          require_relative "irb_integration"
-          thc.activate_irb_integration
-        end
-
         # session start
         q << true
         session_server_main
@@ -214,6 +209,12 @@ module DEBUGGER__
       first_q << :ok
 
       q.pop
+
+      # For activating irb:rdbg with startup config like `RUBY_DEBUG_IRB_CONSOLE=1`
+      # Because in that case the `Config#if_updated` callback would not be triggered
+      if CONFIG[:irb_console] && !CONFIG[:open]
+        activate_irb_integration
+      end
     end
 
     def deactivate
@@ -938,14 +939,15 @@ module DEBUGGER__
       end
 
       # * `irb`
-      #   * Invoke `irb` on the current frame.
+      #   * Activate and switch to `irb:rdbg` console
       register_command 'irb' do |arg|
         if @ui.remote?
           @ui.puts "\nIRB is not supported on the remote console."
-          :retry
         else
-          request_eval :irb, nil
+          config_set :irb_console, true
         end
+
+        :retry
       end
 
       ### Trace
@@ -1876,6 +1878,12 @@ module DEBUGGER__
       end
     end
 
+    def activate_irb_integration
+      require_relative "irb_integration"
+      thc = get_thread_client(@session_server)
+      thc.activate_irb_integration
+    end
+
     def enter_postmortem_session exc
       return unless exc.instance_variable_defined? :@__debugger_postmortem_frames
 

data/lib/debug/thread_client.rb

@@ -44,7 +44,7 @@ module DEBUGGER__
   end
 
   module GlobalVariablesHelper
-    SKIP_GLOBAL_LIST = %i[$= $KCODE $-K $SAFE].freeze
+    SKIP_GLOBAL_LIST = %i[$= $KCODE $-K $SAFE $FILENAME].freeze
     def safe_global_variables
       global_variables.reject{|name| SKIP_GLOBAL_LIST.include? name }
     end
@@ -989,7 +989,7 @@ module DEBUGGER__
                   true
                 else
                   true if depth >= DEBUGGER__.frame_depth - 3 &&
-                          caller_locations(2, 1).first.label == target_location_label
+                          caller_locations(2, 1).first.base_label == target_location_label
                           # TODO: imcomplete condition
                 end
               end
@@ -1005,7 +1005,7 @@ module DEBUGGER__
                   true if pat === tp.callee_id.to_s
                 else # :return, :b_return
                   true if depth >= DEBUGGER__.frame_depth - 3 &&
-                          caller_locations(2, 1).first.label == target_location_label
+                          caller_locations(2, 1).first.base_label == target_location_label
                           # TODO: imcomplete condition
                 end
               end
@@ -1056,9 +1056,6 @@ module DEBUGGER__
             end
           when :call
             result = frame_eval(eval_src)
-          when :irb
-            require_relative "irb_integration"
-            activate_irb_integration
           when :display, :try_display
             failed_results = []
             eval_src.each_with_index{|src, i|

data/lib/debug/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DEBUGGER__
-  VERSION = "1.9.1"
+  VERSION = "1.10.0"
 end

data/misc/README.md.erb

@@ -13,10 +13,10 @@ New debug.rb has several advantages:
   * TCP/IP
   * Integration with rich debugger frontends
 
-     Frontend |  [Console](https://github.com/ruby/debug#invoke-as-a-remote-debuggee) | [VSCode](https://github.com/ruby/debug#vscode-integration) | [Chrome DevTool](#chrome-devtool-integration) |
-     ---|---|---|---|
-     Connection | UDS, TCP/IP | UDS, TCP/IP | TCP/IP |
-     Requirement | No | [vscode-rdbg](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) | Chrome |
+     | Frontend    | [Console](https://github.com/ruby/debug#invoke-as-a-remote-debuggee) | [VSCode](https://github.com/ruby/debug#vscode-integration)                                  | [Chrome DevTool](#chrome-devtool-integration) |
+     | ----------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------- |
+     | Connection  | UDS, TCP/IP                                                          | UDS, TCP/IP                                                                                 | TCP/IP                                        |
+     | Requirement | No                                                                   | [vscode-rdbg](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) | Chrome                                        |
 
 * Extensible: application can introduce debugging support in several ways:
   * By `rdbg` command
@@ -244,16 +244,16 @@ It will help if you want to know what the program is doing.
 
 If you want to run a command written in Ruby like `rake`, `rails`, `bundle`, `rspec`, and so on, you can use `rdbg -c` option.
 
-* Without `-c` option, `rdbg <name>` means that `<name>` is Ruby script and invoke it like `ruby <name>` with the debugger.
-* With `-c` option, `rdbg -c <name>` means that `<name>` is a command in `PATH` and simply invokes it with the debugger.
+* Without the `-c` option, `rdbg <name>` means that `<name>` is a Ruby script and invokes it like `ruby <name>` with the debugger.
+* With the `-c` option, `rdbg -c <name>` means that `<name>` is a command in `PATH` and simply invokes it with the debugger.
 
 Examples:
 * `rdbg -c -- rails server`
 * `rdbg -c -- bundle exec ruby foo.rb`
 * `rdbg -c -- bundle exec rake test`
-* `rdbg -c -- ruby target.rb` is same as `rdbg target.rb`
+* `rdbg -c -- ruby target.rb` is the same as `rdbg target.rb`
 
-NOTE: `--` is needed to separate the command line options for `rdbg` and invoking command. For example, `rdbg -c rake -T` is recognized like `rdbg -c -T -- rake`. It should be `rdbg -c -- rake -T`.
+NOTE: `--` is needed to separate the command line options for `rdbg` and the invoking command. For example, `rdbg -c rake -T` is recognized like `rdbg -c -T -- rake`. It should be `rdbg -c -- rake -T`.
 
 NOTE: If you want to use bundler (`bundle` command), you need to write `gem debug` line in your `Gemfile`.
 
@@ -289,10 +289,10 @@ You can run your application as a remote debuggee, and the remote debugger conso
 
 There are multiple ways to run your program as a debuggee:
 
-Stop at program start | [`rdbg` option](https://github.com/ruby/debug#rdbg---open-or-rdbg--o-for-short) | [require](https://github.com/ruby/debug#require-debugopen-in-a-program) | [debugger API](https://github.com/ruby/debug#start-by-method)
----|---|---|---|
-Yes | `rdbg --open` | `require "debug/open"` | `DEBUGGER__.open`
-No | `rdbg --open --nonstop` | `require "debug/open_nonstop"` | `DEBUGGER__.open(nonstop: true)`
+| Stop at program start | [`rdbg` option](https://github.com/ruby/debug#rdbg---open-or-rdbg--o-for-short) | [require](https://github.com/ruby/debug#require-debugopen-in-a-program) | [debugger API](https://github.com/ruby/debug#start-by-method) |
+| --------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------- |
+| Yes                   | `rdbg --open`                                                                   | `require "debug/open"`                                                  | `DEBUGGER__.open`                                             |
+| No                    | `rdbg --open --nonstop`                                                         | `require "debug/open_nonstop"`                                          | `DEBUGGER__.open(nonstop: true)`                              |
 
 #### `rdbg --open` (or `rdbg -O` for short)
 
@@ -330,7 +330,9 @@ When `rdbg --attach` connects to the debuggee, you can use any debug commands (s
 
 NOTE: If you use the `quit` command, only the remote console exits and the debuggee program continues to run (and you can connect it again). If you want to exit the debuggee program, use `kill` command.
 
-If you want to use TCP/IP for the remote debugging, you need to specify the port and host with `--port` like `rdbg --open --port 12345` and it binds to `localhost:12345`.
+If you want to use TCP/IP for the remote debugging, you need to specify the port and host with `--port` like `rdbg --open --port 12345` and it binds to `localhost:12345`. You can add an optional `--port_range` option to try multiple ports in a reliable way. For example, `rdbg --open --port 12345 --port_range 10` will try to bind to 12345, 12346, 12347, ... until it finds an available port.
+
+```shell
 
 To connect to the debuggee, you need to specify the port.
 
@@ -509,6 +511,30 @@ The `<...>` notation means the argument.
 
 <%= DEBUGGER__.help %>
 
+### Using IRB as the Debug Console
+
+Starting from version `v1.9`, you can now use IRB as the debug console. This integration brings additional features such as:
+
+* Autocompletion
+* Support for multi-line input
+* Access to commands not available in `debug`, like `show_source` or `show_doc`
+* [Configurable command aliases](https://docs.ruby-lang.org/en/master/IRB.html#module-IRB-label-Command+Aliases)
+
+To switch to the IRB console, simply use the `irb` command in the debug console.
+
+Once activated, you'll notice the prompt changes to:
+
+```txt
+irb:rdbg(main):001>
+```
+
+If you want to make IRB the default console for all sessions, configure the `irb_console` setting by either:
+
+* Setting the `RUBY_DEBUG_IRB_CONSOLE=true` environment variable
+* Or adding `config set irb_console 1` to your `~/.rdbgrc`
+
+To disable the IRB console in the current session, execute `config set irb_console 0` in the console.
+
 ## Debugger API
 
 ### Start debugging

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: debug
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.10.0
 platform: ruby
+original_platform: ''
 authors:
 - Koichi Sasada
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-22 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -90,7 +90,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/ruby/debug
   source_code_uri: https://github.com/ruby/debug
-post_install_message: 
+  changelog_uri: https://github.com/ruby/debug/releases/tag/v1.10.0
 rdoc_options: []
 require_paths:
 - lib
@@ -105,8 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
-signing_key: 
+rubygems_version: 3.6.0.dev
 specification_version: 4
 summary: Debugging functionality for Ruby
 test_files: []