debug 1.0.0.beta5 → 1.0.0.beta6

data/lib/debug/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module DEBUGGER__
   def self.unix_domain_socket_dir
@@ -34,15 +35,18 @@ module DEBUGGER__
     nonstop:     'RUBY_DEBUG_NONSTOP',     # Nonstop mode ('1' is nonstop)
     init_script: 'RUBY_DEBUG_INIT_SCRIPT', # debug command script path loaded at first stop
     commands:    'RUBY_DEBUG_COMMANDS',    # debug commands invoked at first stop. commands should be separated by ';;'
+    no_rc:       'RUBY_DEBUG_NO_RC',       # ignore loading ~/.rdbgrc(.rb)
 
     # UI setting
     show_src_lines: 'RUBY_DEBUG_SHOW_SRC_LINES', # Show n lines source code on breakpoint (default: 10 lines).
     show_frames:    'RUBY_DEBUG_SHOW_FRAMES',    # Show n frames on breakpoint (default: 2 frames).
     use_short_path: 'RUBY_DEBUG_USE_SHORT_PATH', # Show shoten PATH (like $(Gem)/foo.rb).
     skip_nosrc:     'RUBY_DEBUG_SKIP_NOSRC',     # Skip on no source code lines (default: false).
-    use_colorize:   'RUBY_DEBUG_USE_COLORIZE',   # Show coloring
+    no_color:       'RUBY_DEBUG_NO_COLOR',       # Do not use colorize
+    no_sigint_hook: 'RUBY_DEBUG_NO_SIGINT_HOOK', # Do not suspend on SIGINT
+    quiet:          'RUBY_DEBUG_QUIET',          # Do not show messages
 
-    # remote
+    # remote setting
     port:        'RUBY_DEBUG_PORT',        # TCP/IP remote debugging: port
     host:        'RUBY_DEBUG_HOST',        # TCP/IP remote debugging: host (localhost if not given)
     sock_path:   'RUBY_DEBUG_SOCK_PATH',   # UNIX Domain Socket remote debugging: socket path
@@ -50,16 +54,15 @@ module DEBUGGER__
     cookie:      'RUBY_DEBUG_COOKIE',      # Cookie for negotiation
   }.freeze
 
-  def self.config_to_env config
-    CONFIG_MAP.each{|key, evname|
-      ENV[evname] = config[key].to_s if config[key]
+  def self.config_to_env_hash config
+    CONFIG_MAP.each_with_object({}){|(key, evname), env|
+      env[evname] = config[key].to_s if config[key]
     }
   end
 
   def self.parse_argv argv
     config = {
       mode: :start,
-      use_colorize: true,
     }
     CONFIG_MAP.each{|key, evname|
       if val = ENV[evname]
@@ -90,14 +93,26 @@ module DEBUGGER__
         config[:nonstop] = '1'
       end
 
-      o.on('-e COMMAND', 'execute debug command at the beginning of the script.') do |cmd|
+      o.on('-e COMMAND', 'Execute debug command at the beginning of the script.') do |cmd|
         config[:commands] ||= ''
-        config[:commands] << cmd + ';;'
+        config[:commands] += cmd + ';;'
       end
 
-      o.on('-x FILE', '--init-script=FILE', 'execute debug command in the FILE.') do |file|
+      o.on('-x FILE', '--init-script=FILE', 'Execute debug command in the FILE.') do |file|
         config[:init_script] = file
       end
+      o.on('--no-rc', 'Ignore ~/.rdbgrc') do
+        config[:no_rc] = true
+      end
+      o.on('--no-color', 'Disable colorize') do
+        config[:no_color] = true
+      end
+
+      o.on('-c', '--command', 'Enable command mode.',
+                              'The first argument should be a command name in $PATH.',
+                              'Example: \'rdbg -c bundle exec rake test\'') do
+        config[:command] = true
+      end
 
       o.separator ''
 
@@ -154,11 +169,8 @@ module DEBUGGER__
         exit
       end
 
-      o.on('-c', '--command', 'Command mode (first argument is command name)') do
-        config[:command] = true
-      end
-
       o.on('--util=NAME', 'Utility mode (used by tools)') do |name|
+        require_relative 'client'
         Client.new(name)
         exit
       end

data/lib/debug/console.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'session'
 return unless defined?(DEBUGGER__)
 
@@ -6,6 +8,17 @@ require 'io/console/size'
 module DEBUGGER__
   class UI_Console < UI_Base
     def initialize
+      unless CONFIG[:no_sigint_hook]
+        @prev_handler = trap(:SIGINT){
+          ThreadClient.current.on_trap :SIGINT
+        }
+      end
+    end
+
+    def close
+      if @prev_handler
+        trap(:SIGINT, @prev_handler)
+      end
     end
 
     def remote?

data/lib/debug/frame_info.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module DEBUGGER__
   FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
@@ -9,7 +10,7 @@ module DEBUGGER__
   if File.exist? File.join(__dir__, 'debug.so')
     require_relative 'debug.so'
   else
-    require "debug/debug"
+    require_relative 'debug'
   end
 
   class FrameInfo

data/lib/debug/open.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Open the door for the debugger to connect.
 # Users can connect to debuggee program with "rdbg --attach" option.

data/lib/debug/run.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'console'
 return unless defined?(DEBUGGER__)
-
-DEBUGGER__.console
+DEBUGGER__.start

data/lib/debug/server.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'socket'
 
 require_relative 'session'
@@ -13,8 +15,8 @@ module DEBUGGER__
       @accept_m = Mutex.new
       @accept_cv = ConditionVariable.new
       @client_addr = nil
-      @q_msg = Queue.new
-      @q_ans = Queue.new
+      @q_msg = nil
+      @q_ans = nil
       @unsent_messages = []
       @width = 80
 
@@ -23,7 +25,7 @@ module DEBUGGER__
         Thread.current.abort_on_exception = true
 
         accept do |server|
-          DEBUGGER__.message "Connected."
+          DEBUGGER__.warn "Connected."
 
           @accept_m.synchronize{
             @sock = server
@@ -36,6 +38,9 @@ module DEBUGGER__
               @sock.puts m
             }
             @unsent_messages.clear
+
+            @q_msg = Queue.new
+            @q_ans = Queue.new
           }
 
           setup_interrupt do
@@ -43,12 +48,14 @@ module DEBUGGER__
           end
 
         rescue => e
-          DEBUGGER__.message "ReaderThreadError: #{e}"
+          DEBUGGER__.warn "ReaderThreadError: #{e}", :error
         ensure
-          DEBUGGER__.message "Disconnected."
+          DEBUGGER__.warn "Disconnected."
           @sock = nil
           @q_msg.close
+          @q_msg = nil
           @q_ans.close
+          @q_ans = nil
         end
       end
     end
@@ -81,9 +88,6 @@ module DEBUGGER__
     end
 
     def process
-      @q_msg = Queue.new
-      @q_ans = Queue.new
-
       pause
 
       while line = @sock.gets
@@ -141,12 +145,20 @@ module DEBUGGER__
       if s = @sock         # already connection
         # ok
       elsif skip == true   # skip process
-        return yield nil
+        no_sock = true
+        r = @accept_m.synchronize do
+          if @sock
+            no_sock = false
+          else
+            yield nil
+          end
+        end
+        return r if no_sock
       else                 # wait for connection
         until s = @sock
           @accept_m.synchronize{
             unless @sock
-              DEBUGGER__.message "wait for debuger connection..."
+              DEBUGGER__.warn "wait for debuger connection..."
               @accept_cv.wait(@accept_m)
             end
           }
@@ -190,6 +202,7 @@ module DEBUGGER__
     def readline
       (sock do |s|
         s.puts "input"
+        sleep 0.01 until @q_msg
         @q_msg.pop
       end || 'continue').strip
     end
@@ -224,7 +237,7 @@ module DEBUGGER__
 
     def accept
       Socket.tcp_server_sockets @host, @port do |socks|
-        ::DEBUGGER__.message "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
+        ::DEBUGGER__.warn "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
         Socket.accept_loop(socks) do |sock, client|
           @client_addr = client
           yield sock
@@ -254,7 +267,7 @@ module DEBUGGER__
         @sock_path = DEBUGGER__.create_unix_domain_socket_name(@sock_dir)
       end
 
-      ::DEBUGGER__.message "Debugger can attach via UNIX domain socket (#{@sock_path})"
+      ::DEBUGGER__.warn "Debugger can attach via UNIX domain socket (#{@sock_path})"
       Socket.unix_server_loop @sock_path do |sock, client|
         @client_addr = client
         yield sock
@@ -263,8 +276,4 @@ module DEBUGGER__
       end
     end
   end
-
-  def self.message msg
-    $stderr.puts "DEBUGGER: #{msg}"
-  end
 end

data/lib/debug/server_dap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module DEBUGGER__
@@ -5,7 +7,7 @@ module DEBUGGER__
     SHOW_PROTOCOL = ENV['RUBY_DEBUG_DAP_SHOW_PROTOCOL'] == '1'
 
     def dap_setup bytes
-      DEBUGGER__.set_config(use_colorize: false)
+      DEBUGGER__.set_config(no_color: true)
       @seq = 0
 
       $stderr.puts '[>]' + bytes if SHOW_PROTOCOL
@@ -436,7 +438,7 @@ module DEBUGGER__
       when :backtrace
         event! :dap_result, :backtrace, req, {
           stackFrames: @target_frames.map.with_index{|frame, i|
-            path = frame.path
+            path = frame.realpath
             ref = frame.file_lines unless File.exist?(path)
 
             {

data/lib/debug/session.rb

@@ -1,4 +1,5 @@
-
+# frozen_string_literal: true
+
 # skip to load debugger for bundle exec
 return if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
 
@@ -52,6 +53,8 @@ class RubyVM::InstructionSequence
 end
 
 module DEBUGGER__
+  PresetCommand = Struct.new(:commands, :source, :auto_continue)
+
   class Session
     def initialize ui
       @ui = ui
@@ -67,7 +70,7 @@ module DEBUGGER__
       @displays = []
       @tc = nil
       @tc_id = 0
-      @initial_commands = []
+      @preset_command = nil
 
       @frame_map = {} # {id => [threadId, frame_depth]} for DAP
       @var_map   = {1 => [:globals], } # {id => ...} for DAP
@@ -98,6 +101,12 @@ module DEBUGGER__
       @tp_thread_begin.enable
     end
 
+    def reset_ui ui
+      @ui.close
+      @ui = ui
+      @management_threads << @ui.reader_thread if @ui.respond_to? :reader_thread
+    end
+
     def session_server_main
       while evt = @q_evt.pop
         # varible `@internal_info` is only used for test
@@ -105,6 +114,8 @@ module DEBUGGER__
         output.each{|str| @ui.puts str}
 
         case ev
+        when :init
+          wait_command_loop tc
         when :load
           iseq, src = ev_args
           on_load iseq, src
@@ -133,10 +144,6 @@ module DEBUGGER__
           end
         when :result
           case ev_args.first
-          when :watch
-            bp = ev_args[1]
-            @bps[bp.key] = bp
-            show_bps bp
           when :try_display
             failed_results = ev_args[1]
             if failed_results.size > 0
@@ -145,10 +152,10 @@ module DEBUGGER__
                 @ui.puts "canceled: #{@displays.pop}"
               end
             end
-          when :method_breakpoint
+          when :method_breakpoint, :watch_breakpoint
             bp = ev_args[1]
             if bp
-              @bps[bp.key] = bp
+              add_breakpoint(bp)
               show_bps bp
             else
               # can't make a bp
@@ -169,15 +176,24 @@ module DEBUGGER__
       @th_clients.each{|th, thc| thc.close}
     end
 
-    def add_initial_commands cmds
-      cmds.each{|c|
-        c.gsub('#.*', '').strip!
-        @initial_commands << c unless c.empty?
-      }
+    def add_preset_commands name, cmds, kick: true, continue: true
+      cs = cmds.map{|c|
+        c = c.strip.gsub(/\A\s*\#.*/, '').strip
+        c unless c.empty?
+      }.compact
+
+      unless cs.empty?
+        if @preset_command
+          @preset_command.commands += cs
+        else
+          @preset_command = PresetCommand.new(cs, name, continue)
+        end
+        ThreadClient.current.on_init name if kick
+      end
     end
 
     def source iseq
-      if CONFIG[:use_colorize]
+      if !CONFIG[:no_color]
         @sr.get_colored(iseq)
       else
         @sr.get(iseq)
@@ -207,12 +223,23 @@ module DEBUGGER__
     end
 
     def wait_command
-      if @initial_commands.empty?
+      if @preset_command
+        if @preset_command.commands.empty?
+          if @preset_command.auto_continue
+            @preset_command = nil
+            @tc << :continue
+            return
+          else
+            @preset_command = nil
+            return :retry
+          end
+        else
+          line = @preset_command.commands.shift
+          @ui.puts "(rdbg:#{@preset_command.source}) #{line}"
+        end
+      else
         @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_MODE']
         line = @ui.readline
-      else
-        line = @initial_commands.shift.strip
-        @ui.puts "(rdbg:init) #{line}"
       end
 
       case line
@@ -247,21 +274,25 @@ module DEBUGGER__
       # * `s[tep]`
       #   * Step in. Resume the program until next breakable point.
       when 's', 'step'
+        cancel_auto_continue
         @tc << [:step, :in]
 
       # * `n[ext]`
       #   * Step over. Resume the program until next line.
       when 'n', 'next'
+        cancel_auto_continue
         @tc << [:step, :next]
 
       # * `fin[ish]`
       #   * Finish this frame. Resume the program until the current frame is finished.
       when 'fin', 'finish'
+        cancel_auto_continue
         @tc << [:step, :finish]
 
       # * `c[ontinue]`
       #   * Resume the program.
       when 'c', 'continue'
+        cancel_auto_continue
         @tc << :continue
 
       # * `q[uit]` or `Ctrl-D`
@@ -366,8 +397,8 @@ module DEBUGGER__
       #   * Stop the execution when the result of current scope's `@ivar` is changed.
       #   * Note that this feature is super slow.
       when 'wat', 'watch'
-        if arg
-          @tc << [:eval, :watch, arg]
+        if arg && arg.match?(/\A@\w+/)
+          @tc << [:breakpoint, :watch, arg]
         else
           show_bps
           return :retry
@@ -481,9 +512,7 @@ module DEBUGGER__
         case arg
         when /(\d+)/
           if @displays[n = $1.to_i]
-            if ask "clear \##{n} #{@displays[n]}?"
-              @displays.delete_at n
-            end
+            @displays.delete_at n
           end
           @tc << [:eval, :display, @displays]
         when nil
@@ -560,6 +589,9 @@ module DEBUGGER__
         end
         @tc << [:eval, :call, 'binding.irb']
 
+        # don't repeat irb command
+        @repl_prev_line = nil
+
       ### Thread control
 
       # * `th[read]`
@@ -608,6 +640,12 @@ module DEBUGGER__
       return :retry
     end
 
+    def cancel_auto_continue
+      if @preset_command&.auto_continue
+        @preset_command.auto_continue = false
+      end
+    end
+
     def show_help arg
       DEBUGGER__.helps.each{|cat, cs|
         cs.each{|ws, desc|
@@ -883,10 +921,16 @@ module DEBUGGER__
 
     def add_breakpoint bp
       if @bps.has_key? bp.key
-        @ui.puts "duplicated breakpoint: #{bp}"
+        unless bp.duplicable?
+          @ui.puts "duplicated breakpoint: #{bp}"
+          bp.disable
+        end
       else
         @bps[bp.key] = bp
       end
+
+      # don't repeat commands that add breakpoints
+      @repl_prev_line = nil
     end
 
     def rehash_bps
@@ -932,6 +976,7 @@ module DEBUGGER__
     def add_line_breakpoint file, line, **kw
       file = resolve_path(file)
       bp = LineBreakpoint.new(file, line, **kw)
+
       add_breakpoint bp
     rescue Errno::ENOENT => e
       @ui.puts e.message
@@ -1022,44 +1067,71 @@ module DEBUGGER__
 
   # start methods
 
-  def self.console **kw
+  def self.start nonstop: false, **kw
     set_config(kw)
 
-    require_relative 'console'
-
-    initialize_session UI_Console.new
+    unless defined? SESSION
+      require_relative 'console'
+      initialize_session UI_Console.new
+    end
 
-    @prev_handler = trap(:SIGINT){
-      ThreadClient.current.on_trap :SIGINT
-    }
+    setup_initial_suspend unless nonstop
   end
 
-  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_path: nil, sock_dir: nil, **kw
+  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_path: nil, sock_dir: nil, nonstop: false, **kw
     set_config(kw)
 
     if port
-      open_tcp host: host, port: port
+      open_tcp host: host, port: port, nonstop: nonstop
     else
-      open_unix sock_path: sock_path, sock_dir: sock_dir
+      open_unix sock_path: sock_path, sock_dir: sock_dir, nonstop: nonstop
     end
   end
 
-  def self.open_tcp host: nil, port:, **kw
+  def self.open_tcp host: nil, port:, nonstop: false, **kw
     set_config(kw)
     require_relative 'server'
-    initialize_session UI_TcpServer.new(host: host, port: port)
+
+    if defined? SESSION
+      SESSION.reset_ui UI_TcpServer.new(host: host, port: port)
+    else
+      initialize_session UI_TcpServer.new(host: host, port: port)
+    end
+
+    setup_initial_suspend unless nonstop
   end
 
-  def self.open_unix sock_path: nil, sock_dir: nil, **kw
+  def self.open_unix sock_path: nil, sock_dir: nil, nonstop: false, **kw
     set_config(kw)
     require_relative 'server'
-    initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+
+    if defined? SESSION
+      SESSION.reset_ui UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+    else
+      initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+    end
+
+    setup_initial_suspend unless nonstop
   end
 
   # boot utilities
 
+  def self.setup_initial_suspend
+    if !::DEBUGGER__::CONFIG[:nonstop]
+      if loc = ::DEBUGGER__.require_location
+        # require 'debug/console' or 'debug'
+        add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
+      else
+        # -r
+        add_line_breakpoint $0, 1, oneshot: true, hook_call: false
+      end
+    end
+  end
+
   class << self
     define_method :initialize_session do |ui|
+      DEBUGGER__.warn "Session start (pid: #{Process.pid})"
+
       ::DEBUGGER__.const_set(:SESSION, Session.new(ui))
 
       # default breakpoints
@@ -1067,10 +1139,15 @@ module DEBUGGER__
       # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
 
       Binding.module_eval do
-        def bp command: nil
+        def bp command: nil, nonstop: nil
           if command
             cmds = command.split(";;")
-            SESSION.add_initial_commands cmds
+            # nonstop
+            #  nil, true -> auto_continue
+            #  false     -> stop
+            SESSION.add_preset_commands 'binding.bp(command:)', cmds,
+                                        kick: false,
+                                        continue: nonstop == false ? false : true
           end
 
           ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true
@@ -1078,36 +1155,26 @@ module DEBUGGER__
         end
       end
 
-      if !::DEBUGGER__::CONFIG[:nonstop]
-        if loc = ::DEBUGGER__.require_location
-          # require 'debug/console' or 'debug'
-          add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
-        else
-          # -r
-          add_line_breakpoint $0, 1, oneshot: true, hook_call: false
-        end
-      end
-
       load_rc
     end
   end
 
   def self.load_rc
-    ['./rdbgrc.rb', File.expand_path('~/.rdbgrc.rb')].each{|path|
-      if File.file? path
-        load path
-      end
-    }
-
-    # debug commands file
-    [init_script = ::DEBUGGER__::CONFIG[:init_script],
-     './.rdbgrc',
-     File.expand_path('~/.rdbgrc')].each{|path|
-       next unless path
+    [[File.expand_path('~/.rdbgrc'), true],
+     [File.expand_path('~/.rdbgrc.rb'), true],
+     # ['./.rdbgrc', true], # disable because of security concern
+     [::DEBUGGER__::CONFIG[:init_script], false],
+     ].each{|(path, rc)|
+      next unless path
+      next if rc && ::DEBUGGER__::CONFIG[:no_rc] # ignore rc
 
       if File.file? path
-        ::DEBUGGER__::SESSION.add_initial_commands File.readlines(path)
-      elsif path == init_script
+        if path.end_with?('.rb')
+          load path
+        else
+          ::DEBUGGER__::SESSION.add_preset_commands path, File.readlines(path)
+        end
+      elsif !rc
         warn "Not found: #{path}"
       end
     }
@@ -1115,7 +1182,7 @@ module DEBUGGER__
     # given debug commands
     if ::DEBUGGER__::CONFIG[:commands]
       cmds = ::DEBUGGER__::CONFIG[:commands].split(';;')
-      ::DEBUGGER__::SESSION.add_initial_commands cmds
+      ::DEBUGGER__::SESSION.add_preset_commands "commands", cmds, kick: false, continue: false
     end
   end
 
@@ -1194,4 +1261,13 @@ module DEBUGGER__
       str
     end
   end
+
+  def self.warn msg, level = :warn
+    case level
+    when :warn
+      STDERR.puts "DEBUGGER: #{msg}" unless CONFIG[:quiet]
+    when :error
+      STDERR.puts "DEBUGGER: #{msg}"
+    end
+  end
 end