debug 1.0.0.beta8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df98b8b5fd353be1aad11534d3180e9ae4b753de6e7ca95c3568d79e952e4770
-  data.tar.gz: 600580327ace5a5feb37df85e3d0569d17ee55a118dab0d05513452745211b2a
+  metadata.gz: 5e9851059a728e477461cc318c9b94932fa0aeb19215f936ab6c25cf62f67cd0
+  data.tar.gz: b050eee3dbf0afecfda2c1221fe38ab678808405c10f89d5832a1950e2728aa8
 SHA512:
-  metadata.gz: 3a8b1ba471ca0169bc243e7a97600160317d041c022452b00fc0c2729939bc5ea907f52293cfa62dcf5d3be95cbd3c89ed9ebe2d49221e228f5588834378abdd
-  data.tar.gz: ee7524b1fb4040472ca7e7d9c760f92200dfe0f94d034877c3d23ea0f940f2a8f9d67310a756fa287ecf6b80c60e7d221215d1b150798f49a3fc627c7b9635d7
+  metadata.gz: a15549ee06b890a32d0960dd24a99c4c925d66b5f6512a7e5ff3052f10ca3a255038d44eaa2d10046cbe2b68bca121c813db3a8e5fea68def5dcd2e1797864d7
+  data.tar.gz: '058b5ef8c6e40a8ccfa12b62b09c8808c1b524c398e37a25ffd790b8a8e0364026911478019d06100b7a6d8fde878dd7695f2f2630f3f35f37f12695b84b2ddf'

data/CONTRIBUTING.md

@@ -49,75 +49,75 @@ $ bin/gentest target.rb
 #### 3. Debugger will be executed. You can type any debug commands.
 ```shell
 $ bin/gentest target.rb
+DEBUGGER: Session start (pid: 11139)
 [1, 9] in ~/workspace/debug/target.rb
-=>    1| module Foo
-      2|   class Bar
-      3|     def self.a
-      4|       "hello"
-      5|     end
-      6|   end
-      7|   Bar.a
-      8|   bar = Bar.new
-      9| end
+=>   1| module Foo
+     2|   class Bar
+     3|     def self.a
+     4|       "hello"
+     5|     end
+     6|   end
+     7|   Bar.a
+     8|   bar = Bar.new
+     9| end
 =>#0	<main> at ~/workspace/debug/target.rb:1
 INTERNAL_INFO: {"location":"~/workspace/debug/target.rb:1","line":1}
-
 (rdbg)s
  s
 [1, 9] in ~/workspace/debug/target.rb
-      1| module Foo
-=>    2|   class Bar
-      3|     def self.a
-      4|       "hello"
-      5|     end
-      6|   end
-      7|   Bar.a
-      8|   bar = Bar.new
-      9| end
+     1| module Foo
+=>   2|   class Bar
+     3|     def self.a
+     4|       "hello"
+     5|     end
+     6|   end
+     7|   Bar.a
+     8|   bar = Bar.new
+     9| end
 =>#0	<module:Foo> at ~/workspace/debug/target.rb:2
   #1	<main> at ~/workspace/debug/target.rb:1
 INTERNAL_INFO: {"location":"~/workspace/debug/target.rb:2","line":2}
-
 (rdbg)n
  n
 [1, 9] in ~/workspace/debug/target.rb
-      1| module Foo
-      2|   class Bar
-=>    3|     def self.a
-      4|       "hello"
-      5|     end
-      6|   end
-      7|   Bar.a
-      8|   bar = Bar.new
-      9| end
+     1| module Foo
+     2|   class Bar
+=>   3|     def self.a
+     4|       "hello"
+     5|     end
+     6|   end
+     7|   Bar.a
+     8|   bar = Bar.new
+     9| end
 =>#0	<class:Bar> at ~/workspace/debug/target.rb:3
   #1	<module:Foo> at ~/workspace/debug/target.rb:2
-  #2	<main> at ~/workspace/debug/target.rb:1
+  # and 1 frames (use `bt' command for all frames)
 INTERNAL_INFO: {"location":"~/workspace/debug/target.rb:3","line":3}
-
 (rdbg)b 7
  b 7
+#0  BP - Line  /Users/naotto/workspace/debug/target.rb:7 (line)
 INTERNAL_INFO: {"location":"~/workspace/debug/target.rb:3","line":3}
-
 (rdbg)c
  c
 [2, 9] in ~/workspace/debug/target.rb
-      2|   class Bar
-      3|     def self.a
-      4|       "hello"
-      5|     end
-      6|   end
-=>    7|   Bar.a
-      8|   bar = Bar.new
-      9| end
+     2|   class Bar
+     3|     def self.a
+     4|       "hello"
+     5|     end
+     6|   end
+=>   7|   Bar.a
+     8|   bar = Bar.new
+     9| end
 =>#0	<module:Foo> at ~/workspace/debug/target.rb:7
   #1	<main> at ~/workspace/debug/target.rb:1
 
 Stop by #0  BP - Line  /Users/naotto/workspace/debug/target.rb:7 (line)
 INTERNAL_INFO: {"location":"~/workspace/debug/target.rb:7","line":7}
-
 (rdbg)q!
  q!
+created: /Users/naotto/workspace/debug/test/tool/../debug/foo_test.rb
+    class: FooTest
+    method: test_1629720194
 ```
 #### 4. The test file will be created as `test/debug/foo_test.rb`.
 If the file already exists, **only method** will be added to it.
@@ -131,70 +131,70 @@ module DEBUGGER__
     def program
       <<~RUBY
         1| module Foo
-        1|   class Bar
-        2|     def self.a
-        3|       "hello"
-        4|     end
-        5|   end
-        6|   Bar.a
-        7|   bar = Bar.new
-        8| end
+        2|   class Bar
+        3|     def self.a
+        4|       "hello"
+        5|     end
+        6|   end
+        7|   Bar.a
+        8|   bar = Bar.new
+        9| end
       RUBY
     end
     
-    def test_foo
+    def test_1629720194
       debug_code(program) do
         type 's'
         assert_line_num 2
         assert_line_text([
-          /[1, 9] in .*/,
-          /      1| module Foo/,
-          /=>    2|   class Bar/,
-          /      3|     def self.a/,
-          /      4|       "hello"/,
-          /      5|     end/,
-          /      6|   end/,
-          /      7|   Bar.a/,
-          /      8|   bar = Bar.new/,
-          /      9| end/,
-          /=>#0	<module:Foo> at .*/,
-          /  #1	<main> at .*/
+          /\[1, 9\] in .*/,
+          /     1\| module Foo/,
+          /=>   2\|   class Bar/,
+          /     3\|     def self\.a/,
+          /     4\|       "hello"/,
+          /     5\|     end/,
+          /     6\|   end/,
+          /     7\|   Bar\.a/,
+          /     8\|   bar = Bar\.new/,
+          /     9\| end/,
+          /=>\#0\t<module:Foo> at .*/,
+          /  \#1\t<main> at .*/
         ])
         type 'n'
         assert_line_num 3
         assert_line_text([
-          /[1, 9] in .*/,
-          /      1| module Foo/,
-          /      2|   class Bar/,
-          /=>    3|     def self.a/,
-          /      4|       "hello"/,
-          /      5|     end/,
-          /      6|   end/,
-          /      7|   Bar.a/,
-          /      8|   bar = Bar.new/,
-          /      9| end/,
-          /=>#0	<class:Bar> at .*/,
-          /  #1	<module:Foo> at .*/,
-          /  #2	<main> at .*/
+          /\[1, 9\] in .*/,
+          /     1\| module Foo/,
+          /     2\|   class Bar/,
+          /=>   3\|     def self\.a/,
+          /     4\|       "hello"/,
+          /     5\|     end/,
+          /     6\|   end/,
+          /     7\|   Bar\.a/,
+          /     8\|   bar = Bar\.new/,
+          /     9\| end/,
+          /=>\#0\t<class:Bar> at .*/,
+          /  \#1\t<module:Foo> at .*/,
+          /  \# and 1 frames \(use `bt' command for all frames\)/
         ])
         type 'b 7'
-        assert_line_text(//)
+        assert_line_text(/\#0  BP \- Line  .*/)
         type 'c'
         assert_line_num 7
         assert_line_text([
-          /[2, 9] in .*/,
-          /      2|   class Bar/,
-          /      3|     def self.a/,
-          /      4|       "hello"/,
-          /      5|     end/,
-          /      6|   end/,
-          /=>    7|   Bar.a/,
-          /      8|   bar = Bar.new/,
-          /      9| end/,
-          /=>#0	<module:Foo> at .*/,
-          /  #1	<main> at .*/,
+          /\[2, 9\] in .*/,
+          /     2\|   class Bar/,
+          /     3\|     def self\.a/,
+          /     4\|       "hello"/,
+          /     5\|     end/,
+          /     6\|   end/,
+          /=>   7\|   Bar\.a/,
+          /     8\|   bar = Bar\.new/,
+          /     9\| end/,
+          /=>\#0\t<module:Foo> at .*/,
+          /  \#1\t<main> at .*/,
           //,
-          /Stop by #0  BP - Line  .*/
+          /Stop by \#0  BP \- Line  .*/
         ])
         type 'q!'
       end
@@ -287,6 +287,7 @@ $ exe/rdbg -e 'b 20;; c ;; bt ;; info ;; q!' -e c target.rb
 
 ```
 ❯ exe/rdbg -e 'b 20;; c ;; bt ;; info ;; q!' -e c target.rb
+DEBUGGER: Session start (pid: 9815)
 [1, 10] in target.rb
 =>    1| class Foo
       2|   def first_call
@@ -299,10 +300,10 @@ $ exe/rdbg -e 'b 20;; c ;; bt ;; info ;; q!' -e c target.rb
       9|     end
      10|   end
 =>#0    <main> at target.rb:1
-(rdbg:init) b 20
-#1 line bp /PATH_TO_PROJECT/debug/target.rb:20 (return)
-(rdbg:init) c
-[15, 23] in target.rb
+(rdbg:commands) b 20
+#0  BP - Line  /PATH_TO_PROJECT/target.rb:20 (return)
+(rdbg:commands) c
+[15, 24] in target.rb
      15|     yield(10)
      16|   end
      17|
@@ -312,25 +313,26 @@ $ exe/rdbg -e 'b 20;; c ;; bt ;; info ;; q!' -e c target.rb
      21| end
      22|
      23| Foo.new.first_call
+     24|
 =>#0    Foo#forth_call(num1=20, num2=10) at target.rb:20 #=> 30
-  #1    block{|ten=10|} in second_call at target.rb:8
+  #1    block {|ten=10|} in second_call at target.rb:8
   # and 4 frames (use `bt' command for all frames)
 
-Stop by #1 line bp /PATH_TO_PROJECT/debug/target.rb:20 (return)
-(rdbg:init) bt
+Stop by #0  BP - Line  /PATH_TO_PROJECT/target.rb:20 (return)
+(rdbg:commands) bt
 =>#0    Foo#forth_call(num1=20, num2=10) at target.rb:20 #=> 30
-  #1    block{|ten=10|} in second_call at target.rb:8
-  #2    Foo#third_call_with_block(block=#<Proc:0x00007f8bc32f0c28 target.rb:7>) at target.rb:15
+  #1    block {|ten=10|} in second_call at target.rb:8
+  #2    Foo#third_call_with_block(block=#<Proc:0x00007f9283101568 target.rb:7>) at target.rb:15
   #3    Foo#second_call(num=20) at target.rb:7
-  #4    first_call at target.rb:3
+  #4    Foo#first_call at target.rb:3
   #5    <main> at target.rb:23
-(rdbg:init) info
+(rdbg:commands) info
 =>#0    Foo#forth_call(num1=20, num2=10) at target.rb:20 #=> 30
- %self => #<Foo:0x00007f8bc32f0ed0>
- %return => 30
- num1 => 20
- num2 => 10
- @ivar1 => 10
- @ivar2 => 20
-(rdbg:init) q!
+%self => #<Foo:0x00007f92831016d0 @ivar1=10, @ivar2=20>
+%return => 30
+num1 => 20
+num2 => 10
+@ivar1 => 10
+@ivar2 => 20
+(rdbg:commands) q!
 ```

data/README.md

@@ -8,7 +8,7 @@ This debug.rb is replacement of traditional lib/debug.rb standard library which
 New debug.rb has several advantages:
 
 * Fast: No performance penalty on non-stepping mode and non-breakpoints.
-* Remote debugging: Support remote debugging natively.
+* [Remote debugging](#remote-debugging): Support remote debugging natively.
   * UNIX domain socket
   * TCP/IP
   * VSCode/DAP integration ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
@@ -20,11 +20,12 @@ New debug.rb has several advantages:
   * Support threads (almost done) and ractors (TODO).
   * Support suspending and entering to the console debugging with `Ctrl-C` at most of timing.
   * Show parameters on backtrace command.
+  * Support recording & reply debugging.
 
 # Installation
 
 ```
-$ gem install debug --pre
+$ gem install debug
 ```
 
 or specify `-Ipath/to/debug/lib` in `RUBYOPT` or each ruby command-line option, especially for debug this gem development.
@@ -32,7 +33,7 @@ or specify `-Ipath/to/debug/lib` in `RUBYOPT` or each ruby command-line option,
 If you use Bundler, write the following line to your Gemfile.
 
 ```
-gem "debug", ">= 1.0.0.beta"
+gem "debug", ">= 1.0.0"
 ```
 
 # HOW TO USE
@@ -43,25 +44,27 @@ To use a debugger, roughly you will do the following steps:
 2. Run a program with the debugger.
 3. At the breakpoint, enter the debugger console.
 4. Use debug commands.
-    * Query the prgram status (e.g. `p lvar` to see the local variable `lvar`).
-    * Control program flow (e.g. move to the another line with `step`, to the next line with `next`).
-    * Set another breakpoints (e.g. `catch Exception` to set the breakpoints when `Exception` is raiesd).
-    * Change the configuration (e.g. `config set no_color true` to disable coloring).
+    * [Evaluate Ruby expressions](#evaluate) (e.g. `p lvar` to see the local variable `lvar`).
+    * [Query the program status](#information) (e.g. `info` to see information about the current frame).
+    * [Control program flow](#control-flow) (e.g. move to the another line with `step`, to the next line with `next`).
+    * [Set another breakpoint](#breakpoint) (e.g. `catch Exception` to set a breakpoint that'll be triggered when `Exception` is raised).
+    * [Activate tracing in your program](#trace) (e.g. `trace call` to trace method calls).
+    * [Change the configuration](#configuration-1) (e.g. `config set no_color true` to disable coloring).
     * Continue the program (`c` or `continue`) and goto 3.
 
 ## Invoke with the debugger
 
 There are several options for (1) and (2). Please choose your favorite way.
 
-### Modify source code as `binding.pry` and `binding.irb`
+### Modify source code with [`binding.break`](#bindingbreak-method) (similar to `binding.pry` or `binding.irb`)
 
-If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting `binding.break` method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
-After that, you run the program as usuall and you will enter the debug console at breakpoints you inserted.
+If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting [`binding.break`](#bindingbreak-method) method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
+After that, you run the program as usual and you will enter the debug console at breakpoints you inserted.
 
-The following example shows the demonstration of `binding.break`.
+The following example shows the demonstration of [`binding.break`](#bindingbreak-method).
 
 ```shell
-$ cat target.rb                        # Sample prgram
+$ cat target.rb                        # Sample program
 require 'debug'
 
 a = 1
@@ -120,13 +123,13 @@ d => 4
 [1, 2, 3, 4]
 ```
 
-### Invoke the prorgam from the debugger as a traditional debuggers
+### Invoke the program from the debugger as a traditional debuggers
 
 If you don't want to modify the source code, you can set breakpoints with a debug command `break` (`b` for short).
 Using `rdbg` command to launch the program without any modifications, you can run the program with the debugger.
 
 ```shell
-$ cat target.rb                        # Sample prgram
+$ cat target.rb                        # Sample program
 a = 1
 b = 2
 c = 3
@@ -241,16 +244,16 @@ NOTE: If you want to use bundler (`bundle` command), you need to write `gem debu
 
 ### Using VSCode
 
-Like other langauges, you can use this debugger on the VSCode.
+Like other languages, you can use this debugger on the VSCode.
 
-1. Install [VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) 
+1. Install [VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg)
 2. Open `.rb` file (e.g. `target.rb`)
 3. Register breakpoints with "Toggle breakpoint" in Run menu (or type F9 key)
 4. Choose "Start debugging" in "Run" menu (or type F5 key)
 5. You will see a dialog "Debug command line" and you can choose your favorite command line your want to run.
-6. Chosed command line is invoked with `rdbg -c` and VSCode shows the details at breakponts.
+6. Chosen command line is invoked with `rdbg -c` and VSCode shows the details at breakpoints.
 
-Plase refer [Debugging in Visual Studio Code](https://code.visualstudio.com/docs/editor/debugging) for operations on VSCode.
+Please refer [Debugging in Visual Studio Code](https://code.visualstudio.com/docs/editor/debugging) for operations on VSCode.
 
 You can configure the extension in `.vscode/launch.json`.
 Please see the extension page for more details.
@@ -265,7 +268,7 @@ You can use this debugger as a remote debugger. For example, it will help the fo
   * Your application uses pipe for STDIN or STDOUT.
 * Your application is running as a daemon and you want to query the running status (checking a backtrace and so on).
 
-You can run your application as a remote debuggee and the remote debugger console can attach to the debugee anytime.
+You can run your application as a remote debuggee and the remote debugger console can attach to the debuggee anytime.
 
 ### Invoke as a remote debuggee
 
@@ -279,10 +282,10 @@ You can run a script with `rdbg --open target.rb` command and run a `target.rb`
 $ exe/rdbg --open target.rb
 DEBUGGER: Session start (pid: 7773)
 DEBUGGER: Debugger can attach via UNIX domain socket (/home/ko1/.ruby-debug-sock/ruby-debug-ko1-7773)
-DEBUGGER: wait for debuger connection...
+DEBUGGER: wait for debugger connection...
 ```
 
-By deafult, `rdbg --open` uses UNIX domain socket and generates path name automatically (`/home/ko1/.ruby-debug-sock/ruby-debug-ko1-7773` in this case).
+By default, `rdbg --open` uses UNIX domain socket and generates path name automatically (`/home/ko1/.ruby-debug-sock/ruby-debug-ko1-7773` in this case).
 
 You can connect to the debuggee with `rdbg --attach` command (`rdbg -A` for short).
 
@@ -309,7 +312,7 @@ NOTE: If you use `quit` command, only remote console exits and the debuggee prog
 
 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`.
 
-To connect to the debugeee, you need to specify the port.
+To connect to the debuggee, you need to specify the port.
 
 ```shell
 $ rdbg --attach 12345
@@ -324,7 +327,7 @@ If you can modify the program, you can open debugging port by adding `require 'd
 
 If you don't want to stop the program at the beginning, you can also use `require 'debug/open_nonstop'`.
 Using `debug/open_nonstop` is useful if you want to open a backdoor to the application.
-However, it is also danger because it can become antoher vulnerability.
+However, it is also danger because it can become another vulnerability.
 Please use it carefully.
 
 By default, UNIX domain socket is used for the debugging port. To use TCP/IP, you can set the `RUBY_DEBUG_PORT` environment variable.
@@ -336,14 +339,14 @@ $ RUBY_DEBUG_PORT=12345 ruby target.rb
 ## Configuration
 
 You can configure the debugger's behavior with debug commands and environment variables.
-When the debug session is started, initial scripts are loaded so you can put your favorite configurations in the intial scripts.
+When the debug session is started, initial scripts are loaded so you can put your favorite configurations in the initial scripts.
 
 ### Configuration list
 
 You can configure debugger's behavior with environment variables and `config` command. Each configuration has environment variable and the name which can be specified by `config` command.
 
 ```
-# configulation example
+# configuration example
 config set log_level INFO
 config set no_color true
 ```
@@ -354,12 +357,18 @@ config set no_color true
   * `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 lines)
   * `RUBY_DEBUG_SHOW_FRAMES` (`show_frames`): Show n frames on breakpoint (default: 2 frames)
-  * `RUBY_DEBUG_SHOW_INFO_LINES` (`show_info_lines`): Show n lines on info command (default: 10 lines, 0 for unlimited)
-  * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shoten PATH (like $(Gem)/foo.rb)
-  * `RUBY_DEBUG_SKIP_NOSRC` (`skip_nosrc`): Skip on no source code lines (default: false)
-  * `RUBY_DEBUG_SKIP_PATH` (`skip_path`): Skip showing frames for given paths (default: [])
+  * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shorten PATH (like $(Gem)/foo.rb)
   * `RUBY_DEBUG_NO_COLOR` (`no_color`): Do not use colorize (default: false)
   * `RUBY_DEBUG_NO_SIGINT_HOOK` (`no_sigint_hook`): Do not suspend on SIGINT (default: false)
+  * `RUBY_DEBUG_NO_RELINE` (`no_reline`): Do not use Reline library (default: false)
+
+* CONTROL
+  * `RUBY_DEBUG_SKIP_PATH` (`skip_path`): Skip showing/entering frames for given paths (default: [])
+  * `RUBY_DEBUG_SKIP_NOSRC` (`skip_nosrc`): Skip on no source code lines (default: false)
+  * `RUBY_DEBUG_KEEP_ALLOC_SITE` (`keep_alloc_site`): Keep allocation site and p, pp shows it (default: false)
+  * `RUBY_DEBUG_POSTMORTEM` (`postmortem`): Enable postmortem debug (default: false)
+  * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
+  * `RUBY_DEBUG_SIGDUMP_SIG` (`sigdump_sig`): Sigdump signal (default: disabled)
 
 * BOOT
   * `RUBY_DEBUG_NONSTOP` (`nonstop`): Nonstop mode
@@ -376,7 +385,7 @@ config set no_color true
 
 ### Initial scripts
 
-If there is `~/.rdbgrc`, the file is loaded as an initial scripts which contains debug commands) when the debug session is started. 
+If there is `~/.rdbgrc`, the file is loaded as an initial script (which contains debug commands) when the debug session is started.
 
 * `RUBY_DEBUG_INIT_SCRIPT` environment variable can specify the initial script file.
 * You can specify the initial script with `rdbg -x initial_script` (like gdb's `-x` option).
@@ -390,7 +399,12 @@ If there are `~/.rdbgrc.rb` is available, it is also loaded as a ruby script at
 
 On the debug console, you can use the following debug commands.
 
-* `Enter` repeats the last command (useful when repeating `step`s).
+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).
 * `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)
 
@@ -402,10 +416,16 @@ The `<...>` notation means the argument.
 
 * `s[tep]`
   * Step in. Resume the program until next breakable point.
+* `s[tep] <n>`
+  * Step in, resume the program at `<n>`th breakable point.
 * `n[ext]`
   * Step over. Resume the program until next line.
+* `n[ext] <n>`
+  * Step over, same as `step <n>`.
 * `fin[ish]`
   * Finish this frame. Resume the program until the current frame is finished.
+* `fin[ish] <n>`
+  * Finish frames, same as `step <n>`.
 * `c[ontinue]`
   * Resume the program.
 * `q[uit]` or `Ctrl-D`
@@ -470,11 +490,26 @@ The `<...>` notation means the argument.
   * Note that edited file will not be reloaded.
 * `edit <file>`
   * Open <file> on the editor.
-* `i[nfo]`, `i[nfo] l[ocal[s]]`
+* `i[nfo]`
+   * Show information about current frame (local/instance variables and defined constants).
+* `i[nfo] l[ocal[s]]`
   * 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`
+  * Show information about instance variables about `self`.
+* `i[nfo] c[onst[s]]` or `i[nfo] constant[s]`
+  * Show information about accessible constants except toplevel constants.
+* `i[nfo] g[lobal[s]]`
+  * Show information about global variables
+* `i[nfo] ... </pattern/>`
+  * Filter the output with `</pattern/>`.
 * `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>`
+  * Show you available methods and instance variables of the given object.
+  * If the object is a class/module, it also lists its constants.
 * `display`
   * Show display setting.
 * `display <expr>`
@@ -501,11 +536,41 @@ The `<...>` notation means the argument.
   * Evaluate like `p <expr>` on the current frame.
 * `pp <expr>`
   * Evaluate like `pp <expr>` on the current frame.
-* `e[val] <expr>`
+* `eval <expr>`
   * Evaluate `<expr>` on the current frame.
 * `irb`
   * Invoke `irb` on the current frame.
 
+### Trace
+
+* `trace`
+  * Show available tracers list.
+* `trace line`
+  * Add a line tracer. It indicates line events.
+* `trace call`
+  * Add a call tracer. It indicate call/return events.
+* `trace exception`
+  * Add an exception tracer. It indicates raising exceptions.
+* `trace object <expr>`
+  * Add an object tracer. It indicates that an object by `<expr>` is passed as a parameter or a receiver on method call.
+* `trace ... </pattern/>`
+  * Indicates only matched events to `</pattern/>` (RegExp).
+* `trace ... into: <file>`
+  * Save trace information into: `<file>`.
+* `trace off <num>`
+  * Disable tracer specified by `<num>` (use `trace` command to check the numbers).
+* `trace off [line|call|pass]`
+  * Disable all tracers. If `<type>` is provided, disable specified type tracers.
+* `record`
+  * Show recording status.
+* `record [on|off]`
+  * Start/Stop recording.
+* `step back`
+  * Start replay. Step back with the last execution log.
+  * `s[tep]` does stepping forward with the last log.
+* `step reset`
+  * Stop replay .
+
 ### Thread control
 
 * `th[read]`
@@ -525,6 +590,8 @@ The `<...>` notation means the argument.
   * Append `<val>` to `<name>` if it is an array.
 * `config unset <name>`
   * Set <name> to default.
+* `source <file>`
+  * Evaluate lines in `<file>` as debug commands.
 
 ### Help
 
@@ -550,7 +617,7 @@ You can start debugging without `rdbg` command by requiring the following librar
 You need to require one of them at the very beginning of the application.
 Using `ruby -r` (for example `ruby -r debug/start target.rb`) is another way to invoke with debugger.
 
-NOTE: Until Ruby 3.0, there is old `lib/debug.rb` standard library. So that if this gem is not installed, or if `Gemfile` missed to list this gem and `bunde exec` is used, you will see the following output:
+NOTE: Until Ruby 3.0, there is old `lib/debug.rb` standard library. So that if this gem is not installed, or if `Gemfile` missed to list this gem and `bundle exec` is used, you will see the following output:
 
 ```shell
 $ ruby -r debug -e0
@@ -566,7 +633,7 @@ Emacs support available.
 
 #### Start by method
 
-After loading `debug/session`, you can start debug session with the following methods. They are convinient if you want to specifies debug configrations in your program.
+After loading `debug/session`, you can start debug session with the following methods. They are convenient if you want to specify debug configurations in your program.
 
 * `DEBUGGER__.start(**kw)`: start debug session with local console.
 * `DEBUGGER__.open(**kw)`: open debug port with configuration (without configurations open with UNIX domain socket)
@@ -591,15 +658,15 @@ If `do: 'command'` is specified, the debugger suspends the program and run the `
 It is useful if you only want to call a debug command and don't want to stop there.
 
 ```
-def initialzie
+def initialize
   @a = 1
   binding.b do: 'watch @a'
 end
 ```
 
-On this case, register a watch breakpont for `@a` and continue to run.
+On this case, register a watch breakpoint for `@a` and continue to run.
 
-If `pre: 'command'` is specified, the debuger suspends the program and run the `command` as a debug command, and keep suspend.
+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.
 
 ```
@@ -609,7 +676,7 @@ def foo
 end
 ```
 
-On this case, you can see the result of `bar()` everytime when you stops there.
+On this case, you can see the result of `bar()` every time you stop there.
 
 ## rdbg command help
 
@@ -630,7 +697,7 @@ Debug console mode:
     -O, --open                       Start remote debugging with opening the network port.
                                      If TCP/IP options are not given,
                                      a UNIX domain socket will be used.
-        --sock-path=SOCK_PATH        UNIX Doman socket path
+        --sock-path=SOCK_PATH        UNIX Domain socket path
         --port=PORT                  Listening TCP/IP port
         --host=HOST                  Listening TCP/IP host
         --cookie=COOKIE              Set a cookie for connection