debug 1.0.0.beta4 → 1.0.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebaae12c10e51036f850fd1cbcde66d891a1e50b64bc5d96bfdab610cb42fd1d
-  data.tar.gz: e62eee365aa1409c650049ccb8ed237854aeed6f7a066dc2b84f96c9cffefd12
+  metadata.gz: '039bd2cbfdb3a67bbd91603b077a4f4784235fb0c7b48721a4b9f27b493231c6'
+  data.tar.gz: f9605d076dff9d8571e70245baa5c2e97c2377cc7f92ee627cbc1f051361217b
 SHA512:
-  metadata.gz: 2aa2b044268220dc79d72850f6366474fff647fa6893360044ce64a8a97e4d759e414da6c39dac52a6b33593512675091ed4fb4a7399c1357b344d342f3c812f
-  data.tar.gz: 506d0afeb3e3926da6631e99234fd2ba4c96220d5def5a95d0e51afa54ae28beb19c30873c3c0cf9a95fa975023364f7088a0190d26452e307e715925e21a78c
+  metadata.gz: f222a8b1ec58fd6f5264e61ee8613e6ed229c9ebff73c6b4904c4c6c2bded0d625b776fb510b23dec57636cf576a68d471f0b91d7b01d36f8baad741ff64fd38
+  data.tar.gz: 152431ba38203334bbf1c7449ff36a6d49f5116aaa78c017ca5ffa6d695ca87be06bc011822d0bbd325e15c46504385adf4ef94e74ebd37f97468f049da910e8

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

@@ -9,3 +9,4 @@
 *.bundle
 /Gemfile.lock
 /lib/debug/debug.so
+.ruby-version

data/CONTRIBUTING.md

@@ -1,3 +1,51 @@
+## 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
+# or
+$ ruby bin/test-unit.rb
+```
+
+### 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
+```
+
+## 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:

data/Gemfile

@@ -4,4 +4,4 @@ gemspec
 
 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.
@@ -49,28 +51,33 @@ 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
-... rest of program ...
 
 # or
 
-$ cat target.rb
 require 'debug/session'  # introduce the functionality
 DEBUGGER__.console       # and start the debug console
-... rest of program ...
+# ... rest of program ...
+```
 
+```
 $ ruby target.rb
 ```
 
@@ -144,33 +151,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.
@@ -234,40 +244,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
-$ cat target.rb
+#### (3) Write `require 'debug/open'` in .rb files
+
+```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.
@@ -296,10 +315,10 @@ You can control debuggee's behavior with environment variables:
 * `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
@@ -350,8 +369,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.
@@ -377,7 +396,7 @@ The `<...>` notation means the argument.
 * `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] th[read[s]]
+* `i[nfo] th[read[s]]`
   * Show all threads (same as `th[read]`).
 * `display`
   * Show display setting.
@@ -434,13 +453,16 @@ 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 COMMAND                       execute debug command at the beginning of the script.
+    -x, --init-script=FILE           execute debug command in the FILE.
+
+    -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
-        --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.
 
@@ -462,6 +484,15 @@ Attach mode:
   '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
+    -c, --command                    Command mode (first argument is command name)
+        --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
@@ -469,3 +500,7 @@ 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)

data/debug.gemspec

@@ -24,4 +24,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions    = ['ext/debug/extconf.rb']
+
+  spec.add_dependency "irb" # for its color_printer class, which was added after 1.3
 end

data/exe/rdbg

@@ -15,11 +15,18 @@ when :start
   end
 
   ::DEBUGGER__.config_to_env(config)
-  exec("#{RbConfig.ruby}", "-I#{File.expand_path(File.dirname(__dir__))}/lib", "-r" + start_mode, *ARGV)
+
+  cmd = config[:command] ? ARGV.shift : RbConfig.ruby
+  exec({'RUBYOPT' => "-I#{File.expand_path(File.dirname(__dir__))}/lib -r #{start_mode}"},
+       cmd, *ARGV)
 
 when :attach
   require_relative "../lib/debug/client"
 
+  config.each{|k, v|
+    DEBUGGER__::CONFIG[k] = v
+  }
+
   begin
     if ARGV.empty? && config[:port]
       connect [config[:host], config[:port]].compact

data/ext/debug/debug.c

@@ -22,7 +22,7 @@ static VALUE rb_cFrameInfo;
 static VALUE
 di_entry(VALUE loc, VALUE self, VALUE binding, VALUE iseq, VALUE klass, VALUE depth)
 {
-    return rb_struct_new(rb_cFrameInfo, loc, self, binding, iseq, klass, depth, Qnil, Qnil, Qnil);
+    return rb_struct_new(rb_cFrameInfo, loc, self, binding, iseq, klass, depth, Qnil, Qnil, Qnil, Qnil, Qnil);
 }
 
 static int
@@ -49,6 +49,7 @@ di_body(const rb_debug_inspector_t *dc, void *ptr)
     long i;
 
     for (i=1; i<len; i++) {
+        VALUE loc, e;
         VALUE iseq = rb_debug_inspector_frame_iseq_get(dc, i);
 
         if (!NIL_P(iseq)) {
@@ -56,13 +57,13 @@ di_body(const rb_debug_inspector_t *dc, void *ptr)
             if (!NIL_P(path) && str_start_with(path, skip_path_prefix)) continue;
         }
 
-        VALUE loc = RARRAY_AREF(locs, i);
-        VALUE e = di_entry(loc,
-                           rb_debug_inspector_frame_self_get(dc, i),
-                           rb_debug_inspector_frame_binding_get(dc, i),
-                           iseq,
-                           rb_debug_inspector_frame_class_get(dc, i),
-                           INT2FIX(len - i));
+        loc = RARRAY_AREF(locs, i);
+        e = di_entry(loc,
+                     rb_debug_inspector_frame_self_get(dc, i),
+                     rb_debug_inspector_frame_binding_get(dc, i),
+                     iseq,
+                     rb_debug_inspector_frame_class_get(dc, i),
+                     INT2FIX(len - i));
         rb_ary_push(ary, e);
     }
 

data/lib/debug/breakpoint.rb

@@ -1,3 +1,5 @@
+require_relative 'color'
+
 module DEBUGGER__
   class Breakpoint
     attr_reader :key
@@ -55,9 +57,24 @@ module DEBUGGER__
         ""
       end
     end
+
+    def description
+      to_s
+    end
+
+    class << self
+      include Color
+
+      def generate_label(name)
+        colorize(" BP - #{name} ", [:YELLOW, :BOLD, :REVERSE])
+      end
+    end
   end
 
   class LineBreakpoint < Breakpoint
+    LABEL = generate_label("Line")
+    PENDING_LABEL = generate_label("Line (pending)")
+
     attr_reader :path, :line, :iseq
 
     def initialize path, line, cond: nil, oneshot: false, hook_call: true
@@ -186,9 +203,9 @@ module DEBUGGER__
       oneshot = @oneshot ? " (oneshot)" : ""
 
       if @iseq
-        "line bp #{@path}:#{@line} (#{@type})#{oneshot}" + super
+        "#{LABEL} #{@path}:#{@line} (#{@type})#{oneshot}" + super
       else
-        "line bp (pending) #{@path}:#{@line}#{oneshot}" + super
+        "#{PENDING_LABEL} #{@path}:#{@line}#{oneshot}" + super
       end
     end
 
@@ -198,9 +215,13 @@ module DEBUGGER__
   end
 
   class CatchBreakpoint < Breakpoint
+    LABEL = generate_label("Catch")
+    attr_reader :last_exc
+
     def initialize pat
       @pat = pat.freeze
       @key = [:catch, @pat].freeze
+      @last_exc = nil
 
       super()
     end
@@ -208,18 +229,30 @@ module DEBUGGER__
     def setup
       @tp = TracePoint.new(:raise){|tp|
         exc = tp.raised_exception
+        should_suspend = false
         exc.class.ancestors.each{|cls|
-          suspend if @pat === cls.name
+          if @pat === cls.name
+            should_suspend = true
+            @last_exc = exc
+            break
+          end
         }
+        suspend if should_suspend
       }
     end
 
     def to_s
-      "catch bp #{@pat.inspect}"
+      "#{LABEL} #{@pat.inspect}"
+    end
+
+    def description
+      "#{@last_exc.inspect} is raised."
     end
   end
 
   class CheckBreakpoint < Breakpoint
+    LABEL = generate_label("Check")
+
     def initialize expr
       @expr = expr.freeze
       @key = [:check, @expr].freeze
@@ -231,6 +264,8 @@ module DEBUGGER__
       @tp = TracePoint.new(:line){|tp|
         next if tp.path.start_with? __dir__
         next if tp.path.start_with? '<internal:'
+        # Skip when `JSON.generate` is called during tests
+        next if tp.defined_class.to_s == '#<Class:JSON>' and ENV['RUBY_DEBUG_TEST_MODE']
 
         if safe_eval tp.binding, @expr
           suspend
@@ -239,21 +274,24 @@ module DEBUGGER__
     end
 
     def to_s
-      "check bp: #{@expr}"
+      "#{LABEL} #{@expr}"
     end
   end
 
-  class WatchExprBreakpoint < Breakpoint
-    def initialize expr, current
-      @expr = expr.freeze
-      @key = [:watch, @expr].freeze
+  class WatchIVarBreakpoint < Breakpoint
+    LABEL = generate_label("Watch")
+
+    def initialize ivar, object, current
+      @ivar = ivar.to_sym
+      @object = object
+      @key = [:watch, @ivar].freeze
 
       @current = current
       super()
     end
 
-    def watch_eval b
-      result = b.eval(@expr)
+    def watch_eval
+      result = @object.instance_variable_get(@ivar)
       if result != @current
         begin
           @prev = @current
@@ -263,7 +301,7 @@ module DEBUGGER__
           remove_instance_variable(:@prev)
         end
       end
-    rescue Exception => e
+    rescue Exception
       false
     end
 
@@ -272,20 +310,25 @@ module DEBUGGER__
         next if tp.path.start_with? __dir__
         next if tp.path.start_with? '<internal:'
 
-        watch_eval(tp.binding)
+        watch_eval
       }
     end
 
     def to_s
-      if defined? @prev
-        "watch bp: #{@expr} = #{@prev} -> #{@current}"
-      else
-        "watch bp: #{@expr} = #{@current}"
-      end
+      value_str =
+        if defined?(@prev)
+          "#{@prev} -> #{@current}"
+        else
+          "#{@current}"
+        end
+      "#{LABEL} #{@object} #{@ivar} = #{value_str}"
     end
   end
 
   class MethodBreakpoint < Breakpoint
+    LABEL = generate_label("Method")
+    PENDING_LABEL = generate_label("Method (pending)")
+
     attr_reader :sig_method_name, :method
 
     def initialize b, klass_name, op, method_name, cond
@@ -345,18 +388,22 @@ module DEBUGGER__
         retried = false
         @tp.enable(target: @method)
 
-      rescue ArgumentError => e
+      rescue ArgumentError
         raise if retried
         retried = true
+        sig_method_name = @sig_method_name
 
         # maybe C method
         @klass.module_eval do
-          orig_name = @sig_method_name + '__orig__'
-          alias_method orig_name, @sig_method_name
-          define_method(@sig_method_name) do |*args|
+          orig_name = sig_method_name + '__orig__'
+          alias_method orig_name, sig_method_name
+          define_method(sig_method_name) do |*args|
             send(orig_name, *args)
           end
         end
+
+        # re-collect the method object after the above patch
+        search_method
         retry
       end
     rescue Exception
@@ -369,9 +416,9 @@ module DEBUGGER__
 
     def to_s
       if @method
-        "method bp: #{sig}"
+        "#{LABEL} #{sig}"
       else
-        "method bp (pending): #{sig}"
+        "#{PENDING_LABEL} #{sig}"
       end + super
     end
   end