debug 1.0.0.beta2 → 1.0.0.beta7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0ed57ff87f1864d86d79c435081b12df6cb35bd4f24a3cb79f4a909887e5f41
-  data.tar.gz: c342d515e9358e0cfdee353b5d5be1fbbb7bcf46cfdf3f925ace7a3acc2b6e90
+  metadata.gz: d545d212530685e0eaf7163bc0b2517befd0edfdc1b083c64ecab6bfcb6958b8
+  data.tar.gz: 6662febf1dccfbc0e7e4ec785578fb5eac2a076fa488a4a3a814582f80fa940f
 SHA512:
-  metadata.gz: 112d49a60540e034752e1c3d3721c213549cae4653c63041c3f3da08cf7bf01624e8a45c0ee88ff31270eef337cf8db3ca8de7d403eea550aff82621050e9e14
-  data.tar.gz: e6800fb760a734419ed43fa04720b0bc75a815f0de4511df7f76a44b9b864c002eb6c9503f74e1a9471d335f671f0db12636e852cc6bac0366ba00d051e29b0b
+  metadata.gz: 3173551c5ada6fb2f7f71656a5762b6a6a6cc541d80d371532abfe1e03188f81ffb397df1a2c8d743c34983e27c5abe6e33ae8d8188502960501801af3aa9ea3
+  data.tar.gz: 59c84ef76b01d8630b764784d68edb7b1e25e2c336cab56a74e23add5f606f14c3dfe2d6cdd9fe3779e328ca8873317d5d7b56a8e5a7951ecc3a081c20c309d8

data/.github/workflows/ruby.yml

@@ -0,0 +1,34 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0', 'head', 'debug']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

@@ -6,4 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.bundle
 /Gemfile.lock
+/lib/debug/debug.so
+.ruby-version

data/CONTRIBUTING.md

@@ -0,0 +1,336 @@
+## Set Up a Development Environment
+
+1. `$ git clone git@github.com:ruby/debug.git`
+2. `$ bundle install`
+3. `$ rake` - this will
+    - Compile the C extension locally (which can also be done solely with `rake compile`).
+    - Run tests.
+    - Re-generate `README.md`.
+
+If you spot any problem, please open an issue.
+
+## Run Tests
+
+### Run all tests
+
+```bash
+$ rake test
+```
+
+### Run specific test(s)
+
+
+```bash
+$ ruby test/debug/bp_test.rb # run all tests in the specified file
+$ ruby test/debug/bp_test.rb -h # to see all the test options
+```
+
+## Generate Tests
+There is a test generator in `debug.rb` project to make it easier to write tests.
+### Quickstart
+This section shows you how to create test file by test generator. For more advanced informations on creating tests, please take a look at [gentest options](#gentest-options). (You can also check by `$bin/gentest -h`)
+#### 1. Create a target file for debuggee.
+Let's say, we created `target.rb` which is located in top level directory of debugger.
+```ruby
+module Foo
+  class Bar
+    def self.a
+      "hello"
+    end
+  end
+  Bar.a
+  bar = Bar.new
+end
+```
+#### 2. Run `gentest` as shown in the example below.
+```shell
+$ bin/gentest target.rb
+```
+#### 3. Debugger will be executed. You can type any debug commands.
+```shell
+$ bin/gentest target.rb
+[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
+=>#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
+=>#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
+=>#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
+INTERNAL_INFO: {"location":"~/workspace/debug/target.rb:3","line":3}
+
+(rdbg)b 7
+ b 7
+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
+=>#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!
+```
+#### 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.
+```ruby
+# frozen_string_literal: true
+
+require_relative '../support/test_case'
+
+module DEBUGGER__
+  class FooTest < TestCase
+    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
+      RUBY
+    end
+    
+    def test_foo
+      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 .*/
+        ])
+        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 .*/
+        ])
+        type 'b 7'
+        assert_line_text(//)
+        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 .*/,
+          //,
+          /Stop by #0  BP - Line  .*/
+        ])
+        type 'q!'
+      end
+    end
+  end
+end
+```
+
+#### gentest options
+You can get more information about `gentest` here.
+
+The default method name is `test_foo` and the class name is `FooTest`. The file name will be `[Lowercase letters with "Test" removed from the class name]_test.rb`.
+```shell
+# run without any options(test method name will be `test_foo`, class name will be `FooTest`, file name will be `foo_test.rb`)
+$ bin/gentest target.rb
+# specify the class name(test method name will be `test_foo`, class name will be `StepTest`, file name will be `step_test.rb`)
+$ bin/gentest target.rb -c StepTest
+# specify the method name(test method name will be `test_step`, class name will be `FooTest`, file name will be `foo_test.rb`)
+$ bin/gentest target.rb -m test_step
+# specify class name and method name(test method name will be `test_step`, class name will be `StepTest`, file name will be `step_test.rb`.)
+$ bin/gentest target.rb -c StepTest -m test_step
+```
+
+## To Update README
+
+This project generates `README.md` from the template `misc/README.md.erb`
+
+So **do not** directly update `README.md`. Instead, you should update the template's source and run
+
+```bash
+$ rake
+```
+
+to reflect the changes on `README.md`.
+
+
+### When to re-generate `README.md`
+
+- After updating `misc/README.md.erb`.
+- After updating `rdbg` executable's options.
+- After updating comments of debugger's commands.
+
+## Manually Test Your Changes
+
+You can manually test your changes with a simple Ruby script + a line of command. The following example will help you check:
+
+- Breakpoint insertion.
+- Resume from the breakpoint.
+- Backtrace display.
+- Information (local variables, ivars..etc.) display.
+- Debugger exit.
+
+
+### Script
+
+```ruby
+# target.rb
+class Foo
+  def first_call
+    second_call(20)
+  end
+
+  def second_call(num)
+    third_call_with_block do |ten|
+      forth_call(num, ten)
+    end
+  end
+
+  def third_call_with_block(&block)
+    @ivar1 = 10; @ivar2 = 20
+
+    yield(10)
+  end
+
+  def forth_call(num1, num2)
+    num1 + num2
+  end
+end
+
+Foo.new.first_call
+```
+
+### Command
+
+```
+$ exe/rdbg -e 'b 20;; c ;; bt ;; info ;; q!' -e c target.rb
+```
+
+### Expect Result
+
+```
+❯ exe/rdbg -e 'b 20;; c ;; bt ;; info ;; q!' -e c target.rb
+[1, 10] in target.rb
+=>    1| class Foo
+      2|   def first_call
+      3|     second_call(20)
+      4|   end
+      5|
+      6|   def second_call(num)
+      7|     third_call_with_block do |ten|
+      8|       forth_call(num, ten)
+      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
+     15|     yield(10)
+     16|   end
+     17|
+     18|   def forth_call(num1, num2)
+     19|     num1 + num2
+=>   20|   end
+     21| end
+     22|
+     23| Foo.new.first_call
+=>#0    Foo#forth_call(num1=20, num2=10) at target.rb:20 #=> 30
+  #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
+=>#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
+  #3    Foo#second_call(num=20) at target.rb:7
+  #4    first_call at target.rb:3
+  #5    <main> at target.rb:23
+(rdbg:init) 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!
+```

data/Gemfile

@@ -2,6 +2,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake"
 gem "rake-compiler"
-gem "minitest", "~> 5.0"
+gem "test-unit", "~> 3.0"

data/README.md

@@ -1,3 +1,5 @@
+[![Ruby](https://github.com/ruby/debug/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/ruby/debug/actions/workflows/ruby.yml?query=branch%3Amaster)
+
 # debug.rb
 
 This library provides debugging functionality to Ruby.
@@ -9,7 +11,7 @@ New debug.rb has several advantages:
 * Remote debugging: Support remote debugging natively.
   * UNIX domain socket
   * TCP/IP
-  * VSCode/DAP integration (TODO)
+  * VSCode/DAP integration ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
 * Extensible: application can introduce debugging support with several methods
   * By `rdbg` command
   * By loading libraries with `-r` command line option
@@ -27,6 +29,16 @@ $ gem install debug --pre
 
 or specify `-Ipath/to/debug/lib` in `RUBYOPT` or each ruby command-line option, especially for debug this gem development.
 
+If you use Bundler, write the following line to your Gemfile. And use rdbg command with -c option.
+
+```
+gem "debug", ">= 1.0.0.beta"
+```
+
+```
+$ rdbg -c bundle exec ruby target.rb
+```
+
 # How to use
 
 ## Invoke with debugger
@@ -49,33 +61,54 @@ To use debugging feature, you can have 3 ways.
 
 ### Local debug console
 
+#### (1) Use `rdbg` command
+
 ```
-# (1) Use `rdbg` command
 $ rdbg target.rb
 $ rdbg -- -r foo -e expr # -- is required to make clear rdbg options and ruby's options
+```
 
-# (2) Use `-r debug/run` command line option
+#### (2) Use `-r debug/run` command line option
 
+```
 $ ruby -r debug/run target.rb
+```
 
-# (3) Write `require 'debug...' in .rb files
+#### (3) Write `require 'debug...'` in .rb files
 
-$ cat target.rb
+```ruby
+# target.rb
 require 'debug/run' # start the debug console
-...
 
-# or
+# ... rest of program ...
+```
 
-$ cat target.rb
-require 'debug/session'  # introduce the functionality
-DEBUGGER__.console       # and start the debug console
 
+```
 $ ruby target.rb
 ```
 
 When you run the program with the debug console, you will see the debug console prompt `(rdbg)`.
 The debuggee program (`target.rb`) is suspended at the beginning of `target.rb`.
 
+
+Alternatively, start the debugger at a specific location in your program using `binding.break` (`binding.b` for short).
+
+```ruby
+# target.rb
+require 'debug' # start the debugger
+
+# ... program ...
+
+binding.break # setup a breakpoint at this line
+
+# ... rest of program ...
+```
+
+```
+$ ruby target.rb
+```
+
 You can type any debugger's command described bellow. "c" or "continue" resume the debuggee program.
 You can suspend the debuggee program and show the debug console with `Ctrl-C`.
 
@@ -143,33 +176,36 @@ $ rdbg  ~/src/rb/target.rb
 
 ### Remote debug (1) UNIX domain socket
 
+#### (1) Use `rdbg` command
+
 ```
-# (1) Use `rdbg` command
 $ rdbg --open target.rb # or rdbg -O target.rb for shorthand
 Debugger can attach via UNIX domain socket (/home/ko1/.ruby-debug-sock/ruby-debug-ko1-5042)
-...
+```
 
-# (2) Use `-r debug/open` command line option
+#### (2) Use `-r debug/open` command line option
 
+```
 $ ruby -r debug/open target.rb
 Debugger can attach via UNIX domain socket (/home/ko1/.ruby-debug-sock/ruby-debug-ko1-5042)
-...
+```
 
-# (3) Write `require 'debug/open' in .rb files
-$ cat target.rb
+#### (3) Write `require 'debug/open'` in .rb files
+
+```ruby
+# target.rb
 require 'debug/open' # open the debugger entry point by UNIX domain socket.
-...
 
 # or
 
-$ cat target.rb
 require 'debug/server' # introduce remote debugging feature
 DEBUGGER__.open        # open the debugger entry point by UNIX domain socket.
 # or DEBUGGER__.open_unix to specify UNIX domain socket.
+```
 
+```
 $ ruby target.rb
 Debugger can attach via UNIX domain socket (/home/ko1/.ruby-debug-sock/ruby-debug-ko1-5042)
-...
 ```
 
 It runs target.rb and accept debugger connection within UNIX domain socket.
@@ -233,40 +269,49 @@ The socket file is located at
 
 You can open the TCP/IP port instead of using UNIX domain socket.
 
+#### (1) Use `rdbg` command
+
 ```
-# (1) Use `rdbg` command
 $ rdbg -O --port=12345 target.rb
 # or
 $ rdbg --open --port=12345 target.rb
 Debugger can attach via TCP/IP (localhost:12345)
-...
+```
 
-# (2) Use `-r debug/open` command line option
+#### (2) Use `-r debug/open` command line option
 
+
+```
 $ RUBY_DEBUG_PORT=12345 ruby -r debug/open target.rb
 Debugger can attach via TCP/IP (localhost:12345)
-...
+```
+
+#### (3) Write `require 'debug/open'` in .rb files
 
-# (3) Write `require 'debug/open' in .rb files
-$ cat target.rb
+```ruby
+# target.rb
 require 'debug/open' # open the debugger entry point.
-...
+```
+
+and run with environment variable RUBY_DEBUG_PORT
 
-# and run with environment variable RUBY_DEBUG_PORT
+```
 $ RUBY_DEBUG_PORT=12345 ruby target.rb
 Debugger can attach via TCP/IP (localhost:12345)
-...
+```
 
-# or
+or
 
-$ cat target.rb
+```ruby
+# target.rb
 require 'debug/server' # introduce remote debugging feature
 DEBUGGER__.open(port: 12345)
 # or DEBUGGER__.open_tcp(port: 12345)
+```
 
+```
 $ ruby target.rb
 Debugger can attach via TCP/IP (localhost:12345)
-...
 ```
 
 You can also specify the host with the `RUBY_DEBUG_HOST` environment variable. And also `DEBUGGER__.open` method accepts a `host:` keyword parameter. If the host is not given, `localhost` will be used.
@@ -280,26 +325,45 @@ $ rdbg --attach hostname 12345
 
 ### Initial scripts
 
-If there are `.rdbgrc` files are there at the current directory and the home directory, files are loaded as initial scripts which contains debugger commands. `RUBY_DEBUG_INIT_SCRIPT` environment variable can specify the initial script file.
+If there are `~/.rdbgrc`, the file is loaded as initial scripts which contains debugger commands at the beginning of debug session. `RUBY_DEBUG_INIT_SCRIPT` environment variable can specify the initial script file. You can write configurations in a file. For example, you can set break points with `break file:123` in `~/.rdbgrc`.
 
-Initial scripts are evaluated at the first suspend timing (generally, it is the beginning of the target script). For example, you can set break points with `break file:123`.
+If there are `~/.rdbgrc.rb` is available, it is loaded as a ruby script at same timing.
 
-If there are `.rdbgrc.rb` files at the current directory and the home directory, files are loaded as a ruby script at the initializing timing.
+### Configurations
 
-### Environment variables
+You can configure debugger's setting with environment variables and `config` command.
+You can write any configuration into `~/.rdbgrc` like:
 
-You can control debuggee's behavior with environment variables:
+```
+config set log_level INFO
+config set no_color true
+```
 
-* `RUBY_DEBUG_NONSTOP`: 1 for nonstop at the beginning of program.
-* `RUBY_DEBUG_INIT_SCRIPT`: Initial script path loaded at the first stop.
-* `RUBY_DEBUG_COMMANDS`: Debug commands invoked at the first stop. Commands should be separated by ';;'.
-* `RUBY_DEBUG_SHOW_SRC_LINES`: Show n lines source code on breakpoint (default: 10 lines).
-* `RUBY_DEBUG_SHOW_FRAMES`: Show n frames on breakpoint (default: 2 frames).
 
-* Remote debugging
-  * `RUBY_DEBUG_PORT`: TCP/IP remote debugging: port to open.
-  * `RUBY_DEBUG_HOST`: TCP/IP remote debugging: host (localhost if not given) to open.
-  * `RUBY_DEBUG_SOCK_DIR`: UNIX Domain Socket remote debugging: socket directory to open.
+* 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 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_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)
+
+* BOOT
+  * `RUBY_DEBUG_NONSTOP` (`nonstop`): Nonstop mode
+  * `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_NO_RC` (`no_rc`): ignore loading ~/.rdbgrc(.rb)
+  * `RUBY_DEBUG_HISTORY` (`history`): save and load history file (default: ~/.rdbg_history)
+
+* REMOTE
+  * `RUBY_DEBUG_PORT` (`port`): TCP/IP remote debugging: port
+  * `RUBY_DEBUG_HOST` (`host`): TCP/IP remote debugging: host (localhost if not given)
+  * `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
+  * `RUBY_DEBUG_COOKIE` (`cookie`): Cookie for negotiation
 
 ## Debug command on the debug console
 
@@ -321,10 +385,14 @@ The `<...>` notation means the argument.
   * Finish this frame. Resume the program until the current frame is finished.
 * `c[ontinue]`
   * Resume the program.
-* `q[uit]` or exit or `Ctrl-D`
+* `q[uit]` or `Ctrl-D`
   * Finish debugger (with the debuggee process on non-remote debugging).
-* `kill` or `q[uit]!`
-  * Stop the debuggee process.
+* `q[uit]!`
+  * Same as q[uit] but without the confirmation prompt.
+* `kill`
+  * Stop the debuggee process with `Kernal#exit!`.
+* `kill!`
+  * Same as kill but without the confirmation prompt.
 
 ### Breakpoint
 
@@ -338,15 +406,19 @@ The `<...>` notation means the argument.
    * Set breakpoint on the method `<class>#<name>`.
 * `b[reak] <expr>.<name>`
    * Set breakpoint on the method `<expr>.<name>`.
-* `b[reak] ... if <expr>`
+* `b[reak] ... if: <expr>`
   * break if `<expr>` is true at specified location.
-* `b[reak] if <expr>`
-  * break if `<expr>` is true at any lines.
+* `b[reak] ... pre: <command>`
+  * break and run `<command>` before stopping.
+* `b[reak] ... do: <command>`
+  * break and run `<command>`, and continue.
+* `b[reak] if: <expr>`
+  * break if: `<expr>` is true at any lines.
   * Note that this feature is super slow.
 * `catch <Error>`
   * Set breakpoint on raising `<Error>`.
-* `watch <expr>`
-  * Stop the execution when the result of <expr> is changed.
+* `watch @ivar`
+  * Stop the execution when the result of current scope's `@ivar` is changed.
   * Note that this feature is super slow.
 * `del[ete]`
   * delete all breakpoints.
@@ -357,6 +429,12 @@ The `<...>` notation means the argument.
 
 * `bt` or `backtrace`
   * Show backtrace (frame) information.
+* `bt <num>` or `backtrace <num>`
+  * Only shows first `<num>` frames.
+* `bt /regexp/` or `backtrace /regexp/`
+  * Only shows frames with method name or location info that matches `/regexp/`.
+* `bt <num> /regexp/` or `backtrace <num> /regexp/`
+  * Only shows first `<num>` frames with method name or location info that matches `/regexp/`.
 * `l[ist]`
   * Show current frame's source code.
   * Next `list` command shows the successor lines.
@@ -369,11 +447,11 @@ The `<...>` notation means the argument.
   * Note that edited file will not be reloaded.
 * `edit <file>`
   * Open <file> on the editor.
-* `i[nfo]`
+* `i[nfo]`, `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] <expr>`
-  * Show information about the result of <expr>.
+* `i[nfo] th[read[s]]`
+  * Show all threads (same as `th[read]`).
 * `display`
   * Show display setting.
 * `display <expr>`
@@ -388,13 +466,13 @@ The `<...>` notation means the argument.
 ### Frame control
 
 * `f[rame]`
-  * Show current frame.
+  * Show the current frame.
 * `f[rame] <framenum>`
-  * Specify frame. Evaluation are run on this frame environment.
+  * Specify a current frame. Evaluation are run on specified frame.
 * `up`
-  * Specify upper frame.
+  * Specify the upper frame.
 * `down`
-  * Specify down frame.
+  * Specify the lower frame.
 
 ### Evaluate
 
@@ -414,6 +492,19 @@ The `<...>` notation means the argument.
 * `th[read] <thnum>`
   * Switch thread specified by `<thnum>`.
 
+### Configuration
+
+* `config`
+  * Show all configuration with description.
+* `config <name>`
+  * Show current configuration of <name>.
+* `config set <name> <val>` or `config <name> = <val>`
+  * Set <name> to <val>.
+* `config append <name> <val>` or `config <name> << <val>`
+  * Append `<val>` to `<name>` if it is an array.
+* `config unset <name>`
+  * Set <name> to default.
+
 ### Help
 
 * `h[elp]`
@@ -429,35 +520,61 @@ exe/rdbg [options] -- [debuggee options]
 
 Debug console mode:
     -n, --nonstop                    Do not stop at the beginning of the script.
-    -e [COMMAND]                     execute debug command at the beginning of the script.
-    -O, --open                       Start debuggee with opening the debugger port.
+    -e DEBUG_COMMAND                 Execute debug command at the beginning of the script.
+    -x, --init-script=FILE           Execute debug command in the FILE.
+        --no-rc                      Ignore ~/.rdbgrc
+        --no-color                   Disable colorize
+    -c, --command                    Enable command mode.
+                                     The first argument should be a command name in $PATH.
+                                     Example: 'rdbg -c bundle exec rake test'
+
+    -O, --open                       Start remote debugging with opening the network port.
                                      If TCP/IP options are not given,
                                      a UNIX domain socket will be used.
-        --port=[PORT]                Listening TCP/IP port
-        --host=[HOST]                Listening TCP/IP host
+        --sock-path=SOCK_PATH        UNIX Doman socket path
+        --port=PORT                  Listening TCP/IP port
+        --host=HOST                  Listening TCP/IP host
+        --cookie=COOKIE              Set a cookie for connection
 
   Debug console mode runs Ruby program with the debug console.
 
-  exe/rdbg target.rb foo bar                 starts like 'ruby target.rb foo bar'.
-  exe/rdbg -- -r foo -e bar                  starts like 'ruby -r foo -e bar'.
-  exe/rdbg -O target.rb foo bar              starts and accepts attaching with UNIX domain socket.
-  exe/rdbg -O --port 1234 target.rb foo bar  starts accepts attaching with TCP/IP localhost:1234.
-  exe/rdbg -O --port 1234 -- -r foo -e bar   starts accepts attaching with TCP/IP localhost:1234.
+  'rdbg target.rb foo bar'                starts like 'ruby target.rb foo bar'.
+  'rdbg -- -r foo -e bar'                 starts like 'ruby -r foo -e bar'.
+  'rdbg -c rake test'                     starts like 'rake test'.
+  'rdbg -c -- rake test -t'               starts like 'rake test -t'.
+  'rdbg -c bundle exec rake test'         starts like 'bundle exec rake test'.
+  'rdbg -O target.rb foo bar'             starts and accepts attaching with UNIX domain socket.
+  'rdbg -O --port 1234 target.rb foo bar' starts accepts attaching with TCP/IP localhost:1234.
+  'rdbg -O --port 1234 -- -r foo -e bar'  starts accepts attaching with TCP/IP localhost:1234.
 
 Attach mode:
     -A, --attach                     Attach to debuggee process.
 
   Attach mode attaches the remote debug console to the debuggee process.
 
-  'exe/rdbg -A' tries to connect via UNIX domain socket.
+  'rdbg -A'           tries to connect via UNIX domain socket.
                       If there are multiple processes are waiting for the
                       debugger connection, list possible debuggee names.
-  'exe/rdbg -A path' tries to connect via UNIX domain socket with given path name.
-  'exe/rdbg -A port' tries to connect localhost:port via TCP/IP.
-  'exe/rdbg -A host port' tries to connect host:port via TCP/IP.
+  'rdbg -A path'      tries to connect via UNIX domain socket with given path name.
+  'rdbg -A port'      tries to connect to localhost:port via TCP/IP.
+  'rdbg -A host port' tries to connect to host:port via TCP/IP.
+
+Other options:
+    -h, --help                       Print help
+        --util=NAME                  Utility mode (used by tools)
+
+NOTE
+  All messages communicated between a debugger and a debuggee are *NOT* encrypted.
+  Please use the remote debugging feature carefully.
 
 ```
 
 # Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/debug.
+
+Please also check the [contributing guideline](/CONTRIBUTING.md).
+
+# Acknowledgement
+
+* Some tests are based on [deivid-rodriguez/byebug: Debugging in Ruby 2](https://github.com/deivid-rodriguez/byebug)