debug 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6251dbcd2eb75a8b4932a740fe0294da996c7bcaaaa965f42353144786b5c0a
-  data.tar.gz: 328c4949a62eeb5277d8d6882c1a7da565b2c5aaa4c2fc5cf52850ca7e454240
+  metadata.gz: adddd814397fedb45de84db6ccb2dc49c3aefae141e73b156e3b87c29a3edf60
+  data.tar.gz: 0b0cb92d077f04ed9f7bfa1f79f56f35dc4dc9054f27ea3608d23c5f0d462274
 SHA512:
-  metadata.gz: 7c8c83768d7d9eca50f18018dc9255a54234ee9c048d9885d54d46399e7bf9910ca87f85a9cd804108ec319ec985095016b00b1ab0d45a787fb55ef96b2a9483
-  data.tar.gz: 24c87a5fbef8a8c1851ffea1b21c53613389d0c8fa46a3a205562aa2c98f6515ad863e97a5ee8857914a0363110ef277bc961b8d04902b0a5f537f133f6f18af
+  metadata.gz: 3e60eb57c1ec6c164d6956e777f8ac52e15ba84c13b97443650ac67f2b503397cfc57d9f0b897f331946e7200067227d61e7b81f459c5b42e44098dbbe9161ef
+  data.tar.gz: 3a377c3da4482103142fbece04cb896522f952aa3d43f316f50dd699f35f0c24db100df3e706e6d86cbc752021800bbfdff6131a95023d497741d68c396e5ed7

data/README.md

@@ -11,7 +11,9 @@ New debug.rb has several advantages:
 * [Remote debugging](#remote-debugging): Support remote debugging natively.
   * UNIX domain socket
   * TCP/IP
-  * VSCode/DAP integration ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
+  * Integeration with rich debugger frontend
+    * VSCode/DAP ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
+    * Chrome DevTools
 * Extensible: application can introduce debugging support with several ways:
   * By `rdbg` command
   * By loading libraries with `-r` command line option
@@ -336,6 +338,97 @@ By default, UNIX domain socket is used for the debugging port. To use TCP/IP, yo
 $ RUBY_DEBUG_PORT=12345 ruby target.rb
 ```
 
+### Integration with external debugger frontend
+
+You can attach with external debuger frontend with VSCode and Chrome.
+
+```
+$ rdbg --open=[frontend] target.rb
+```
+
+will open a debug port and `[frontned]` can attache to the port.
+
+Also `open` command allows opening the debug port.
+
+#### VSCode integration
+
+If you don't run a debuggee Ruby process on VSCode, you can attach with VSCode later with the fowllowing steps.
+
+`rdbg --open=vscode` opens the debug port and tries to invoke the VSCode (`code` command).
+
+```
+$ rdbg --open=vscode target.rb
+DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-27706)
+DEBUGGER: wait for debugger connection...
+Launching: code /tmp/ruby-debug-vscode-20211014-27706-gd7e85/ /tmp/ruby-debug-vscode-20211014-27706-gd7e85/README.rb
+DEBUGGER: Connected.
+```
+
+And it tris to invoke the new VSCode window and VSCode starts attaching to the debuggee Ruby program automatically.
+
+You can also use `open vscode` command in REPL.
+
+```
+$ rdbg target.rb
+[1, 8] in target.rb
+     1|
+=>   2| p a = 1
+     3| p b = 2
+     4| p c = 3
+     5| p d = 4
+     6| p e = 5
+     7|
+     8| __END__
+=>#0    <main> at target.rb:2
+(rdbg) open vscode    # command
+DEBUGGER: wait for debugger connection...
+DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-28337)
+Launching: code /tmp/ruby-debug-vscode-20211014-28337-kg9dm/ /tmp/ruby-debug-vscode-20211014-28337-kg9dm/README.rb
+DEBUGGER: Connected.
+```
+
+If the machine which runs the Ruby process doesn't have a `code` command, the following message will be shown:
+
+```
+(rdbg) open vscode
+DEBUGGER: wait for debugger connection...
+DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-455)
+Launching: code /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
+DEBUGGER: Can not invoke the command.
+Use the command-line on your terminal (with modification if you need).
+
+  code /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
+
+If your application is running on a SSH remote host, please try:
+
+  code --remote ssh-remote+[SSH hostname] /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
+
+```
+
+and try to use proposed commands.
+
+Note that you can attach with `rdbg --attach` and continue REPL debugging.
+
+#### Chrome DevTool integration
+
+With `rdbg --open=chrome` command will shows the following message.
+
+```
+$ rdbg target.rb --open=chrome
+DEBUGGER: Debugger can attach via TCP/IP (127.0.0.1:43633)
+DEBUGGER: With Chrome browser, type the following URL in the address-bar:
+
+   devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633
+
+DEBUGGER: wait for debugger connection...
+```
+
+Type `devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633` in the address-bar on Chrome browser, and you can continue the debugging with chrome browser.
+
+Also `open chrome` command works like `open vscode`.
+
+For more information about how to use Chrome debugging, you might want to read [here](https://developer.chrome.com/docs/devtools/)
+
 ## Configuration
 
 You can configure the debugger's behavior with debug commands and environment variables.
@@ -367,7 +460,7 @@ config set no_color true
   * `RUBY_DEBUG_SKIP_NOSRC` (`skip_nosrc`): Skip on no source code lines (default: false)
   * `RUBY_DEBUG_KEEP_ALLOC_SITE` (`keep_alloc_site`): Keep allocation site and p, pp shows it (default: false)
   * `RUBY_DEBUG_POSTMORTEM` (`postmortem`): Enable postmortem debug (default: false)
-  * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
+  * `RUBY_DEBUG_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)
 
 * BOOT
@@ -376,6 +469,8 @@ config set no_color true
   * `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_FILE` (`history_file`): history file (default: ~/.rdbg_history)
+  * `RUBY_DEBUG_SAVE_HISTORY` (`save_history`): maximum save history lines (default: 10,000)
 
 * REMOTE
   * `RUBY_DEBUG_PORT` (`port`): TCP/IP remote debugging: port
@@ -383,6 +478,10 @@ config set no_color true
   * `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
+  * `RUBY_DEBUG_OPEN_FRONTEND` (`open_frontend`): frontend used by open command (vscode, chrome, default: rdbg).
+
+* OBSOLETE
+  * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
 
 ### Initial scripts
 
@@ -596,6 +695,15 @@ The `<...>` notation means the argument.
   * Set <name> to default.
 * `source <file>`
   * Evaluate lines in `<file>` as debug commands.
+* `open`
+  * open debuggee port on UNIX domain socket and wait for attaching.
+  * Note that `open` command is EXPERIMENTAL.
+* `open [<host>:]<port>`
+  * open debuggee port on TCP/IP with given `[<host>:]<port>` and wait for attaching.
+* `open vscode`
+  * open debuggee port for VSCode and launch VSCode if available.
+* `open chrome`
+  * open debuggee port for Chrome and wait for attaching.
 
 ### Help
 
@@ -698,9 +806,10 @@ Debug console 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.
+    -O, --open=[FRONTEND]            Start remote debugging with opening the network port.
+                                     If TCP/IP options are not given, a UNIX domain socket will be used.
+                                     If FRONTEND is given, prepare for the FRONTEND.
+                                     Now rdbg, vscode and chrome is supported.
         --sock-path=SOCK_PATH        UNIX Domain socket path
         --port=PORT                  Listening TCP/IP port
         --host=HOST                  Listening TCP/IP host
@@ -716,6 +825,7 @@ Debug console mode:
   '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.
+  'rdbg target.rb -O chrome --port 1234'  starts and accepts connecting from Chrome Devtools with localhost:1234.
 
 Attach mode:
     -A, --attach                     Attach to debuggee process.
@@ -750,3 +860,4 @@ 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)
+* Several codes in `server_cdp.rb` are based on [geoffreylitt/ladybug: Visual Debugger](https://github.com/geoffreylitt/ladybug)

data/ext/debug/debug.c

@@ -2,7 +2,7 @@
 #include "ruby/ruby.h"
 #include "ruby/debug.h"
 #include "ruby/encoding.h"
-
+#include "debug_version.h"
 //
 static VALUE rb_mDebugger;
 
@@ -130,5 +130,6 @@ Init_debug(void)
     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));
     Init_iseq_collector();
 }

data/ext/debug/extconf.rb

@@ -1,2 +1,4 @@
 require 'mkmf'
+require_relative '../../lib/debug/version'
+File.write("debug_version.h", "#define RUBY_DEBUG_VERSION \"#{DEBUGGER__::VERSION}\"\n")
 create_makefile 'debug/debug'

data/lib/debug/client.rb

@@ -21,6 +21,18 @@ module DEBUGGER__
         when 'list-socks'
           cleanup_unix_domain_sockets
           puts list_connections
+        when 'init'
+          if ARGV.shift == '-'
+            puts <<~EOS
+            export RUBYOPT="-r #{__dir__}/prelude $(RUBYOPT)"
+            EOS
+          else
+            puts <<~EOS
+            # add the following lines in your .bash_profile
+
+            eval "$(rdbg init -)"
+            EOS
+          end
         else
           raise "Unknown utility: #{name}"
         end
@@ -31,6 +43,7 @@ module DEBUGGER__
           if /(\d+)$/ =~ file
             begin
               Process.kill(0, $1.to_i)
+            rescue Errno::EPERM
             rescue Errno::ESRCH
               File.unlink(file)
             end
@@ -44,17 +57,15 @@ module DEBUGGER__
     end
 
     def initialize argv
+      @multi_process = false
+      @pid = nil
       @console = Console.new
 
       case argv.size
       when 0
         connect_unix
       when 1
-        case arg = argv.shift
-        when /-h/, /--help/
-          help
-          exit
-        when /\A\d+\z/
+        if /\A\d+\z/ =~ (arg = argv.shift.strip)
           connect_tcp nil, arg.to_i
         else
           connect_unix arg
@@ -67,13 +78,22 @@ module DEBUGGER__
 
       @width = IO.console_size[1]
       @width = 80 if @width == 0
-      @width_changed = false
 
       send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"
     end
 
+    def deactivate
+      @console.deactivate if @console
+    end
+
     def readline
-      @console.readline "(rdbg:remote) "
+      if @multi_process
+        @console.readline "(rdbg:remote\##{@pid}) "
+      else
+        @console.readline "(rdbg:remote) "
+      end.tap{|line|
+        p readline: line
+      }
     end
 
     def connect_unix name = nil
@@ -118,15 +138,19 @@ module DEBUGGER__
       }
       trap(:SIGWINCH){
         @width = IO.console_size[1]
-        @width_changed = true
       }
 
       while line = @s.gets
         p recv: line if $VERBOSE
         case line
+
         when /^out (.*)/
           puts "#{$1}"
-        when /^input/
+
+        when /^input (.+)/
+          pid = $1
+          @multi_process = true if @pid && @pid != pid
+          @pid = pid
           prev_trap = trap(:SIGINT, 'DEFAULT')
 
           begin
@@ -138,18 +162,16 @@ module DEBUGGER__
           end
 
           line = (line || 'quit').strip
+          send "command #{pid} #{@width} #{line}"
 
-          if @width_changed
-            @width_changed = false
-            send "width #{@width}"
-          end
+        when /^ask (\d+) (.*)/
+          pid = $1
+          print $2
+          send "answer #{pid} #{gets || ''}"
 
-          send "command #{line}"
-        when /^ask (.*)/
-          print $1
-          send "answer #{gets || ''}"
         when /^quit/
           raise 'quit'
+
         else
           puts "(unknown) #{line.inspect}"
         end
@@ -157,6 +179,8 @@ module DEBUGGER__
     rescue
       STDERR.puts "disconnected (#{$!})"
       exit
+    ensure
+      deactivate
     end
   end
 end

data/lib/debug/config.rb

@@ -24,7 +24,7 @@ module DEBUGGER__
     skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "CONTROL: Skip on no source code lines (default: false)",              :bool],
     keep_alloc_site:['RUBY_DEBUG_KEEP_ALLOC_SITE',"CONTROL: Keep allocation site and p, pp shows it (default: false)",   :bool],
     postmortem:     ['RUBY_DEBUG_POSTMORTEM',     "CONTROL: Enable postmortem debug (default: false)",                   :bool],
-    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "CONTROL: Keep debugging parent process on fork (default: false)",     :bool],
+    fork_mode:      ['RUBY_DEBUG_FORK_MODE',      "CONTROL: Control which process activates a debugger after fork (both/parent/child) (default: both)", :forkmode],
     sigdump_sig:    ['RUBY_DEBUG_SIGDUMP_SIG',    "CONTROL: Sigdump signal (default: disabled)"],
 
     # boot setting
@@ -33,13 +33,19 @@ module DEBUGGER__
     init_script:    ['RUBY_DEBUG_INIT_SCRIPT', "BOOT: debug command script path loaded at first stop"],
     commands:       ['RUBY_DEBUG_COMMANDS',    "BOOT: debug commands invoked at first stop. commands should be separated by ';;'"],
     no_rc:          ['RUBY_DEBUG_NO_RC',       "BOOT: ignore loading ~/.rdbgrc(.rb)",                               :bool],
+    history_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file (default: ~/.rdbg_history)"],
+    save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines (default: 10,000)"],
 
     # remote setting
-    port:           ['RUBY_DEBUG_PORT',      "REMOTE: TCP/IP remote debugging: port"],
-    host:           ['RUBY_DEBUG_HOST',      "REMOTE: TCP/IP remote debugging: host (localhost if not given)"],
-    sock_path:      ['RUBY_DEBUG_SOCK_PATH', "REMOTE: UNIX Domain Socket remote debugging: socket path"],
-    sock_dir:       ['RUBY_DEBUG_SOCK_DIR',  "REMOTE: UNIX Domain Socket remote debugging: socket directory"],
-    cookie:         ['RUBY_DEBUG_COOKIE',    "REMOTE: Cookie for negotiation"],
+    port:           ['RUBY_DEBUG_PORT',         "REMOTE: TCP/IP remote debugging: port"],
+    host:           ['RUBY_DEBUG_HOST',         "REMOTE: TCP/IP remote debugging: host (localhost if not given)"],
+    sock_path:      ['RUBY_DEBUG_SOCK_PATH',    "REMOTE: UNIX Domain Socket remote debugging: socket path"],
+    sock_dir:       ['RUBY_DEBUG_SOCK_DIR',     "REMOTE: UNIX Domain Socket remote debugging: socket directory"],
+    cookie:         ['RUBY_DEBUG_COOKIE',       "REMOTE: Cookie for negotiation"],
+    open_frontend:  ['RUBY_DEBUG_OPEN_FRONTEND',"REMOTE: frontend used by open command (vscode, chrome, default: rdbg)."],
+
+    # obsolete
+    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "OBSOLETE: Keep debugging parent process on fork (default: false)",     :bool],
   }.freeze
 
   CONFIG_MAP = CONFIG_SET.map{|k, (ev, desc)| [k, ev]}.to_h.freeze
@@ -57,6 +63,10 @@ module DEBUGGER__
       update self.class.parse_argv(argv)
     end
 
+    def inspect
+      config.inspect
+    end
+
     def [](key)
       config[key]
     end
@@ -79,7 +89,7 @@ module DEBUGGER__
     end
 
     def append_config key, val
-      conf = self.config.dup
+      conf = config.dup
 
       if CONFIG_SET[key]
         if CONFIG_SET[key][2] == :path
@@ -187,6 +197,13 @@ module DEBUGGER__
         else
           raise "Unknown loglevel: #{valstr}"
         end
+      when :forkmode
+        case sym = valstr.to_sym
+        when :parent, :child, :both, nil
+          sym
+        else
+          raise "unknown fork mode: #{sym}"
+        end
       when :path # array of String
         valstr.split(/:/).map{|e|
           if /\A\/(.+)\/\z/ =~ e
@@ -255,10 +272,12 @@ module DEBUGGER__
 
         o.separator ''
 
-        o.on('-O', '--open', 'Start remote debugging with opening the network port.',
-                             'If TCP/IP options are not given,',
-                             'a UNIX domain socket will be used.') do
+        o.on('-O', '--open=[FRONTEND]', 'Start remote debugging with opening the network port.',
+                                        'If TCP/IP options are not given, a UNIX domain socket will be used.',
+                                        'If FRONTEND is given, prepare for the FRONTEND.',
+                                        'Now rdbg, vscode and chrome is supported.') do |f|
           config[:remote] = true
+          config[:open_frontend] = f.downcase if f
         end
         o.on('--sock-path=SOCK_PATH', 'UNIX Domain socket path') do |path|
           config[:sock_path] = path
@@ -286,6 +305,7 @@ module DEBUGGER__
         o.separator "  '#{rdbg} -O target.rb foo bar'             starts and accepts attaching with UNIX domain socket."
         o.separator "  '#{rdbg} -O --port 1234 target.rb foo bar' starts accepts attaching with TCP/IP localhost:1234."
         o.separator "  '#{rdbg} -O --port 1234 -- -r foo -e bar'  starts accepts attaching with TCP/IP localhost:1234."
+        o.separator "  '#{rdbg} target.rb -O chrome --port 1234'  starts and accepts connecting from Chrome Devtools with localhost:1234."
 
         o.separator ''
         o.separator 'Attach mode:'

data/lib/debug/console.rb

@@ -31,6 +31,7 @@ module DEBUGGER__
       end if SIGWINCH_SUPPORTED
 
       def readline_setup prompt
+        load_history_if_not_loaded
         commands = DEBUGGER__.commands
 
         Reline.completion_proc = -> given do
@@ -87,40 +88,106 @@ module DEBUGGER__
         Reline.readmultiline(prompt, true){ true }
       end
 
+      def history
+        Reline::HISTORY
+      end
+
     rescue LoadError
-    begin
-      require 'readline.so'
+      begin
+        require 'readline.so'
+
+        def readline_setup
+          load_history_if_not_loaded
+          commands = DEBUGGER__.commands
+
+          Readline.completion_proc = proc{|given|
+            buff = Readline.line_buffer
+            Readline.completion_append_character= ' '
+
+            if /\s/ =~ buff # second parameters
+              given = File.expand_path(given + 'a').sub(/a\z/, '')
+              files = Dir.glob(given + '*')
+              if files.size == 1 && File.directory?(files.first)
+                Readline.completion_append_character= '/'
+              end
+              files
+            else
+              commands.keys.grep(/\A#{given}/)
+            end
+          }
+        end
 
-      def readline_setup
-        Readline.completion_proc = proc{|given|
-          buff = Readline.line_buffer
-          Readline.completion_append_character= ' '
+        def readline prompt
+          readline_setup
+          Readline.readline(prompt, true)
+        end
 
-          if /\s/ =~ buff # second parameters
-            given = File.expand_path(given + 'a').sub(/a\z/, '')
-            files = Dir.glob(given + '*')
-            if files.size == 1 && File.directory?(files.first)
-              Readline.completion_append_character= '/'
-            end
-            files
-          else
-            DEBUGGER__.commands.keys.grep(/\A#{given}/)
-          end
-        }
+        def history
+          Readline::HISTORY
+        end
+
+      rescue LoadError
+        def readline prompt
+          print prompt
+          gets
+        end
+
+        def history
+          nil
+        end
       end
+    end
 
-      def readline prompt
-        readline_setup
-        Readline.readline(prompt, true)
+    def history_file
+      CONFIG[:history_file] || File.expand_path("~/.rdbg_history")
+    end
+
+    FH = "# Today's OMIKUJI: "
+
+    def read_history_file
+      if history && File.exists?(path = history_file)
+        f = (['', 'DAI-', 'CHU-', 'SHO-'].map{|e| e+'KICHI'}+['KYO']).sample
+        ["#{FH}#{f}".dup] + File.readlines(path)
+      else
+        []
       end
+    end
 
-    rescue LoadError
-      def readline prompt
-        print prompt
-        gets
+    def initialize
+      @init_history_lines = nil
+    end
+
+    def load_history_if_not_loaded
+      return if @init_history_lines
+
+      @init_history_lines = load_history
+    end
+
+    def deactivate
+      if history && @init_history_lines
+        added_records = history.to_a[@init_history_lines .. -1]
+        path = history_file
+        max = CONFIG[:save_history] || 10_000
+
+        if !added_records.empty? && !path.empty?
+          orig_records = read_history_file
+          open(history_file, 'w'){|f|
+            (orig_records + added_records).last(max).each{|line|
+              if !line.start_with?(FH) && !line.strip.empty?
+                f.puts line.strip
+              end
+            }
+          }
+        end
       end
     end
+
+    def load_history
+      read_history_file.count{|line|
+        line.strip!
+        history << line unless line.empty?
+      }
     end
-  end
+  end # class Console
 end
 

data/lib/debug/local.rb

@@ -26,8 +26,11 @@ module DEBUGGER__
 
     def deactivate
       if SESSION.intercept_trap_sigint?
-        trap(:SIGINT, SESSION.intercepted_sigint_cmd)
+        prev = SESSION.intercept_trap_sigint_end
+        trap(:SIGINT, prev)
       end
+
+      @console.deactivate
     end
 
     def width

data/lib/debug/prelude.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+return if defined?(::DEBUGGER__)
+
+#
+# put the following line in .bash_profile
+#   export RUBYOPT="-r .../debug/prelude $(RUBYOPT)"
+#
+module Kernel
+  def debugger(*a, up_level: 0, **kw)
+    begin
+      require_relative 'version'
+      cur_version = ::DEBUGGER__::VERSION
+      require_relative 'frame_info'
+
+      if !defined?(::DEBUGGER__::SO_VERSION) || ::DEBUGGER__::VERSION != ::DEBUGGER__::SO_VERSION
+        ::Object.send(:remove_const, :DEBUGGER__)
+        raise LoadError
+      end
+      require_relative 'session'
+      up_level += 1
+    rescue LoadError
+      $LOADED_FEATURES.delete_if{|e|
+        e.start_with?(__dir__) || e.end_with?('debug/debug.so')
+      }
+      require 'debug/session'
+      require 'debug/version'
+      ::DEBUGGER__.info "Can not activate debug #{cur_version} specified by debug/prelude.rb. Activate debug #{DEBUGGER__::VERSION} instead."
+      up_level += 1
+    end
+
+    ::DEBUGGER__::start no_sigint_hook: true, nonstop: true
+
+    begin
+      debugger(*a, up_level: up_level, **kw)
+      self
+    rescue ArgumentError # for 1.2.4 and earlier
+      debugger(*a, **kw)
+      self
+    end
+  end
+
+  alias b debugger if ENV['RUBY_DEBUG_B']
+end
+
+class Binding
+  alias break debugger
+  alias b debugger
+end