debug 1.6.3 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61c14c6e761a2ed0f10294682cb7b152c4329d3cd0eccbffff68e3ae122d00a0
-  data.tar.gz: 714add08d21df0ceb674a8a9c8b8599f0dcc45cb38b68611c766fab1b6ddcd41
+  metadata.gz: a84e87e9582c98cf24ca8aa9f1f30032c10736bf4dbc1c44da016db564a7a574
+  data.tar.gz: da093ef6ebfd8fc5e4a10fcc39c59826e45829ec09da0d9dc164b9cd71085286
 SHA512:
-  metadata.gz: 2c43d785c88ce38a676941b87ab320d126d9083f8b4dcc487ef22b8f7f0c4a144ed2fe9dfc800f8d7b2bf9287694c3d5abcd3b7c5075248b5ca08bd6bd0b3bcf
-  data.tar.gz: 8f2e9922aac4e297c437f3fc63ec11df2af430c2f3b3406df8723d4703fc254705246300fee99fee6f38f1da62348184b3ff0dcb6a4ddf302c3345f8ae5d4634
+  metadata.gz: d663b6db0dba8921aaaa535f834e768367e07fef03613e6a277a27724fb75ecf830c7557465521998d42cbb41744e6335495958f626285468d6e38ae6ec52515
+  data.tar.gz: cb24e62c5875c069812ff1b056dda3b912a20069d09123b72dbd0da69e61aed66968bc4dc5f80e9b599df743fb7755a2399f1461f344fc43ed9ea6bbf20f251c

data/CONTRIBUTING.md

@@ -166,7 +166,7 @@ module DEBUGGER__
         9| end
       RUBY
     end
-    
+
     def test_1629720194
       debug_code(program) do
         type 's'
@@ -272,7 +272,7 @@ To run the test generator, you can enter `$ bin/gentest target.rb --open=vscode`
 Also, if you enter `$ bin/gentest target.rb --open=chrome` there, Chrome will be executed.
 If you need to modify existing tests, it is basically a good idea to regenerate them by the test generator instead of rewriting them directly.
 Please refer to [the Microsoft "Debug Adapter Protocol" article](https://microsoft.github.io/debug-adapter-protocol/specification) to learn more about DAP formats.
-Please refer to [Procol viewer for "Chrome DevTools Protocol"](https://chromedevtools.github.io/devtools-protocol/) to learn more about CDP formats.
+Please refer to [the "Chrome DevTools Protocol" official documentation](https://chromedevtools.github.io/devtools-protocol/) to learn more about CDP formats.
 
 2. High-level tests
 
@@ -320,6 +320,22 @@ Execute debugging `program` with `&scenario`. If you want to test it only for DA
 
 `run_protocol_scenario program, cdp: false ...`
 
+- attach_to_dap_server(terminate_debuggee:)
+
+Attach to the running DAP server through UNIX Domain Socket.
+
+- attach_to_cdp_server
+
+Attach to the running CDP server through TCP/IP.
+
+- req_dap_disconnect
+
+Disconnect from the currently connected DAP server.
+
+- req_cdp_disconnect
+
+Disconnect from the currently connected CDP server.
+
 - req_add_breakpoint(lineno, path: temp_file_path, cond: nil)
 
 Sends request to rdbg to add a breakpoint.
@@ -336,7 +352,7 @@ Sends request to rdbg to set exception breakpoints. e.g.
 req_set_exception_breakpoints([{ name: "RuntimeError", condition: "a == 1" }])
 ```
 
-Please note that `setExceptionBreakpoints` resets all exception breakpoints in every request. 
+Please note that `setExceptionBreakpoints` resets all exception breakpoints in every request.
 
 So the following code will only set breakpoint for `Exception`.
 
@@ -377,10 +393,6 @@ Sends request to rdbg to step back from current method.
 
 Sends request to rdbg to terminate the debuggee.
 
-- assert_reattach
-
-Passes if reattaching to rdbg is successful.
-
 - assert_hover_result(expected, expression)
 
 Passes if result of `expression` matches `expected`.

data/README.md

@@ -469,6 +469,7 @@ config set no_color true
 * UI
   * `RUBY_DEBUG_LOG_LEVEL` (`log_level`): Log level same as Logger (default: WARN)
   * `RUBY_DEBUG_SHOW_SRC_LINES` (`show_src_lines`): Show n lines source code on breakpoint (default: 10)
+  * `RUBY_DEBUG_SHOW_EVALEDSRC` (`show_evaledsrc`): Show actually evaluated source (default: false)
   * `RUBY_DEBUG_SHOW_FRAMES` (`show_frames`): Show n frames on breakpoint (default: 2)
   * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shorten PATH (like $(Gem)/foo.rb) (default: false)
   * `RUBY_DEBUG_NO_COLOR` (`no_color`): Do not use colorize (default: false)
@@ -488,12 +489,13 @@ config set no_color true
   * `RUBY_DEBUG_NONSTOP` (`nonstop`): Nonstop mode (default: false)
   * `RUBY_DEBUG_STOP_AT_LOAD` (`stop_at_load`): Stop at just loading location (default: false)
   * `RUBY_DEBUG_INIT_SCRIPT` (`init_script`): debug command script path loaded at first stop
-  * `RUBY_DEBUG_COMMANDS` (`commands`): debug commands invoked at first stop. commands should be separated by ';;'
+  * `RUBY_DEBUG_COMMANDS` (`commands`): debug commands invoked at first stop. Commands should be separated by `;;`
   * `RUBY_DEBUG_NO_RC` (`no_rc`): ignore loading ~/.rdbgrc(.rb) (default: false)
   * `RUBY_DEBUG_HISTORY_FILE` (`history_file`): history file (default: ~/.rdbg_history)
   * `RUBY_DEBUG_SAVE_HISTORY` (`save_history`): maximum save history lines (default: 10000)
 
 * REMOTE
+  * `RUBY_DEBUG_OPEN` (`open`): Open remote port (same as `rdbg --open` option)
   * `RUBY_DEBUG_PORT` (`port`): TCP/IP remote debugging: port
   * `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
@@ -501,7 +503,6 @@ config set no_color true
   * `RUBY_DEBUG_LOCAL_FS_MAP` (`local_fs_map`): Specify local fs map
   * `RUBY_DEBUG_SKIP_BP` (`skip_bp`): Skip breakpoints if no clients are attached (default: false)
   * `RUBY_DEBUG_COOKIE` (`cookie`): Cookie for negotiation
-  * `RUBY_DEBUG_OPEN_FRONTEND` (`open_frontend`): frontend used by open command (vscode, chrome, default: rdbg).
   * `RUBY_DEBUG_CHROME_PATH` (`chrome_path`): Platform dependent path of Chrome (For more information, See [here](https://github.com/ruby/debug/pull/334/files#diff-5fc3d0a901379a95bc111b86cf0090b03f857edfd0b99a0c1537e26735698453R55-R64))
 
 * OBSOLETE
@@ -536,7 +537,8 @@ There are additional features:
 * `<expr>` without debug command is almost same as `pp <expr>`.
   * If the input line `<expr>` does *NOT* start with any debug command, the line `<expr>` will be evaluated as a Ruby expression and the result will be printed with `pp` method. So that the input `foo.bar` is same as `pp foo.bar`.
   * If `<expr>` is recognized as a debug command, of course it is not evaluated as a Ruby expression, but is executed as debug command. For example, you can not evaluate such single letter local variables `i`, `b`, `n`, `c` because they are single letter debug commands. Use `p i` instead.
-* `Enter` without any input repeats the last command (useful when repeating `step`s).
+  * So the author (Koichi Sasada) recommends to use `p`, `pp` or `eval` command to evaluate the Ruby expression everytime.
+* `Enter` without any input repeats the last command (useful when repeating `step`s) for some commands.
 * `Ctrl-D` is equal to `quit` command.
 * [debug command compare sheet - Google Sheets](https://docs.google.com/spreadsheets/d/1TlmmUDsvwK4sSIyoMv-io52BUUz__R5wpu-ComXlsw0/edit?usp=sharing)
 
@@ -558,7 +560,14 @@ The `<...>` notation means the argument.
   * Finish this frame. Resume the program until the current frame is finished.
 * `fin[ish] <n>`
   * Finish `<n>`th frames.
-* `c[ontinue]`
+* `u[ntil]`
+  * Similar to `next` command, but only stop later lines or the end of the current frame.
+  * Similar to gdb's `advance` command.
+* `u[ntil] <[file:]line>
+  * Run til the program reaches given location or the end of the current frame.
+* `u[ntil] <name>
+  * Run til the program invokes a method `<name>`. `<name>` can be a regexp with `/name/`.
+* `c` or `cont` or `continue`
   * Resume the program.
 * `q[uit]` or `Ctrl-D`
   * Finish debugger (with the debuggee process on non-remote debugging).
@@ -638,26 +647,35 @@ The `<...>` notation means the argument.
   * Show predecessor lines as opposed to the `list` command.
 * `l[ist] <start>` or `l[ist] <start>-<end>`
   * Show current frame's source code from the line <start> to <end> if given.
+* `whereami`
+  * Show the current frame with source code.
 * `edit`
   * Open the current file on the editor (use `EDITOR` environment variable).
   * Note that edited file will not be reloaded.
 * `edit <file>`
   * Open <file> on the editor.
 * `i[nfo]`
-   * Show information about current frame (local/instance variables and defined constants).
-* `i[nfo] l[ocal[s]]`
+  * Show information about current frame (local/instance variables and defined constants).
+* `i[nfo]` <subcommand>
+  * `info` has the following sub-commands.
+  * Sub-commands can be specified with few letters which is unambiguous, like `l` for 'locals'.
+* `i[nfo] l or locals or local_variables`
   * Show information about the current frame (local variables)
-  * It includes `self` as `%self` and a return value as `%return`.
-* `i[nfo] i[var[s]]` or `i[nfo] instance`
+  * It includes `self` as `%self` and a return value as `_return`.
+* `i[nfo] i or ivars or instance_variables`
   * Show information about instance variables about `self`.
-* `i[nfo] c[onst[s]]` or `i[nfo] constant[s]`
+  * `info ivars <expr>` shows the instance variables of the result of `<expr>`.
+* `i[nfo] c or consts or constants`
   * Show information about accessible constants except toplevel constants.
-* `i[nfo] g[lobal[s]]`
+  * `info consts <expr>` shows the constants of a class/module of the result of `<expr>`
+* `i[nfo] g or globals or global_variables`
   * Show information about global variables
+* `i[nfo] th or threads`
+  * Show all threads (same as `th[read]`).
+* `i[nfo] b or breakpoints or w or watchpoints`
+  * Show all breakpoints and watchpoints.
 * `i[nfo] ... /regexp/`
   * Filter the output with `/regexp/`.
-* `i[nfo] th[read[s]]`
-  * Show all threads (same as `th[read]`).
 * `o[utline]` or `ls`
   * Show you available methods, constants, local variables, and instance variables in the current scope.
 * `o[utline] <expr>` or `ls <expr>`
@@ -822,11 +840,11 @@ It is useful if you only want to call a debug command and don't want to stop the
 ```
 def initialize
   @a = 1
-  binding.b do: 'watch @a'
+  binding.b do: 'info \n watch @a'
 end
 ```
 
-On this case, register a watch breakpoint for `@a` and continue to run.
+On this case, execute the `info` command then register a watch breakpoint for `@a` and continue to run. You can also use `;;` instead of `\n` to separate your commands.
 
 If `pre: 'command'` is specified, the debugger suspends the program and run the `command` as a debug command, and keep suspend.
 It is useful if you have operations before suspend.
@@ -900,6 +918,11 @@ NOTE
 
 ```
 
+# Additional Resources
+
+- [From byebug to ruby/debug](https://st0012.dev/from-byebug-to-ruby-debug) by Stan Lo - A migration guide for `byebug` users.
+- [ruby/debug cheatsheet](https://st0012.dev/ruby-debug-cheatsheet) by Stan Lo
+
 # Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/debug.

data/TODO.md

@@ -2,22 +2,22 @@
 
 ## Basic functionality
 
-* Support Ractors
-* Signal (SIGINT) trap handling 
+* Support Fibers and Ractors
 
 ## UI
 
+* Multi-line support
 * Completion for Ruby's code
 * Interactive breakpoint setting
 * Interactive record & play debugging
 * irb integration
-* Web browser integrated UI
-* History file
 
 ## Debug command
 
-* Breakpoints
-    * Lightweight pending method break points with Ruby 3.1 feature (TP:method_added)
 * Watch points
-    * Lightweight watchpoints for instance variables with Ruby 3.1 features (TP:ivar_set)
-* Faster `next`/`finish` command by specifying target code.
+    * Lightweight watchpoints for instance variables with Ruby 3.3 features (TP:ivar_set)
+* Alias
+
+## Debug port
+
+* Debug port for monitoring

data/debug.gemspec

@@ -27,6 +27,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions    = ['ext/debug/extconf.rb']
 
-  spec.add_dependency "irb", ">= 1.3.6" # for its color_printer class, which was added after 1.3
+  spec.add_dependency "irb", ">= 1.5.0" # for binding.irb(show_code: false)
   spec.add_dependency "reline", ">= 0.3.1"
 end

data/exe/rdbg

@@ -10,7 +10,7 @@ when :start
   require 'rbconfig'
 
   libpath = File.join(File.expand_path(File.dirname(__dir__)), 'lib/debug')
-  start_mode = config[:remote] ? "open" : 'start'
+  start_mode = config[:open] ? "open" : 'start'
   cmd = config[:command] ? ARGV.shift : (ENV['RUBY'] || RbConfig.ruby)
 
   if defined?($:.resolve_feature_path)

data/ext/debug/debug.c

@@ -76,7 +76,12 @@ di_body(const rb_debug_inspector_t *dc, void *ptr)
                      rb_debug_inspector_frame_binding_get(dc, i),
                      iseq,
                      rb_debug_inspector_frame_class_get(dc, i),
-                     INT2FIX(len - i));
+#ifdef RB_DEBUG_INSPECTOR_FRAME_DEPTH
+                     rb_debug_inspector_frame_depth(dc, i)
+#else
+                     INT2FIX(len - i)
+#endif
+                     );
         rb_ary_push(ary, e);
     }
 
@@ -89,6 +94,13 @@ capture_frames(VALUE self, VALUE skip_path_prefix)
     return rb_debug_inspector_open(di_body, (void *)skip_path_prefix);
 }
 
+#ifdef RB_DEBUG_INSPECTOR_FRAME_DEPTH
+static VALUE
+frame_depth(VALUE self)
+{
+    return rb_debug_inspector_current_depth();
+}
+#else
 static VALUE
 frame_depth(VALUE self)
 {
@@ -96,6 +108,8 @@ frame_depth(VALUE self)
     VALUE bt = rb_make_backtrace();
     return INT2FIX(RARRAY_LEN(bt));
 }
+#endif
+
 
 // iseq
 

data/lib/debug/abbrev_command.rb

@@ -0,0 +1,77 @@
+
+module DEBUGGER__
+  class AbbrevCommand
+    class TrieNode
+      def initialize
+        @children = {}
+        @types = {} # set
+      end
+
+      def append c, type
+        trie = (@children[c] ||= TrieNode.new)
+        trie.add_type type
+      end
+
+      def [](c)
+        @children[c]
+      end
+
+      def add_type type
+        @types[type] = true
+        self
+      end
+
+      def types
+        @types.keys
+      end
+
+      def type
+        if @types.size == 1
+          @types.keys.first
+        else
+          nil
+        end
+      end
+
+      def candidates
+        @children.map{|c, n|
+          ss = n.candidates
+          ss.empty? ? c :
+          ss.map{|s|
+            c+s
+          }
+        }.flatten
+      end
+    end
+
+    # config: { type: [commands...], ... }
+    def initialize config
+      @trie = TrieNode.new
+      build config
+    end
+
+    private def build config
+      config.each do |type, commands|
+        commands.each do |command|
+          trie = @trie
+          command.each_char do |c|
+            trie = trie.append(c, type)
+          end
+        end
+      end
+    end
+
+    def search str, if_none = nil
+      trie = @trie
+      str.each_char do |c|
+        if trie = trie[c]
+          return trie.type if trie.type
+        else
+          return if_none
+        end
+      end
+      yield trie.candidates.map{|s| str + s} if block_given?
+      if_none
+    end
+  end
+end

data/lib/debug/breakpoint.rb

@@ -6,7 +6,7 @@ module DEBUGGER__
   class Breakpoint
     include SkipPathHelper
 
-    attr_reader :key
+    attr_reader :key, :skip_src
 
     def initialize cond, command, path, do_enable: true
       @deleted = false
@@ -101,6 +101,10 @@ module DEBUGGER__
     def generate_label(name)
       colorize(" BP - #{name} ", [:YELLOW, :BOLD, :REVERSE])
     end
+
+    def pending_until_load?
+      false
+    end
   end
 
   if RUBY_VERSION.to_f <= 2.7
@@ -141,10 +145,11 @@ module DEBUGGER__
       nbp
     end
 
-    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil, skip_activate: false
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil, skip_activate: false, skip_src: false
       @line = line
       @oneshot = oneshot
       @hook_call = hook_call
+      @skip_src = skip_src
       @pending = false
 
       @iseq = nil
@@ -158,6 +163,10 @@ module DEBUGGER__
       @pending = !@iseq
     end
 
+    def pending_until_load?
+      @pending
+    end
+
     def setup
       return unless @type
 
@@ -196,7 +205,7 @@ module DEBUGGER__
       enable
 
       if @pending && !@oneshot
-        DEBUGGER__.warn "#{self} is activated."
+        DEBUGGER__.info "#{self} is activated."
       end
     end
 
@@ -264,13 +273,10 @@ module DEBUGGER__
 
           if !nearest || ((line - nline).abs < (line - nearest.line).abs)
             nearest = NearestISeq.new(iseq, nline, events)
-          else
-            if @hook_call && nearest.iseq.first_lineno <= iseq.first_lineno
-              if (nearest.line > line && !nearest.events.include?(:RUBY_EVENT_CALL)) ||
-                (events.include?(:RUBY_EVENT_CALL))
-                nearest = NearestISeq.new(iseq, nline, events)
-              end
-            end
+          elsif @hook_call &&
+                nearest.line == iseq.first_line &&
+                events.include?(:RUBY_EVENT_CALL)
+            nearest = NearestISeq.new(iseq, nline, events)
           end
         end
       end
@@ -500,7 +506,7 @@ module DEBUGGER__
         retried = false
 
         @tp.enable(target: @method)
-        DEBUGGER__.warn "#{self} is activated." if added
+        DEBUGGER__.info "#{self} is activated." if added
 
         if @sig_op == '#'
           @cond_class = @klass if @method.owner != @klass

data/lib/debug/client.rb

@@ -25,6 +25,9 @@ module DEBUGGER__
         when 'list-socks'
           cleanup_unix_domain_sockets
           puts list_connections
+        when 'list-socks-verbose'
+          cleanup_unix_domain_sockets
+          puts list_connections verbose: true
         when 'setup-autoload'
           setup_autoload
         else
@@ -91,10 +94,24 @@ module DEBUGGER__
         end
       end
 
-      def list_connections
-        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*').find_all do |path|
+      def list_connections verbose: false
+        socks = Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*').find_all do |path|
           File.socket?(path)
         end
+
+        if verbose
+          socks = socks.map{|sock_path|
+            Socket.unix(sock_path){|sock|
+              sock.puts "info cookie: #{CONFIG[:cookie] || '-'}"
+              pid = sock.gets.chomp
+              _dbg = sock.gets.chomp
+              _unm = sock.gets.chomp
+              [sock_path, pid]
+            }
+          }
+        end
+
+        socks
       end
     end
 
@@ -148,18 +165,18 @@ module DEBUGGER__
         end
       else
         Client.cleanup_unix_domain_sockets
-        files = Client.list_connections
+        files = Client.list_connections verbose: true
 
         case files.size
         when 0
           $stderr.puts "No debug session is available."
           exit
         when 1
-          @s = Socket.unix(files.first)
+          @s = Socket.unix(files.first.first)
         else
           $stderr.puts "Please select a debug session:"
-          files.each{|f|
-            $stderr.puts "  #{File.basename(f)}"
+          files.each{|(f, desc)|
+            $stderr.puts "  #{File.basename(f)} (#{desc})"
           }
           exit
         end
@@ -222,7 +239,7 @@ module DEBUGGER__
         when /^ask (\d+) (.*)/
           pid = $1
           print $2
-          send "answer #{pid} #{gets || ''}"
+          send "answer #{pid} #{$stdin.gets || ''}"
 
         when /^quit/
           raise 'quit'
@@ -231,8 +248,8 @@ module DEBUGGER__
           puts "(unknown) #{line.inspect}"
         end
       end
-    rescue
-      STDERR.puts "disconnected (#{$!})"
+    rescue => e
+      STDERR.puts "disconnected (#{e})"
       exit
     ensure
       deactivate

data/lib/debug/config.rb

@@ -14,6 +14,7 @@ module DEBUGGER__
     # UI setting
     log_level:      ['RUBY_DEBUG_LOG_LEVEL',      "UI: Log level same as Logger",               :loglevel, "WARN"],
     show_src_lines: ['RUBY_DEBUG_SHOW_SRC_LINES', "UI: Show n lines source code on breakpoint", :int, "10"],
+    show_evaledsrc: ['RUBY_DEBUG_SHOW_EVALEDSRC', "UI: Show actually evaluated source",         :bool, "false"],
     show_frames:    ['RUBY_DEBUG_SHOW_FRAMES',    "UI: Show n frames on breakpoint",            :int, "2"],
     use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shorten PATH (like $(Gem)/foo.rb)", :bool, "false"],
     no_color:       ['RUBY_DEBUG_NO_COLOR',       "UI: Do not use colorize",                    :bool, "false"],
@@ -33,12 +34,13 @@ module DEBUGGER__
     nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool, "false"],
     stop_at_load:   ['RUBY_DEBUG_STOP_AT_LOAD',"BOOT: Stop at just loading location",                               :bool, "false"],
     init_script:    ['RUBY_DEBUG_INIT_SCRIPT', "BOOT: debug command script path loaded at first stop"],
-    commands:       ['RUBY_DEBUG_COMMANDS',    "BOOT: debug commands invoked at first stop. commands should be separated by ';;'"],
+    commands:       ['RUBY_DEBUG_COMMANDS',    "BOOT: debug commands invoked at first stop. Commands should be separated by `;;`"],
     no_rc:          ['RUBY_DEBUG_NO_RC',       "BOOT: ignore loading ~/.rdbgrc(.rb)",                               :bool, "false"],
     history_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file",               :string, "~/.rdbg_history"],
     save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines", :int, "10000"],
 
     # 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"],
     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"],
@@ -46,7 +48,6 @@ module DEBUGGER__
     local_fs_map:   ['RUBY_DEBUG_LOCAL_FS_MAP', "REMOTE: Specify local fs map", :path_map],
     skip_bp:        ['RUBY_DEBUG_SKIP_BP',      "REMOTE: Skip breakpoints if no clients are attached", :bool, 'false'],
     cookie:         ['RUBY_DEBUG_COOKIE',       "REMOTE: Cookie for negotiation"],
-    open_frontend:  ['RUBY_DEBUG_OPEN_FRONTEND',"REMOTE: frontend used by open command (vscode, chrome, default: rdbg)."],
     chrome_path:    ['RUBY_DEBUG_CHROME_PATH',  "REMOTE: Platform dependent path of Chrome (For more information, See [here](https://github.com/ruby/debug/pull/334/files#diff-5fc3d0a901379a95bc111b86cf0090b03f857edfd0b99a0c1537e26735698453R55-R64))"],
 
     # obsolete
@@ -63,8 +64,6 @@ module DEBUGGER__
     end
 
     def initialize argv
-      @skip_all = false
-
       if self.class.config
         raise 'Can not make multiple configurations in one process'
       end
@@ -94,14 +93,6 @@ module DEBUGGER__
       set_config(key => val)
     end
 
-    def skip_all
-      @skip_all = true
-    end
-
-    def skip?
-      @skip_all
-    end
-
     def set_config(**kw)
       conf = config.dup
       kw.each{|k, v|
@@ -158,6 +149,12 @@ module DEBUGGER__
       if_updated old_conf, conf, :sigdump_sig do |old_sig, new_sig|
         setup_sigdump old_sig, new_sig
       end
+
+      if_updated old_conf, conf, :no_sigint_hook do |old, new|
+        if defined?(SESSION)
+          SESSION.set_no_sigint_hook old, new
+        end
+      end
     end
 
     private def if_updated old_conf, new_conf, key
@@ -308,8 +305,25 @@ module DEBUGGER__
                                         'If TCP/IP options are not given, a UNIX domain socket will be used.',
                                         'If FRONTEND is given, prepare for the FRONTEND.',
                                         'Now rdbg, vscode and chrome is supported.') do |f|
-          config[:remote] = true
-          config[:open_frontend] = f.downcase if f
+
+          case f # some format patterns are not documented yet
+          when nil
+            config[:open] = true
+          when /\A\d\z/
+            config[:open] = true
+            config[:port] = f.to_i
+          when /\A(\S+):(\d+)\z/
+            config[:open] = true
+            config[:host] = $1
+            config[:port] = $2.to_i
+          when 'tcp'
+            config[:open] = true
+            config[:port] ||= 0
+          when 'vscode', 'chrome', 'cdp'
+            config[:open] = f&.downcase
+          else
+            raise "Unknown option for --open: #{f}"
+          end
         end
         o.on('--sock-path=SOCK_PATH', 'UNIX Domain socket path') do |path|
           config[:sock_path] = path
@@ -479,10 +493,14 @@ module DEBUGGER__
       when /\A\s*### (.+)/
         cat = $1
         break if $1 == 'END'
-      when /\A      when (.+)/
+      when /\A      register_command (.+)/
         next unless cat
         next unless desc
-        ws = $1.split(/,\s*/).map{|e| e.gsub('\'', '')}
+
+        ws = []
+        $1.gsub(/'([a-z]+)'/){|w|
+          ws << $1
+        }
         helps[cat] << [ws, desc]
         desc = nil
         max_w = ws.max_by{|w| w.length}