debug 1.0.0.beta1 → 1.0.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99f9de5fc37782d330788a745b34666e07d37c9e168eb7b0361d3b51b8247b56
-  data.tar.gz: 3e6941a9b066ec0965e576b87c8e0cc0bc787571fa5331ca962d906611c368e5
+  metadata.gz: fffc4898e989a76e77a9076407cc1ba6d31b13a531e739c8972afe71bf049285
+  data.tar.gz: 190c18099e1078e00786dde75819b0b793647cd9508b0577e88d93d6a06c045c
 SHA512:
-  metadata.gz: a279de53e047d52c18c0b1c726da4bbf6efbd116f2957f3fa1c106fec929bb0dc903274d9fce8bb03a787f7ca31edd09d54a09b572027485c5a985205e518582
-  data.tar.gz: 5c436bdfa54ab8d2ece8c07fdac31481f0a9e4922ac433e871c09dd0b161d812eaf7c417189e0e9582421d8405a5169ec826065930c3a7441fdd72953c2786de
+  metadata.gz: 647e6c227bded49c962b8d6934557a26930664f5f1ddd57fd596c6651b1c655c1c77e64d5cbba28d2125cdd8a27817e33dc94d465d01f6b43b7f0be61ee30a35
+  data.tar.gz: ceb4dbf7b9479dc54ff5af725e973985493650ca9aaebd16878c4669fa037ae2ee1ec9ddddf83eb25dd65dc2057d0419a74005ec5d74c98585d855eb918e53bb

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,32 +61,34 @@ 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
 
-$ cat target.rb
-require 'debug/session'  # introduce the functionality
-DEBUGGER__.console       # and start the debug console
+# ... rest of program ...
+```
 
+```
 $ 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 beggining of `target.rb`.
+The debuggee program (`target.rb`) is suspended at the beginning of `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`.
@@ -137,48 +151,51 @@ $ rdbg  ~/src/rb/target.rb
  b => 2
  c => 3
 
-(rdbg) c                                                # Contineu the program ("c" is a short name of "continue")
+(rdbg) c                                                # Continue the program ("c" is a short name of "continue")
 [6]
 ```
 
 ### 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
 
-# (3) Write `require 'debug/open' in .rb files
-$ cat target.rb
+```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.
-The debuggee process waits for debugger connection at the beggining of `target.rb` like that:
+The debuggee process waits for debugger connection at the beginning of `target.rb` like that:
 
 ```
 $ rdbg -O ~/src/rb/target.rb
 DEBUGGER: Debugger can attach via UNIX domain socket (/home/ko1/.ruby-debug-sock/ruby-debug-ko1-29828)
-DEBUGGER: wait for debuger connection...
+DEBUGGER: wait for debugger connection...
 ```
 
 You can attach the program with the following command:
@@ -204,7 +221,7 @@ and you can input any debug commands. `c` (or `continue`) continues the debuggee
 You can detach the debugger from the debugger process with `quit` command.
 You can re-connect to the debuggee process by `rdbg -A` command again, and the debuggee process suspends the execution (and debugger can input any debug commands).
 
-If you don't want to stop the debuggee process at the beggining of debuggee process (`target.rb`), you can use the fowllowings to specify "non-stop" option.
+If you don't want to stop the debuggee process at the beginning of debuggee process (`target.rb`), you can use the following to specify "non-stop" option.
 
 * Use `rdbg -n` option
 * Set the environment variable `RUBY_DEBUG_NONSTOP=1`
@@ -233,40 +250,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,25 +306,23 @@ $ 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.
-
-Initial scripts are evaluted at the first suspend timing (generally, it is the beggining of the target script). For example, you can set break points with `break file:123`.
+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`.
 
-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.
+If there are `~/.rdbgrc.rb` is available, it is loaded as a ruby script at same timing.
 
 ### Environment variables
 
 You can control debuggee's behavior with environment variables:
 
-* `RUBY_DEBUG_NONSTOP`: 1 for nonstop at the beggining of program.
+* `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_PATH`: UNIX Domain Socket remote debugging: socket path to open.
   * `RUBY_DEBUG_SOCK_DIR`: UNIX Domain Socket remote debugging: socket directory to open.
 
 ## Debug command on the debug console
@@ -308,7 +332,7 @@ You can control debuggee's behavior with environment variables:
 * [debug command compare sheet - Google Sheets](https://docs.google.com/spreadsheets/d/1TlmmUDsvwK4sSIyoMv-io52BUUz__R5wpu-ComXlsw0/edit?usp=sharing)
 
 You can use the following debug commands. Each command should be written in 1 line.
-The `[...]` notation means this part can be elimiante. For example, `s[tep]` means `s` or `step` are valid command. `ste` is not valid.
+The `[...]` notation means this part can be eliminate. For example, `s[tep]` means `s` or `step` are valid command. `ste` is not valid.
 The `<...>` notation means the argument.
 
 ### Control flow
@@ -321,10 +345,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
 
@@ -345,8 +373,8 @@ The `<...>` notation means the argument.
   * 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.
@@ -366,14 +394,14 @@ The `<...>` notation means the argument.
   * Show current frame's source code from the line <start> to <end> if given.
 * `edit`
   * Open the current file on the editor (use `EDITOR` environment variable).
-  * Note that editted file will not be reloaded.
+  * 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 +416,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 environement.
+  * 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
 
@@ -428,33 +456,50 @@ The `<...>` notation means the argument.
 exe/rdbg [options] -- [debuggee options]
 
 Debug console mode:
-    -n, --nonstop                    Do not stop at the beggining of the script.
-    -e [COMMAND]                     execute debug command at the beggining of the script.
-    -O, --open                       Start debuggee with opning the debagger port.
+    -n, --nonstop                    Do not stop at the beginning of the script.
+    -e 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 -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' tris 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.
 
 ```
 
@@ -462,3 +507,8 @@ Attach mode:
 
 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)