debug 1.2.2 → 1.3.1

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
@@ -83,6 +86,24 @@ module DEBUGGER__
         trap(:INT, prev_handler)
       end
     end
+
+    def after_fork_parent
+      parent_pid = Process.pid
+
+      at_exit{
+        SESSION.intercept_trap_sigint_end
+        trap(:SIGINT, :IGNORE)
+
+        if Process.pid == parent_pid
+          # only check child process from its parent
+          begin
+            # wait for all child processes to keep terminal
+            loop{ Process.waitpid }
+          rescue Errno::ESRCH, Errno::ECHILD
+          end
+        end
+      }
+    end
   end
 end
 

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 bb debugger if ENV['RUBY_DEBUG_BB']
+end
+
+class Binding
+  alias break debugger
+  alias b debugger
+end

data/lib/debug/server.rb

@@ -15,6 +15,8 @@ module DEBUGGER__
       @q_ans = nil
       @unsent_messages = []
       @width = 80
+      @repl = true
+      @session = nil
     end
 
     class Terminate < StandardError
@@ -22,6 +24,7 @@ module DEBUGGER__
 
     def deactivate
       @reader_thread.raise Terminate
+      @reader_thread.join
     end
 
     def accept
@@ -36,9 +39,11 @@ module DEBUGGER__
     end
 
     def activate session, on_fork: false
+      @session = session
       @reader_thread = Thread.new do
         # An error on this thread should break the system.
         Thread.current.abort_on_exception = true
+        Thread.current.name = 'DEBUGGER__::Server::reader'
 
         accept do |server, already_connected: false|
           DEBUGGER__.warn "Connected."
@@ -52,7 +57,7 @@ module DEBUGGER__
             # flush unsent messages
             @unsent_messages.each{|m|
               @sock.puts m
-            }
+            } if @repl
             @unsent_messages.clear
 
             @q_msg = Queue.new
@@ -68,6 +73,7 @@ module DEBUGGER__
           raise # should catch at outer scope
         rescue => e
           DEBUGGER__.warn "ReaderThreadError: #{e}"
+          pp e.backtrace
         ensure
           DEBUGGER__.warn "Disconnected."
           @sock = nil
@@ -103,23 +109,58 @@ module DEBUGGER__
 
         raise unless @sock.read(2) == "\r\n"
         self.extend(UI_DAP)
+        @repl = false
         dap_setup @sock.read($1.to_i)
+      when /^GET \/ HTTP\/1.1/
+        require_relative 'server_cdp'
+
+        self.extend(UI_CDP)
+        @repl = false
+        @web_sock = UI_CDP::WebSocket.new(@sock)
+        @web_sock.handshake
       else
         raise "Greeting message error: #{g}"
       end
     end
 
     def process
-      while line = @sock.gets
+      while true
+        DEBUGGER__.info "sleep IO.select"
+        r = IO.select([@sock])
+        DEBUGGER__.info "wakeup IO.select"
+
+        line = @session.process_group.sync do
+          unless IO.select([@sock], nil, nil, 0)
+            DEBUGGER__.info "UI_Server can not read"
+            break :can_not_read
+          end
+          @sock.gets&.chomp.tap{|line|
+            DEBUGGER__.info "UI_Server received: #{line}"
+          }
+        end
+
+        next if line == :can_not_read
+
         case line
         when /\Apause/
           pause
-        when /\Acommand ?(.+)/
-          @q_msg << $1
-        when /\Aanswer (.*)/
-          @q_ans << $1
-        when /\Awidth (.+)/
-          @width = $1.to_i
+        when /\Acommand (\d+) (\d+) ?(.+)/
+          raise "not in subsession, but received: #{line.inspect}" unless @session.in_subsession?
+
+          if $1.to_i == Process.pid
+            @width = $2.to_i
+            @q_msg << $3
+          else
+            raise "pid:#{Process.pid} but get #{line}"
+          end
+        when /\Aanswer (\d+) (.*)/
+          raise "not in subsession, but received: #{line.inspect}" unless @session.in_subsession?
+
+          if $1.to_i == Process.pid
+            @q_ans << $2
+          else
+            raise "pid:#{Process.pid} but get #{line}"
+          end
         else
           STDERR.puts "unsupported: #{line}"
           exit!
@@ -135,6 +176,21 @@ module DEBUGGER__
       @width
     end
 
+    def sigurg_overridden? prev_handler
+      case prev_handler
+      when "SYSTEM_DEFAULT"
+        false
+      when Proc
+        if prev_handler.source_location[0] == __FILE__
+          false
+        else
+          true
+        end
+      else
+        true
+      end
+    end
+
     def setup_interrupt
       prev_handler = trap(:SIGURG) do
         # $stderr.puts "trapped SIGINT"
@@ -148,8 +204,8 @@ module DEBUGGER__
         end
       end
 
-      if prev_handler != "SYSTEM_DEFAULT"
-        DEBUGGER__.warn "SIGURG handler is overriddend by the debugger."
+      if sigurg_overridden?(prev_handler)
+        DEBUGGER__.warn "SIGURG handler is overridden by the debugger."
       end
       yield
     ensure
@@ -191,7 +247,7 @@ module DEBUGGER__
 
     def ask prompt
       sock do |s|
-        s.puts "ask #{prompt}"
+        s.puts "ask #{Process.pid} #{prompt}"
         @q_ans.pop
       end
     end
@@ -220,13 +276,23 @@ module DEBUGGER__
 
     def readline prompt
       input = (sock do |s|
-        s.puts "input"
+        if @repl
+          raise "not in subsession, but received: #{line.inspect}" unless @session.in_subsession?
+          line = "input #{Process.pid}"
+          DEBUGGER__.info "send: #{line}"
+          s.puts line
+        end
         sleep 0.01 until @q_msg
+        @q_msg.pop.tap{|msg|
+          DEBUGGER__.info "readline: #{msg.inspect}"
+        }
+      end || 'continue')
 
-        @q_msg.pop
-      end || 'continue').strip
-
-      input
+      if input.is_a?(String)
+        input.strip
+      else
+        input
+      end
     end
 
     def pause
@@ -240,10 +306,15 @@ module DEBUGGER__
         s.puts "quit"
       end
     end
+
+    def after_fork_parent
+      # do nothing
+    end
   end
 
   class UI_TcpServer < UI_ServerBase
     def initialize host: nil, port: nil
+      @addr = nil
       @host = host || CONFIG[:host] || '127.0.0.1'
       @port = port || begin
         port_str = CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
@@ -263,7 +334,24 @@ module DEBUGGER__
 
       begin
         Socket.tcp_server_sockets @host, @port do |socks|
-          ::DEBUGGER__.warn "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
+          addr = socks[0].local_address.inspect_sockaddr # Change this part if `socks` are multiple.
+          rdbg = File.expand_path('../../exe/rdbg', __dir__)
+
+          DEBUGGER__.warn "Debugger can attach via TCP/IP (#{addr})"
+          DEBUGGER__.info <<~EOS
+          With rdbg, use the following command line:
+          #
+          #   #{rdbg} --attach #{addr.split(':').join(' ')}
+          #
+          EOS
+
+          DEBUGGER__.warn <<~EOS if CONFIG[:open_frontend] == 'chrome'
+          With Chrome browser, type the following URL in the address-bar:
+          
+             devtools://devtools/bundled/inspector.html?ws=#{addr}
+          
+          EOS
+
           Socket.accept_loop(socks) do |sock, client|
             @client_addr = client
             yield @sock_for_fork = sock
@@ -298,6 +386,64 @@ module DEBUGGER__
       super()
     end
 
+    def vscode_setup
+      require 'tmpdir'
+      require 'json'
+      require 'fileutils'
+
+      dir = Dir.mktmpdir("ruby-debug-vscode-")
+      at_exit{
+        FileUtils.rm_rf dir
+      }
+      Dir.chdir(dir) do
+        Dir.mkdir('.vscode')
+        open('README.rb', 'w'){|f|
+          f.puts <<~MSG
+          # Wait for starting the attaching to the Ruby process
+          # This file will be removed at the end of the debuggee process.
+          #
+          # Note that vscode-rdbg extension is needed. Please install if you don't have.
+          MSG
+        }
+        open('.vscode/launch.json', 'w'){|f|
+          f.puts JSON.pretty_generate({
+            version: '0.2.0',
+            configurations: [
+            {
+              type: "rdbg",
+              name: "Attach with rdbg",
+              request: "attach",
+              rdbgPath: File.expand_path('../../exe/rdbg', __dir__),
+              debugPort: @sock_path,
+              autoAttach: true,
+            }
+            ]
+          })
+        }
+      end
+
+      cmds = ['code', "#{dir}/", "#{dir}/README.rb"]
+      cmdline = cmds.join(' ')
+      ssh_cmdline = "code --remote ssh-remote+[SSH hostname] #{dir}/ #{dir}/README.rb"
+
+      STDERR.puts "Launching: #{cmdline}"
+      env = ENV.delete_if{|k, h| /RUBY/ =~ k}.to_h
+
+      unless system(env, *cmds)
+        DEBUGGER__.warn <<~MESSAGE
+        Can not invoke the command.
+        Use the command-line on your terminal (with modification if you need).
+
+          #{cmdline}
+
+        If your application is running on a SSH remote host, please try:
+
+          #{ssh_cmdline}
+
+        MESSAGE
+      end
+    end
+
     def accept
       super # for fork
 
@@ -310,14 +456,29 @@ module DEBUGGER__
       end
 
       ::DEBUGGER__.warn "Debugger can attach via UNIX domain socket (#{@sock_path})"
-      Socket.unix_server_loop @sock_path do |sock, client|
-        @sock_for_fork = sock
-        @client_addr = client
-
-        yield sock
-      ensure
-        sock.close
-        @sock_for_fork = nil
+      vscode_setup if CONFIG[:open_frontend] == 'vscode'
+
+      begin
+        Socket.unix_server_loop @sock_path do |sock, client|
+          @sock_for_fork = sock
+          @client_addr = client
+
+          yield sock
+        ensure
+          sock.close
+          @sock_for_fork = nil
+        end
+      rescue Errno::ECONNREFUSED => _e
+        ::DEBUGGER__.warn "#{_e.message} (socket path: #{@sock_path})"
+
+        if @sock_path.start_with? Config.unix_domain_socket_tmpdir
+          # try on homedir
+          @sock_path = Config.create_unix_domain_socket_name(unix_domain_socket_homedir)
+          ::DEBUGGER__.warn "retry with #{@sock_path}"
+          retry
+        else
+          raise
+        end
       end
     end
   end