debug 1.0.0.beta5 → 1.0.0.rc1

data/lib/debug/console.rb

@@ -1,49 +1,87 @@
-require_relative 'session'
-return unless defined?(DEBUGGER__)
+# frozen_string_literal: true
+module DEBUGGER__
+  class Console
+    begin
+      raise LoadError if CONFIG[:no_reline]
+      require 'reline'
 
-require 'io/console/size'
+      # reline 0.2.7 or later is required.
+      raise LoadError if Reline::VERSION < '0.2.6'
 
-module DEBUGGER__
-  class UI_Console < UI_Base
-    def initialize
-    end
+      require_relative 'color'
+      include Color
 
-    def remote?
-      false
-    end
+      # 0.2.7 has SIGWINCH issue on non-main thread
+      class ::Reline::LineEditor
+        m = Module.new do
+          def reset(prompt = '', encoding:)
+            super
+            Signal.trap(:SIGWINCH, nil)
+          end
+        end
+        prepend m
+      end
 
-    def width
-      IO.console_size[1]
-    end
+      def readline_setup prompt
+        commands = DEBUGGER__.commands
 
-    def quit n
-      exit n
-    end
+        Reline.completion_proc = -> given do
+          buff = Reline.line_buffer
+          Reline.completion_append_character= ' '
 
-    def ask prompt
-      setup_interrupt do
-        print prompt
-        (gets || '').strip
+          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)
+              Reline.completion_append_character= '/'
+            end
+            files
+          else
+            commands.keys.grep(/\A#{given}/)
+          end
+        end
+
+        Reline.output_modifier_proc = -> buff, **kw do
+          c, rest = get_command buff
+
+          case
+          when commands.keys.include?(c = c.strip)
+            # [:DIM, :CYAN, :BLUE, :CLEAR, :UNDERLINE, :REVERSE, :RED, :GREEN, :MAGENTA, :BOLD, :YELLOW]
+            cmd = colorize(c.strip, [:CYAN, :UNDERLINE])
+
+            if commands[c] == c
+              rprompt = colorize("    # command", [:DIM])
+            else
+              rprompt = colorize("    # #{commands[c]} command", [:DIM])
+            end
+
+            rest = (rest ? colorize_code(rest) : '') + rprompt
+            cmd + rest
+          when !rest && /\A\s*[a-z]*\z/ =~ c
+            buff
+          else
+            colorize_code(buff.chomp) + colorize("    # ruby", [:DIM])
+          end
+        end
       end
-    end
 
-    def puts str = nil
-      case str
-      when Array
-        str.each{|line|
-          $stdout.puts line.chomp
-        }
-      when String
-        str.each_line{|line|
-          $stdout.puts line.chomp
-        }
-      when nil
-        $stdout.puts
+      private def get_command line
+        case line.chomp
+        when /\A(\s*[a-z]+)(\s.*)?\z$/
+          return $1, $2
+        else
+          line.chomp
+        end
+      end
+
+      def readline prompt
+        readline_setup prompt
+        Reline.readmultiline(prompt, true){ true }
       end
-    end
 
+    rescue LoadError
     begin
-      require 'readline'
+      require 'readline.so'
 
       def readline_setup
         Readline.completion_proc = proc{|given|
@@ -58,38 +96,22 @@ module DEBUGGER__
             end
             files
           else
-            DEBUGGER__.commands.grep(/\A#{given}/)
+            DEBUGGER__.commands.keys.grep(/\A#{given}/)
           end
         }
       end
 
-      def readline_body
+      def readline prompt
         readline_setup
-        Readline.readline("\n(rdbg) ", true)
+        Readline.readline(prompt, true)
       end
+
     rescue LoadError
-      def readline_body
-        print "\n(rdbg) "
+      def readline prompt
+        print prompt
         gets
       end
     end
-
-    def readline
-      setup_interrupt do
-        (readline_body || 'quit').strip
-      end
-    end
-
-    def setup_interrupt
-      current_thread = Thread.current # should be session_server thread
-
-      prev_handler = trap(:INT){
-        current_thread.raise Interrupt
-      }
-
-      yield
-    ensure
-      trap(:INT, prev_handler)
     end
   end
 end

data/lib/debug/frame_info.rb

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
 
 module DEBUGGER__
   FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
                           :has_return_value, :return_value,
                           :has_raised_exception, :raised_exception,
-                          :show_line)
+                          :show_line,
+                          :_local_variables, :_callee # for recorder
+                        )
 
   # extend FrameInfo with debug.so
   if File.exist? File.join(__dir__, 'debug.so')
     require_relative 'debug.so'
   else
-    require "debug/debug"
+    require_relative 'debug'
   end
 
   class FrameInfo
@@ -24,10 +27,10 @@ module DEBUGGER__
     end
 
     def pretty_path
-      use_short_path = ::DEBUGGER__::CONFIG[:use_short_path]
+      use_short_path = CONFIG[:use_short_path]
 
       case
-      when use_short_path && path.start_with?(dir = ::DEBUGGER__::CONFIG["rubylibdir"] + '/')
+      when use_short_path && path.start_with?(dir = CONFIG["rubylibdir"] + '/')
         path.sub(dir, '$(rubylibdir)/')
       when use_short_path && Gem.path.any? do |gp|
           path.start_with?(dir = gp + '/gems/')
@@ -61,7 +64,7 @@ module DEBUGGER__
     end
 
     def frame_type
-      if binding && iseq
+      if self.local_variables && iseq
         if iseq.type == :block
           :block
         elsif callee
@@ -101,11 +104,11 @@ module DEBUGGER__
     end
 
     def callee
-      @callee ||= binding&.eval('__callee__', __FILE__, __LINE__)
+      self._callee ||= self.binding&.eval('__callee__')
     end
 
     def return_str
-      if binding && iseq && has_return_value
+      if self.binding && iseq && has_return_value
         DEBUGGER__.short_inspect(return_value)
       end
     end
@@ -114,6 +117,33 @@ module DEBUGGER__
       "#{pretty_path}:#{location.lineno}"
     end
 
+    private def make_binding
+      __newb__ = self.self.instance_eval('binding')
+      self.local_variables.each{|var, val|
+        __newb__.local_variable_set(var, val)
+      }
+      __newb__
+    end
+
+    def eval_binding
+      if b = self.binding
+        b
+      elsif self.local_variables
+        make_binding
+      end
+    end
+
+    def local_variables
+      if lvars = self._local_variables
+        lvars
+      elsif b = self.binding
+        lvars = b.local_variables.map{|var|
+          [var, b.local_variable_get(var)]
+        }.to_h
+        self._local_variables = lvars
+      end
+    end
+
     private
 
     def get_singleton_class obj
@@ -122,11 +152,15 @@ module DEBUGGER__
       nil
     end
 
+    private def local_variable_get var
+      local_variables[var]
+    end
+
     def parameters_info(argc)
       vars = iseq.locals[0...argc]
       vars.map{|var|
         begin
-          { name: var, value: DEBUGGER__.short_inspect(binding.local_variable_get(var)) }
+          { name: var, value: DEBUGGER__.short_inspect(local_variable_get(var)) }
         rescue NameError, TypeError
           nil
         end

data/lib/debug/local.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'io/console/size'
+require_relative 'console'
+
+module DEBUGGER__
+  class UI_LocalConsole < UI_Base
+    def initialize
+      @console = Console.new
+
+      unless CONFIG[:no_sigint_hook]
+        @prev_handler = trap(:SIGINT){
+          if SESSION.active?
+            ThreadClient.current.on_trap :SIGINT
+          end
+        }
+      end
+    end
+
+    def close
+      if @prev_handler
+        trap(:SIGINT, @prev_handler)
+      end
+    end
+
+    def remote?
+      false
+    end
+
+    def activate on_fork: false
+      # Do nothing
+    end
+
+    def deactivate
+      # Do nothing
+    end
+
+    def width
+      if (w = IO.console_size[1]) == 0 # for tests PTY
+        80
+      else
+        w
+      end
+    end
+
+    def quit n
+      exit n
+    end
+
+    def ask prompt
+      setup_interrupt do
+        print prompt
+        ($stdin.gets || '').strip
+      end
+    end
+
+    def puts str = nil
+      case str
+      when Array
+        str.each{|line|
+          $stdout.puts line.chomp
+        }
+      when String
+        str.each_line{|line|
+          $stdout.puts line.chomp
+        }
+      when nil
+        $stdout.puts
+      end
+    end
+
+    def readline prompt = '(rdbg)'
+      setup_interrupt do
+        (@console.readline(prompt) || 'quit').strip
+      end
+    end
+
+    def setup_interrupt
+      current_thread = Thread.current # should be session_server thread
+
+      prev_handler = trap(:INT){
+        current_thread.raise Interrupt
+      }
+
+      yield
+    ensure
+      trap(:INT, prev_handler)
+    end
+  end
+end
+

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.
@@ -6,7 +7,7 @@
 # Otherwise, UNIX domain socket is used.
 #
 
-require_relative 'server'
+require_relative 'session'
 return unless defined?(DEBUGGER__)
 
 DEBUGGER__.open

data/lib/debug/open_nonstop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+#
+# Open the door for the debugger to connect.
+# Unlike debug/open, it does not stop at the beginning of the program.
+# Users can connect to debuggee program with "rdbg --attach" option or
+# VSCode attach type.
+#
+# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
+# Otherwise, UNIX domain socket is used.
+#
+
+require_relative 'session'
+return unless defined?(DEBUGGER__)
+
+DEBUGGER__.open(nonstop: true)

data/lib/debug/server.rb

@@ -1,29 +1,49 @@
-require 'socket'
-
-require_relative 'session'
-return unless defined?(DEBUGGER__)
+# frozen_string_literal: true
 
+require 'socket'
 require_relative 'config'
 require_relative 'version'
 
 module DEBUGGER__
   class UI_ServerBase < UI_Base
     def initialize
-      @sock = nil
+      @sock = @sock_for_fork = nil
       @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
 
+      activate
+    end
+
+    class Terminate < StandardError
+    end
+
+    def deactivate
+      @reader_thread.raise Terminate
+    end
+
+    def accept
+      if @sock_for_fork
+        begin
+          yield @sock_for_fork, already_connected: true
+        ensure
+          @sock_for_fork.close
+          @sock_for_fork = nil
+        end
+      end
+    end
+
+    def activate on_fork: false
       @reader_thread = Thread.new do
         # An error on this thread should break the system.
         Thread.current.abort_on_exception = true
 
-        accept do |server|
-          DEBUGGER__.message "Connected."
+        accept do |server, already_connected: false|
+          DEBUGGER__.warn "Connected."
 
           @accept_m.synchronize{
             @sock = server
@@ -36,20 +56,31 @@ module DEBUGGER__
               @sock.puts m
             }
             @unsent_messages.clear
-          }
+
+            @q_msg = Queue.new
+            @q_ans = Queue.new
+          } unless already_connected
 
           setup_interrupt do
+            pause unless already_connected
             process
           end
 
+        rescue Terminate
+          raise # should catch at outer scope
         rescue => e
-          DEBUGGER__.message "ReaderThreadError: #{e}"
+          DEBUGGER__.warn "ReaderThreadError: #{e}"
         ensure
-          DEBUGGER__.message "Disconnected."
+          DEBUGGER__.warn "Disconnected."
           @sock = nil
           @q_msg.close
+          @q_msg = nil
           @q_ans.close
-        end
+          @q_ans = nil
+        end # accept
+
+      rescue Terminate
+        # ignore
       end
     end
 
@@ -81,11 +112,6 @@ module DEBUGGER__
     end
 
     def process
-      @q_msg = Queue.new
-      @q_ans = Queue.new
-
-      pause
-
       while line = @sock.gets
         case line
         when /\Apause/
@@ -129,10 +155,6 @@ module DEBUGGER__
       trap(:SIGINT, prev_handler)
     end
 
-    def accept
-      raise "NOT IMPLEMENTED ERROR"
-    end
-
     attr_reader :reader_thread
 
     class NoRemoteError < Exception; end
@@ -141,12 +163,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 debugger connection..."
               @accept_cv.wait(@accept_m)
             end
           }
@@ -187,11 +217,15 @@ module DEBUGGER__
       end
     end
 
-    def readline
-      (sock do |s|
+    def readline prompt
+      input = (sock do |s|
         s.puts "input"
+        sleep 0.01 until @q_msg
+
         @q_msg.pop
       end || 'continue').strip
+
+      input
     end
 
     def pause
@@ -209,9 +243,9 @@ module DEBUGGER__
 
   class UI_TcpServer < UI_ServerBase
     def initialize host: nil, port: nil
-      @host = host || ::DEBUGGER__::CONFIG[:host] || '127.0.0.1'
+      @host = host || CONFIG[:host] || '127.0.0.1'
       @port = port || begin
-        port_str = ::DEBUGGER__::CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
+        port_str = CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
         if /\A\d+\z/ !~ port_str
           raise "Specify digits for port number"
         else
@@ -223,17 +257,34 @@ module DEBUGGER__
     end
 
     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}})"
-        Socket.accept_loop(socks) do |sock, client|
-          @client_addr = client
-          yield sock
+      retry_cnt = 0
+      super # for fork
+
+      begin
+        Socket.tcp_server_sockets @host, @port do |socks|
+          ::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_for_fork = sock
+          end
         end
+      rescue Errno::EADDRINUSE
+        if retry_cnt < 10
+          retry_cnt += 1
+          sleep 0.1
+          retry
+        else
+          raise
+        end
+      rescue Terminate
+        # OK
+      rescue => e
+        $stderr.puts e.inspect, e.message
+        pp e.backtrace
+        exit
       end
-    rescue => e
-      $stderr.puts e.message
-      pp e.backtrace
-      exit
+    ensure
+      @sock_for_fork = nil
     end
   end
 
@@ -241,30 +292,32 @@ module DEBUGGER__
     def initialize sock_dir: nil, sock_path: nil
       @sock_path = sock_path
       @sock_dir = sock_dir || DEBUGGER__.unix_domain_socket_dir
+      @sock_for_fork = nil
 
       super()
     end
 
     def accept
+      super # for fork
+
       case
       when @sock_path
-      when sp = ::DEBUGGER__::CONFIG[:sock_path]
+      when sp = CONFIG[:sock_path]
         @sock_path = sp
       else
         @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|
+        @sock_for_fork = sock
         @client_addr = client
+
         yield sock
       ensure
         sock.close
+        @sock_for_fork = nil
       end
     end
   end
-
-  def self.message msg
-    $stderr.puts "DEBUGGER: #{msg}"
-  end
 end