debug 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 121cdb1003971d234dbeb40878f693d06053fa32f28024c5d2a7c0e0fd6d3719
-  data.tar.gz: fd95c68d4bf99b38a83cef1a6851680bb9abb65d39fa9fc69a94d248295a5829
+  metadata.gz: cb9c418ee481ed3b473973d522bb811949f6123501709d3385d9b2bf2a46d993
+  data.tar.gz: d0036bac1930ec7e920e9faeb66556a4a9132342ed604a909e15f9d02b4d6963
 SHA512:
-  metadata.gz: 4354a11670db6e0fd49e4b8151b268a08c7843c80ccd36b5c492cf5fabc7b42c6632939905b9912c81434f5513e36dac8378686b5d47c274248c523eea88a0c8
-  data.tar.gz: e22274473f567bed800c25d46a46d32adf263f070e8147cd71778ef9cbd95b8e239e2912b226892f032266a92322045a62e7f9c908f176e601a984e254acd2a7
+  metadata.gz: e9cb09ddeee150eac35f5f3044106f482e54e16b41cee4ab6d0678fa92a2c1aefad350412bdc00997892733cf0a58312372d3f40c0f22d5262223de46f31cd9b
+  data.tar.gz: 68a846cc25aca6aab1429b3b36da57977c7c5671b21e9c6381f6d0b6d5fe7d28979fac53d1958da4de00c10445722a3fe1e386a871ee8b5638b3bf541cbf19ad

data/CONTRIBUTING.md

@@ -14,15 +14,27 @@ If you spot any problem, please open an issue.
 ### Run all tests
 
 ```bash
-$ rake test
+$ rake test_all
+```
+
+### Run all console tests
+
+```bash
+$ rake test_console
+```
+
+### Run all protocol (DAP & CDP) tests
+
+```bash
+$ rake test_protocol
 ```
 
 ### 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
+$ ruby test/console/break_test.rb # run all tests in the specified file
+$ ruby test/console/break_test.rb -h # to see all the test options
 ```
 
 ## Generate Tests
@@ -316,9 +328,30 @@ Sends request to rdbg to add a breakpoint.
 
 Sends request to rdbg to delete a breakpoint.
 
-- req_set_exception_breakpoints
+- req_set_exception_breakpoints(breakpoints)
+
+Sends request to rdbg to set exception breakpoints. e.g.
 
-Sends request to rdbg to set exception breakpoints.
+```rb
+req_set_exception_breakpoints([{ name: "RuntimeError", condition: "a == 1" }])
+```
+
+Please note that `setExceptionBreakpoints` resets all exception breakpoints in every request. 
+
+So the following code will only set breakpoint for `Exception`.
+
+```rb
+req_set_exception_breakpoints([{ name: "RuntimeError" }])
+req_set_exception_breakpoints([{ name: "Exception" }])
+```
+
+This means you can also use
+
+```rb
+req_set_exception_breakpoints([])
+```
+
+to clear all exception breakpoints.
 
 - req_continue
 
@@ -348,17 +381,35 @@ Sends request to rdbg to terminate the debuggee.
 
 Passes if reattaching to rdbg is successful.
 
-- assert_hover_result(expected, expression: nil)
+- assert_hover_result(expected, expression)
+
+Passes if result of `expression` matches `expected`.
+
+`expected` need to be a Hash object as follows:
+
+`assert_hover_result({value: '2', type: 'Integer'}, 'a')`
+
+NOTE: `value` and `type` need to be strings.
+
+- assert_repl_result(expected, expression)
+
+Passes if result of `expression` matches `expected`.
+
+`expected` need to be a Hash object as follows:
 
-Passes if result of `expression` is equal to `expected`.
+`assert_repl_result({value: '2', type: 'Integer'}, 'a')`
 
-- assert_repl_result(expected, expression: nil)
+NOTE: `value` and `type` need to be strings.
 
-Passes if result of `expression` is equal to `expected`.
+- assert_watch_result(expected, expression)
 
-- assert_watch_result(expected, expression: nil)
+Passes if result of `expression` matches `expected`.
 
-Passes if result of `expression` is equal to `expected`.
+`expected` need to be a Hash object as follows:
+
+`assert_watch_result({value: '2', type: 'Integer'}, 'a')`
+
+NOTE: `value` and `type` need to be strings.
 
 - assert_line_num(expected)
 
@@ -372,6 +423,23 @@ An variable entry looks like this: `{ name: "bar", value: "nil", type: "NilClass
 
 Please note that both `value` and `type` need to be strings.
 
+- assert_threads_result(expected)
+
+Passes if both conditions are true:
+
+1. The number of expected patterns matches the number of threads.
+2. Every pattern matches a thread name. Notice that the order of threads info is not guaranteed.
+
+Example:
+
+```
+assert_threads_result(
+  [
+    /\.rb:\d:in `<main>'/,
+    /\.rb:\d:in `block in foo'/
+  ]
+)
+```
 
 ## To Update README
 

data/README.md

@@ -9,11 +9,15 @@ New debug.rb has several advantages:
 
 * Fast: No performance penalty on non-stepping mode and non-breakpoints.
 * [Remote debugging](#remote-debugging): Support remote debugging natively.
-  * UNIX domain socket
+  * UNIX domain socket (UDS)
   * TCP/IP
-  * Integration with rich debugger frontend
-    * VSCode/DAP ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
-    * Chrome DevTools
+  * Integration with rich debugger frontends
+
+     Frontend |  [Console](https://github.com/ruby/debug#invoke-as-a-remote-debuggee) | [VSCode](https://github.com/ruby/debug#vscode-integration) | [Chrome DevTool](#chrome-devtool-integration) |
+     ---|---|---|---|
+     Connection | UDS, TCP/IP | UDS, TCP/IP | TCP/IP |
+     Requirement | No | [vscode-rdbg](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) | Chrome |
+
 * Extensible: application can introduce debugging support with several ways:
   * By `rdbg` command
   * By loading libraries with `-r` command line option
@@ -38,6 +42,9 @@ If you use Bundler, write the following line to your Gemfile.
 gem "debug", ">= 1.0.0"
 ```
 
+(The version constraint is important; `debug < 1.0.0` is an older,
+abandoned gem that is completely different from this product.)
+
 # HOW TO USE
 
 To use a debugger, roughly you will do the following steps:
@@ -134,7 +141,7 @@ d => 4
 ### 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.
+Using `rdbg` command (or `bundle exec rdbg`) to launch the program without any modifications, you can run the program with the debugger.
 
 ```shell
 $ cat target.rb                        # Sample program
@@ -280,7 +287,12 @@ You can run your application as a remote debuggee and the remote debugger consol
 
 ### Invoke as a remote debuggee
 
-There are two ways to invoke a script as remote debuggee: Use `rdbg --open` and require `debug/open` (or `debug/open_nonstop`).
+There are multiple ways to run your program as a debuggee:
+
+Stop at program start | [`rdbg` option](https://github.com/ruby/debug#rdbg---open-or-rdbg--o-for-short) | [require](https://github.com/ruby/debug#require-debugopen-in-a-program) | [debugger API](https://github.com/ruby/debug#start-by-method)
+---|---|---|---|
+Yes | `rdbg --open` | `require "debug/open"` | `DEBUGGER__.open`
+No | `rdbg --open --nonstop` | `require "debug/open_nonstop"` | `DEBUGGER__.open(nonstop: true)`
 
 #### `rdbg --open` (or `rdbg -O` for short)
 
@@ -456,35 +468,38 @@ config set no_color true
 
 * UI
   * `RUBY_DEBUG_LOG_LEVEL` (`log_level`): Log level same as Logger (default: WARN)
-  * `RUBY_DEBUG_SHOW_SRC_LINES` (`show_src_lines`): Show n lines source code on breakpoint (default: 10 lines)
-  * `RUBY_DEBUG_SHOW_FRAMES` (`show_frames`): Show n frames on breakpoint (default: 2 frames)
-  * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shorten PATH (like $(Gem)/foo.rb)
+  * `RUBY_DEBUG_SHOW_SRC_LINES` (`show_src_lines`): Show n lines source code on breakpoint (default: 10)
+  * `RUBY_DEBUG_SHOW_FRAMES` (`show_frames`): Show n frames on breakpoint (default: 2)
+  * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shorten PATH (like $(Gem)/foo.rb) (default: false)
   * `RUBY_DEBUG_NO_COLOR` (`no_color`): Do not use colorize (default: false)
   * `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)
+  * `RUBY_DEBUG_NO_HINT` (`no_hint`): Do not show the hint on the REPL (default: false)
 
 * CONTROL
-  * `RUBY_DEBUG_SKIP_PATH` (`skip_path`): Skip showing/entering frames for given paths (default: [])
+  * `RUBY_DEBUG_SKIP_PATH` (`skip_path`): Skip showing/entering frames for given paths
   * `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_FORK_MODE` (`fork_mode`): Control which process activates a debugger after fork (both/parent/child) (default: both)
-  * `RUBY_DEBUG_SIGDUMP_SIG` (`sigdump_sig`): Sigdump signal (default: disabled)
+  * `RUBY_DEBUG_SIGDUMP_SIG` (`sigdump_sig`): Sigdump signal (default: false)
 
 * BOOT
-  * `RUBY_DEBUG_NONSTOP` (`nonstop`): Nonstop mode
-  * `RUBY_DEBUG_STOP_AT_LOAD` (`stop_at_load`): Stop at just loading location
+  * `RUBY_DEBUG_NONSTOP` (`nonstop`): Nonstop mode (default: false)
+  * `RUBY_DEBUG_STOP_AT_LOAD` (`stop_at_load`): Stop at just loading location (default: false)
   * `RUBY_DEBUG_INIT_SCRIPT` (`init_script`): debug command script path loaded at first stop
   * `RUBY_DEBUG_COMMANDS` (`commands`): debug commands invoked at first stop. commands should be separated by ';;'
-  * `RUBY_DEBUG_NO_RC` (`no_rc`): ignore loading ~/.rdbgrc(.rb)
+  * `RUBY_DEBUG_NO_RC` (`no_rc`): ignore loading ~/.rdbgrc(.rb) (default: false)
   * `RUBY_DEBUG_HISTORY_FILE` (`history_file`): history file (default: ~/.rdbg_history)
-  * `RUBY_DEBUG_SAVE_HISTORY` (`save_history`): maximum save history lines (default: 10,000)
+  * `RUBY_DEBUG_SAVE_HISTORY` (`save_history`): maximum save history lines (default: 10000)
 
 * 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_HOST` (`host`): TCP/IP remote debugging: host (default: 127.0.0.1)
   * `RUBY_DEBUG_SOCK_PATH` (`sock_path`): UNIX Domain Socket remote debugging: socket path
   * `RUBY_DEBUG_SOCK_DIR` (`sock_dir`): UNIX Domain Socket remote debugging: socket directory
+  * `RUBY_DEBUG_LOCAL_FS_MAP` (`local_fs_map`): Specify local fs map
+  * `RUBY_DEBUG_SKIP_BP` (`skip_bp`): Skip breakpoints if no clients are attached (default: false)
   * `RUBY_DEBUG_COOKIE` (`cookie`): Cookie for negotiation
   * `RUBY_DEBUG_OPEN_FRONTEND` (`open_frontend`): frontend used by open command (vscode, chrome, default: rdbg).
   * `RUBY_DEBUG_CHROME_PATH` (`chrome_path`): Platform dependent path of Chrome (For more information, See [here](https://github.com/ruby/debug/pull/334/files#diff-5fc3d0a901379a95bc111b86cf0090b03f857edfd0b99a0c1537e26735698453R55-R64))
@@ -492,6 +507,14 @@ config set no_color true
 * OBSOLETE
   * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
 
+There are other environment variables:
+
+* `NO_COLOR`: If the value is set, set `RUBY_DEBUG_NO_COLOR` ([NO_COLOR: disabling ANSI color output in various Unix commands](https://no-color.org/)).
+* `RUBY_DEBUG_ENABLE`: If the value is `0`, do not enable debug.gem feature.
+* `RUBY_DEBUG_ADDED_RUBYOPT`: Remove this value from `RUBYOPT` at first. This feature helps loading debug.gem with `RUBYOPT='-r debug/...'` and you don't want to derive it to child processes. In this case you can set `RUBY_DEBUG_ADDED_RUBYOPT='-r debug/...'` (same value) and this string will be deleted from `RUBYOPT` at first.
+* `RUBY_DEBUG_EDITOR` or `EDITOR`: An editor used by `edit` debug command.
+* `RUBY_DEBUG_BB`: Define `Kernel#bb` method which is alias of `Kernel#debugger`.
+
 ### Initial scripts
 
 If there is `~/.rdbgrc`, the file is loaded as an initial script (which contains debug commands) when the debug session is started.

data/Rakefile

@@ -1,10 +1,6 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
 begin
   require "rake/extensiontask"
   task :build => :compile
@@ -15,7 +11,7 @@ begin
 rescue LoadError
 end
 
-task :default => [:clobber, :compile, 'README.md', :test]
+task :default => [:clobber, :compile, 'README.md', :check_readme, :test_console]
 
 file 'README.md' => ['lib/debug/session.rb', 'lib/debug/config.rb',
                      'exe/rdbg', 'misc/README.md.erb'] do
@@ -25,10 +21,32 @@ file 'README.md' => ['lib/debug/session.rb', 'lib/debug/config.rb',
   puts 'README.md is updated.'
 end
 
-task :test_protocol do
-  ENV['RUBY_DEBUG_PROTOCOL_TEST'] = '1'
+task :check_readme do
+  require_relative 'lib/debug/session'
+  require 'erb'
+  current_readme = File.read("README.md")
+  generated_readme = ERB.new(File.read('misc/README.md.erb')).result
+
+  if current_readme != generated_readme
+    fail <<~MSG
+      The content of README.md doesn't match its template and/or source.
+      Please apply the changes to info source (e.g. command comments) or the template and run 'rake README.md' to update README.md.
+    MSG
+  end
 end
 
+desc "Run all debugger console related tests"
+Rake::TestTask.new(:test_console) do |t|
+  t.test_files = FileList["test/console/*_test.rb", "test/support/*_test.rb"]
+end
+
+desc "Run all debugger protocols (CAP & DAP) related tests"
 Rake::TestTask.new(:test_protocol) do |t|
   t.test_files = FileList["test/protocol/*_test.rb"]
 end
+
+task test: 'test_console' do
+  warn '`rake test` doesn\'t run protocol tests. Use `rake test-all` to test all.'
+end
+
+task test_all: [:test_console, :test_protocol]

data/debug.gemspec

@@ -28,5 +28,5 @@ Gem::Specification.new do |spec|
   spec.extensions    = ['ext/debug/extconf.rb']
 
   spec.add_dependency "irb", ">= 1.3.6" # for its color_printer class, which was added after 1.3
-  spec.add_dependency "reline", ">= 0.2.7"
+  spec.add_dependency "reline", ">= 0.3.1"
 end

data/exe/rdbg

@@ -3,7 +3,9 @@
 require_relative '../lib/debug/config'
 config = DEBUGGER__::Config::parse_argv(ARGV)
 
-case config[:mode]
+# mode is not an actual configuration option
+# it's only used to carry the result of parse_argv here
+case config.delete(:mode)
 when :start
   require 'rbconfig'
 
@@ -12,13 +14,15 @@ when :start
   cmd = config[:command] ? ARGV.shift : (ENV['RUBY'] || RbConfig.ruby)
 
   env = ::DEBUGGER__::Config.config_to_env_hash(config)
-  env['RUBYOPT'] = "-r #{libpath}/#{start_mode}"
+  rubyopt = env['RUBYOPT']
+  env['RUBY_DEBUG_ADDED_RUBYOPT'] = added = "-r #{libpath}/#{start_mode}"
+  env['RUBYOPT'] = "#{added} #{rubyopt}"
 
   exec(env, cmd, *ARGV)
 
 when :attach
   require_relative "../lib/debug/client"
-  ::DEBUGGER__::CONFIG.update config
+  ::DEBUGGER__::CONFIG.set_config **config
 
   begin
     if ARGV.empty? && config[:port]

data/ext/debug/debug.c

@@ -97,27 +97,6 @@ frame_depth(VALUE self)
     return INT2FIX(RARRAY_LEN(bt));
 }
 
-static void
-method_added_tracker(VALUE tpval, void *ptr)
-{
-    rb_trace_arg_t *arg = rb_tracearg_from_tracepoint(tpval);
-    VALUE mid = rb_tracearg_callee_id(arg);
-
-    if (RB_UNLIKELY(mid == ID2SYM(rb_intern("method_added")) ||
-                    mid == ID2SYM(rb_intern("singleton_method_added")))) {
-        VALUE args[] = {
-            tpval,
-        };
-        rb_funcallv(rb_mDebugger, rb_intern("method_added"), 1, args);
-    }
-}
-
-static VALUE
-create_method_added_tracker(VALUE self)
-{
-    return rb_tracepoint_new(0, RUBY_EVENT_CALL, method_added_tracker, NULL);
-}
-
 // iseq
 
 const struct rb_iseq *rb_iseqw_to_iseq(VALUE iseqw);
@@ -203,7 +182,6 @@ Init_debug(void)
     rb_gc_register_mark_object(rb_cFrameInfo);
     rb_define_singleton_method(rb_mDebugger, "capture_frames", capture_frames, 1);
     rb_define_singleton_method(rb_mDebugger, "frame_depth", frame_depth, 0);
-    rb_define_singleton_method(rb_mDebugger, "create_method_added_tracker", create_method_added_tracker, 0);
     rb_define_const(rb_mDebugger, "SO_VERSION", rb_str_new2(RUBY_DEBUG_VERSION));
 
     // iseq

data/ext/debug/extconf.rb

@@ -2,14 +2,25 @@ require 'mkmf'
 require_relative '../../lib/debug/version'
 File.write("debug_version.h", "#define RUBY_DEBUG_VERSION \"#{DEBUGGER__::VERSION}\"\n")
 
-have_func "rb_iseq_parameters(NULL, 0)",
-          [["VALUE rb_iseq_parameters(void *, int is_proc);"]]
 
-have_func "rb_iseq_code_location(NULL, NULL, NULL, NULL, NULL)",
-          [["void rb_iseq_code_location(void *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);"]]
+if defined? RubyVM
+  $defs << '-DHAVE_RB_ISEQ_PARAMETERS'
+  $defs << '-DHAVE_RB_ISEQ_CODE_LOCATION'
 
-# from Ruby 3.1
-have_func "rb_iseq_type(NULL)",
-          [["VALUE rb_iseq_type(void *);"]]
+  if RUBY_VERSION >= '3.1.0'
+    $defs << '-DHAVE_RB_ISEQ_TYPE'
+  end
+else
+  # not on MRI
+
+  have_func "rb_iseq_parameters(NULL, 0)",
+             [["VALUE rb_iseq_parameters(void *, int is_proc);"]]
+
+  have_func "rb_iseq_code_location(NULL, NULL, NULL, NULL, NULL)",
+            [["void rb_iseq_code_location(void *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);"]]
+  # from Ruby 3.1
+  have_func "rb_iseq_type(NULL)",
+            [["VALUE rb_iseq_type(void *);"]]
+end
 
 create_makefile 'debug/debug'

data/lib/debug/breakpoint.rb

@@ -131,9 +131,17 @@ module DEBUGGER__
   end
 
   class LineBreakpoint < Breakpoint
-    attr_reader :path, :line, :iseq
+    attr_reader :path, :line, :iseq, :cond, :oneshot, :hook_call, :command
 
-    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil
+    def self.copy bp, root_iseq
+      nbp = LineBreakpoint.new bp.path, bp.line,
+                               cond: bp.cond, oneshot: bp.oneshot, hook_call: bp.hook_call,
+                               command: bp.command, skip_activate: true
+      nbp.try_activate root_iseq
+      nbp
+    end
+
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil, skip_activate: false
       @line = line
       @oneshot = oneshot
       @hook_call = hook_call
@@ -146,7 +154,7 @@ module DEBUGGER__
 
       super(cond, command, path)
 
-      try_activate
+      try_activate unless skip_activate
       @pending = !@iseq
     end
 
@@ -206,7 +214,7 @@ module DEBUGGER__
       when events.include?(:RUBY_EVENT_END)
         activate(iseq, :end, line)
       else
-        # not actiavated
+        # not activated
       end
     end
 
@@ -216,42 +224,56 @@ module DEBUGGER__
 
     NearestISeq = Struct.new(:iseq, :line, :events)
 
-    def try_activate
-      nearest = nil # NearestISeq
-
-      ObjectSpace.each_iseq{|iseq|
-        if DEBUGGER__.compare_path((iseq.absolute_path || iseq.path), self.path) &&
-            iseq.first_lineno <= self.line &&
-            iseq.type != :ensure # ensure iseq is copied (duplicated)
+    def iterate_iseq root_iseq
+      if root_iseq
+        is = [root_iseq]
+        while iseq = is.pop
+          yield iseq
+          iseq.each_child do |child_iseq|
+            is << child_iseq
+          end
+        end
+      else
+        ObjectSpace.each_iseq do |iseq|
+          if DEBUGGER__.compare_path((iseq.absolute_path || iseq.path), self.path) &&
+             iseq.first_lineno <= self.line &&
+             iseq.type != :ensure # ensure iseq is copied (duplicated)
+            yield iseq
+          end
+        end
+      end
+    end
 
-          iseq.traceable_lines_norec(line_events = {})
-          lines = line_events.keys.sort
+    def try_activate root_iseq = nil
+      nearest = nil # NearestISeq
+      iterate_iseq root_iseq do |iseq|
+        iseq.traceable_lines_norec(line_events = {})
+        lines = line_events.keys.sort
 
-          if !lines.empty? && lines.last >= line
-            nline = lines.bsearch{|l| line <= l}
-            events = line_events[nline]
+        if !lines.empty? && lines.last >= line
+          nline = lines.bsearch{|l| line <= l}
+          events = line_events[nline]
 
-            next if events == [:RUBY_EVENT_B_CALL]
+          next if events == [:RUBY_EVENT_B_CALL]
 
-            if @hook_call &&
-               events.include?(:RUBY_EVENT_CALL) &&
-               self.line == iseq.first_lineno
-              nline = iseq.first_lineno
-            end
+          if @hook_call &&
+            events.include?(:RUBY_EVENT_CALL) &&
+            self.line == iseq.first_lineno
+            nline = iseq.first_lineno
+          end
 
-            if !nearest || ((line - nline).abs < (line - nearest.line).abs)
-              nearest = NearestISeq.new(iseq, nline, events)
-            else
-              if @hook_call && nearest.iseq.first_lineno <= iseq.first_lineno
-                if (nearest.line > line && !nearest.events.include?(:RUBY_EVENT_CALL)) ||
-                   (events.include?(:RUBY_EVENT_CALL))
-                  nearest = NearestISeq.new(iseq, nline, events)
-                end
+          if !nearest || ((line - nline).abs < (line - nearest.line).abs)
+            nearest = NearestISeq.new(iseq, nline, events)
+          else
+            if @hook_call && nearest.iseq.first_lineno <= iseq.first_lineno
+              if (nearest.line > line && !nearest.events.include?(:RUBY_EVENT_CALL)) ||
+                (events.include?(:RUBY_EVENT_CALL))
+                nearest = NearestISeq.new(iseq, nline, events)
               end
             end
           end
         end
-      }
+      end
 
       if nearest
         activate_exact nearest.iseq, nearest.events, nearest.line
@@ -326,12 +348,25 @@ module DEBUGGER__
         next if ThreadClient.current.management?
         next if skip_path?(tp.path)
 
-        if safe_eval tp.binding, @cond
+        if need_suspend? safe_eval(tp.binding, @cond)
           suspend
         end
       }
     end
 
+    private def need_suspend? cond_result
+      map = ThreadClient.current.check_bp_fulfillment_map
+      if cond_result
+        if map[self]
+          false
+        else
+          map[self] = true
+        end
+      else
+        map[self] = false
+      end
+    end
+
     def to_s
       s = "#{generate_label("Check")}"
       s += super
@@ -386,7 +421,7 @@ module DEBUGGER__
   end
 
   class MethodBreakpoint < Breakpoint
-    attr_reader :sig_method_name, :method
+    attr_reader :sig_method_name, :method, :klass
 
     def initialize b, klass_name, op, method_name, cond: nil, command: nil, path: nil
       @sig_klass_name = klass_name

data/lib/debug/client.rb

@@ -121,7 +121,10 @@ module DEBUGGER__
       @width = IO.console_size[1]
       @width = 80 if @width == 0
 
-      send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"
+      send "version: #{VERSION} " +
+           "width: #{@width} " +
+           "cookie: #{CONFIG[:cookie] || '-'} " +
+           "nonstop: #{CONFIG[:nonstop] ? 'true' : 'false'}"
     end
 
     def deactivate
@@ -173,6 +176,8 @@ module DEBUGGER__
     end
 
     def connect
+      pre_commands = (CONFIG[:commands] || '').split(';;')
+
       trap(:SIGINT){
         send "pause"
       }
@@ -199,7 +204,12 @@ module DEBUGGER__
           prev_trap = trap(:SIGINT, 'DEFAULT')
 
           begin
-            line = readline
+            if pre_commands.empty?
+              line = readline
+            else
+              line = pre_commands.shift
+              puts "(rdbg:remote:command) #{line}"
+            end
           rescue Interrupt
             retry
           ensure