debug 1.0.0.beta4 → 1.0.0.beta5

data/lib/debug/client.rb

@@ -1,5 +1,10 @@
 require 'socket'
+require 'io/console/size'
+
 require_relative 'config'
+require_relative 'version'
+
+# $VERBOSE = true
 
 module DEBUGGER__
   class CommandLineOptionError < Exception; end
@@ -18,6 +23,8 @@ module DEBUGGER__
     end
 
     def initialize argv
+      return util(argv) if String === argv
+
       case argv.size
       when 0
         connect_unix
@@ -36,6 +43,23 @@ module DEBUGGER__
       else
         raise CommandLineOptionError
       end
+
+      @width = IO.console_size[1]
+      @width_changed = false
+
+      send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"
+    end
+
+    def util name
+      case name
+      when 'gen-sockpath'
+        puts DEBUGGER__.create_unix_domain_socket_name
+      when 'list-socks'
+        cleanup_unix_domain_sockets
+        puts list_connections
+      else
+        raise "Unknown utility: #{name}"
+      end
     end
 
     def cleanup_unix_domain_sockets
@@ -50,16 +74,20 @@ module DEBUGGER__
       end
     end
 
+    def list_connections
+      Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
+    end
+
     def connect_unix name = nil
       if name
         if File.exist? name
           @s = Socket.unix(name)
         else
-          @s = Socket.unix(File.join(DEBUGGER__.unix_domain_socket_basedir, name))
+          @s = Socket.unix(File.join(DEBUGGER__.unix_domain_socket_dir, name))
         end
       else
         cleanup_unix_domain_sockets
-        files = Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
+        files = list_connections
         case files.size
         when 0
           $stderr.puts "No debug session is available."
@@ -80,13 +108,22 @@ module DEBUGGER__
       @s = Socket.tcp(host, port)
     end
 
+    def send msg
+      p send: msg if $VERBOSE
+      @s.puts msg
+    end
+
     def connect
       trap(:SIGINT){
-        @s.puts "pause"
+        send "pause"
+      }
+      trap(:SIGWINCH){
+        @width = IO.console_size[1]
+        @width_changed = true
       }
 
       while line = @s.gets
-        # p line: line
+        p recv: line if $VERBOSE
         case line
         when /^out (.*)/
           puts "#{$1}"
@@ -102,10 +139,16 @@ module DEBUGGER__
           end
 
           line = (line || 'quit').strip
-          @s.puts "command #{line}"
+
+          if @width_changed
+            @width_changed = false
+            send "width #{@width}"
+          end
+
+          send "command #{line}"
         when /^ask (.*)/
           print $1
-          @s.puts "answer #{gets || ''}"
+          send "answer #{gets || ''}"
         when /^quit/
           raise 'quit'
         else

data/lib/debug/color.rb

@@ -0,0 +1,70 @@
+begin
+  require 'irb/color'
+  require "irb/color_printer"
+rescue LoadError
+  warn "DEBUGGER: can not load newer irb for coloring. Write 'gem \"debug\" in your Gemfile."
+end
+
+module DEBUGGER__
+  module Color
+    if defined? IRB::Color.colorize
+      def colorize str, color
+        if CONFIG[:use_colorize]
+          IRB::Color.colorize str, color
+        else
+          str
+        end
+      end
+    else
+      def colorize str, color
+        str
+      end
+    end
+
+    if defined? IRB::ColorPrinter.pp
+      def color_pp obj
+        IRB::ColorPrinter.pp(obj, "")
+      end
+    else
+      def color_pp obj
+        obj.pretty_inspect
+      end
+    end
+
+    def colored_inspect obj
+      if CONFIG[:use_colorize]
+        color_pp obj
+      else
+        obj.pretty_inspect
+      end
+    rescue => ex
+      err_msg = "#{ex.inspect} rescued during inspection"
+      string_result = obj.to_s rescue nil
+
+      # don't colorize the string here because it's not from user's application
+      if string_result
+        %Q{"#{string_result}" from #to_s because #{err_msg}}
+      else
+        err_msg
+      end
+    end
+
+    if defined? IRB::Color.colorize_code
+      def colorize_code code
+        IRB::Color.colorize_code(code)
+      end
+    else
+      def colorize_code code
+        code
+      end
+    end
+
+    def colorize_cyan(str)
+      colorize(str, [:CYAN, :BOLD])
+    end
+
+    def colorize_blue(str)
+      colorize(str, [:BLUE, :BOLD])
+    end
+  end
+end

data/lib/debug/config.rb

@@ -47,6 +47,7 @@ module DEBUGGER__
     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
     sock_dir:    'RUBY_DEBUG_SOCK_DIR',    # UNIX Domain Socket remote debugging: socket directory
+    cookie:      'RUBY_DEBUG_COOKIE',      # Cookie for negotiation
   }.freeze
 
   def self.config_to_env config
@@ -77,35 +78,46 @@ module DEBUGGER__
     return config if !argv || argv.empty?
 
     require 'optparse'
+    require_relative 'version'
 
     opt = OptionParser.new do |o|
       o.banner = "#{$0} [options] -- [debuggee options]"
       o.separator ''
+      o.version = ::DEBUGGER__::VERSION
 
       o.separator 'Debug console mode:'
       o.on('-n', '--nonstop', 'Do not stop at the beginning of the script.') do
         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 + ';;'
       end
 
-      o.on('-O', '--open', 'Start debuggee with opening the debugger port.',
+      o.on('-x FILE', '--init-script=FILE', 'execute debug command in the FILE.') do |file|
+        config[:init_script] = file
+      end
+
+      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
         config[:remote] = true
       end
-      o.on('--sock-path=[SOCK_PATH]', 'UNIX Doman socket path') do |path|
+      o.on('--sock-path=SOCK_PATH', 'UNIX Doman socket path') do |path|
         config[:sock_path] = path
       end
-      o.on('--port=[PORT]', 'Listening TCP/IP port') do |port|
+      o.on('--port=PORT', 'Listening TCP/IP port') do |port|
         config[:port] = port
       end
-      o.on('--host=[HOST]', 'Listening TCP/IP host') do |host|
+      o.on('--host=HOST', 'Listening TCP/IP host') do |host|
         config[:host] = host
       end
+      o.on('--cookie=COOKIE', 'Set a cookie for connection') do |c|
+        config[:cookie] = c
+      end
 
       rdbg = 'rdbg'
 
@@ -133,6 +145,28 @@ module DEBUGGER__
       o.separator "  '#{rdbg} -A path'      tries to connect via UNIX domain socket with given path name."
       o.separator "  '#{rdbg} -A port'      tries to connect to localhost:port via TCP/IP."
       o.separator "  '#{rdbg} -A host port' tries to connect to host:port via TCP/IP."
+
+      o.separator ''
+      o.separator 'Other options:'
+
+      o.on("-h", "--help", "Print help") do
+        puts o
+        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|
+        Client.new(name)
+        exit
+      end
+
+      o.separator ''
+      o.separator 'NOTE'
+      o.separator '  All messages communicated between a debugger and a debuggee are *NOT* encrypted.'
+      o.separator '  Please use the remote debugging feature carefully.'
     end
 
     opt.parse!(argv)

data/lib/debug/console.rb

@@ -1,7 +1,10 @@
 require_relative 'session'
+return unless defined?(DEBUGGER__)
+
+require 'io/console/size'
 
 module DEBUGGER__
-  class UI_Console
+  class UI_Console < UI_Base
     def initialize
     end
 
@@ -9,6 +12,10 @@ module DEBUGGER__
       false
     end
 
+    def width
+      IO.console_size[1]
+    end
+
     def quit n
       exit n
     end

data/lib/debug/frame_info.rb

@@ -1,8 +1,9 @@
 
 module DEBUGGER__
   FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
-                          :has_return_value, :return_value, :show_line)
-
+                          :has_return_value, :return_value,
+                          :has_raised_exception, :raised_exception,
+                          :show_line)
 
   # extend FrameInfo with debug.so
   if File.exist? File.join(__dir__, 'debug.so')
@@ -39,33 +40,73 @@ module DEBUGGER__
       end
     end
 
+    def name
+      # p frame_type: frame_type, self: self
+      case frame_type
+      when :block
+        level, block_loc, _args = block_identifier
+        "block in #{block_loc}#{level}"
+      when :method
+        ci, _args = method_identifier
+        "#{ci}"
+      when :c
+        c_identifier
+      when :other
+        other_identifier
+      end
+    end
+
     def file_lines
-      SESSION.source(realpath || path)
+      SESSION.source(self.iseq)
     end
 
-    def call_identifier_str
+    def frame_type
       if binding && iseq
         if iseq.type == :block
-          if (argc = iseq.argc) > 0
-            args = parameters_info iseq.locals[0...argc]
-            args_str = "{|#{args}|}"
-          end
-
-          location.label.sub('block'){ "block#{args_str}" }
-        elsif (callee = binding.eval('__callee__', __FILE__, __LINE__)) && (argc = iseq.argc) > 0
-          args = parameters_info iseq.locals[0...argc]
-          "#{klass_sig}#{callee}(#{args})"
+          :block
+        elsif callee
+          :method
         else
-          location.label
+          :other
         end
       else
-        "[C] #{klass_sig}#{location.base_label}"
+        :c
       end
     end
 
+    BLOCK_LABL_REGEXP = /\Ablock( \(\d+ levels\))* in (.+)\z/
+
+    def block_identifier
+      return unless frame_type == :block
+      args = parameters_info(iseq.argc)
+      _, level, block_loc = location.label.match(BLOCK_LABL_REGEXP).to_a
+      [level || "", block_loc, args]
+    end
+
+    def method_identifier
+      return unless frame_type == :method
+      args = parameters_info(iseq.argc)
+      ci = "#{klass_sig}#{callee}"
+      [ci, args]
+    end
+
+    def c_identifier
+      return unless frame_type == :c
+      "[C] #{klass_sig}#{location.base_label}"
+    end
+
+    def other_identifier
+      return unless frame_type == :other
+      location.label
+    end
+
+    def callee
+      @callee ||= binding&.eval('__callee__', __FILE__, __LINE__)
+    end
+
     def return_str
       if binding && iseq && has_return_value
-        short_inspect(return_value)
+        DEBUGGER__.short_inspect(return_value)
       end
     end
 
@@ -75,31 +116,21 @@ module DEBUGGER__
 
     private
 
-    SHORT_INSPECT_LENGTH = 40
-
-    def short_inspect obj
-      str = obj.inspect
-      if str.length > SHORT_INSPECT_LENGTH
-        str[0...SHORT_INSPECT_LENGTH] + '...'
-      else
-        str
-      end
-    end
-
     def get_singleton_class obj
       obj.singleton_class # TODO: don't use it
     rescue TypeError
       nil
     end
 
-    def parameters_info vars
+    def parameters_info(argc)
+      vars = iseq.locals[0...argc]
       vars.map{|var|
         begin
-          "#{var}=#{short_inspect(binding.local_variable_get(var))}"
+          { name: var, value: DEBUGGER__.short_inspect(binding.local_variable_get(var)) }
         rescue NameError, TypeError
           nil
         end
-      }.compact.join(', ')
+      }.compact
     end
 
     def klass_sig

data/lib/debug/open.rb

@@ -7,4 +7,6 @@
 #
 
 require_relative 'server'
+return unless defined?(DEBUGGER__)
+
 DEBUGGER__.open

data/lib/debug/run.rb

@@ -1,2 +1,4 @@
 require_relative 'console'
+return unless defined?(DEBUGGER__)
+
 DEBUGGER__.console

data/lib/debug/server.rb

@@ -1,9 +1,13 @@
 require 'socket'
+
 require_relative 'session'
+return unless defined?(DEBUGGER__)
+
 require_relative 'config'
+require_relative 'version'
 
 module DEBUGGER__
-  class UI_ServerBase
+  class UI_ServerBase < UI_Base
     def initialize
       @sock = nil
       @accept_m = Mutex.new
@@ -12,13 +16,19 @@ module DEBUGGER__
       @q_msg = Queue.new
       @q_ans = Queue.new
       @unsent_messages = []
+      @width = 80
 
       @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_m.synchronize{
             @sock = server
+            greeting
+
             @accept_cv.signal
 
             # flush unsent messages
@@ -27,26 +37,13 @@ module DEBUGGER__
             }
             @unsent_messages.clear
           }
-          @q_msg = Queue.new
-          @q_ans = Queue.new
 
           setup_interrupt do
-            pause
-
-            while line = @sock.gets
-              case line
-              when /\Apause/
-                pause
-              when /\Acommand ?(.+)/
-                @q_msg << $1
-              when /\Aanswer (.*)/
-                @q_ans << $1
-              else
-                STDERR.puts "unsupported: #{line}"
-                exit!
-              end
-            end
+            process
           end
+
+        rescue => e
+          DEBUGGER__.message "ReaderThreadError: #{e}"
         ensure
           DEBUGGER__.message "Disconnected."
           @sock = nil
@@ -56,10 +53,64 @@ module DEBUGGER__
       end
     end
 
+    def greeting
+      case g = @sock.gets
+      when /^version:\s+(.+)\s+width: (\d+) cookie:\s+(.*)$/
+        v, w, c = $1, $2, $3
+        # TODO: protocol version
+        if v != VERSION
+          raise "Incompatible version (#{VERSION} client:#{$1})"
+        end
+
+        cookie = CONFIG[:cookie]
+        if cookie && cookie != c
+          raise "Cookie mismatch (#{$2.inspect} was sent)"
+        end
+
+        @width = w.to_i
+
+      when /^Content-Length: (\d+)/
+        require_relative 'server_dap'
+
+        raise unless @sock.read(2) == "\r\n"
+        self.extend(UI_DAP)
+        dap_setup @sock.read($1.to_i)
+      else
+        raise "Greeting message error: #{g}"
+      end
+    end
+
+    def process
+      @q_msg = Queue.new
+      @q_ans = Queue.new
+
+      pause
+
+      while line = @sock.gets
+        case line
+        when /\Apause/
+          pause
+        when /\Acommand ?(.+)/
+          @q_msg << $1
+        when /\Aanswer (.*)/
+          @q_ans << $1
+        when /\Awidth (.+)/
+          @width = $1.to_i
+        else
+          STDERR.puts "unsupported: #{line}"
+          exit!
+        end
+      end
+    end
+
     def remote?
       true
     end
 
+    def width
+      @width
+    end
+
     def setup_interrupt
       prev_handler = trap(:SIGINT) do
         # $stderr.puts "trapped SIGINT"
@@ -158,7 +209,7 @@ module DEBUGGER__
 
   class UI_TcpServer < UI_ServerBase
     def initialize host: nil, port: nil
-      @host = host || ::DEBUGGER__::CONFIG[:host] || 'localhost'
+      @host = host || ::DEBUGGER__::CONFIG[:host] || '127.0.0.1'
       @port = port || begin
         port_str = ::DEBUGGER__::CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
         if /\A\d+\z/ !~ port_str
@@ -207,6 +258,8 @@ module DEBUGGER__
       Socket.unix_server_loop @sock_path do |sock, client|
         @client_addr = client
         yield sock
+      ensure
+        sock.close
       end
     end
   end