debug 1.0.0.beta4 → 1.0.0.beta8

data/lib/debug/client.rb

@@ -1,5 +1,12 @@
+# frozen_string_literal: true
+
 require 'socket'
+require 'io/console/size'
+
 require_relative 'config'
+require_relative 'version'
+
+# $VERBOSE = true
 
 module DEBUGGER__
   class CommandLineOptionError < Exception; end
@@ -8,16 +15,18 @@ module DEBUGGER__
     begin
       require 'readline'
       def readline
-        Readline.readline("\n(rdb) ", true)
+        Readline.readline("\n(rdbg:remote) ", true)
       end
     rescue LoadError
       def readline
-        print "\n(rdb) "
+        print "\n(rdbg:remote) "
         gets
       end
     end
 
     def initialize argv
+      return util(argv) if String === argv
+
       case argv.size
       when 0
         connect_unix
@@ -36,6 +45,24 @@ module DEBUGGER__
       else
         raise CommandLineOptionError
       end
+
+      @width = IO.console_size[1]
+      @width = 80 if @width == 0
+      @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 +77,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 +111,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 +142,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
@@ -119,10 +165,6 @@ module DEBUGGER__
   end
 end
 
-def connect argv = ARGV
-  DEBUGGER__::Client.new(argv).connect
-end
-
 if __FILE__ == $0
-  connect
+  DEBUGGER__::Client.new(argv).connect
 end

data/lib/debug/color.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+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[:no_color]
+          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, width = SESSION.width
+        if !CONFIG[:no_color]
+          IRB::ColorPrinter.pp(obj, "".dup, width)
+        else
+          obj.pretty_inspect
+        end
+      end
+    else
+      def color_pp obj
+        obj.pretty_inspect
+      end
+    end
+
+    def colored_inspect obj, no_color: false
+      if !no_color
+        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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module DEBUGGER__
   def self.unix_domain_socket_dir
@@ -29,83 +30,139 @@ module DEBUGGER__
     create_unix_domain_socket_name_prefix(base_dir) + "-#{Process.pid}"
   end
 
-  CONFIG_MAP = {
-    # boot setting
-    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 ';;'
-
+  CONFIG_SET = {
     # 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
-
-    # remote
-    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
-    sock_dir:    'RUBY_DEBUG_SOCK_DIR',    # UNIX Domain Socket remote debugging: socket directory
+    log_level:      ['RUBY_DEBUG_LOG_LEVEL',      "UI: Log level same as Logger (default: WARN)",                   :loglevel],
+    show_src_lines: ['RUBY_DEBUG_SHOW_SRC_LINES', "UI: Show n lines source code on breakpoint (default: 10 lines)", :int],
+    show_frames:    ['RUBY_DEBUG_SHOW_FRAMES',    "UI: Show n frames on breakpoint (default: 2 frames)",            :int],
+    show_info_lines:['RUBY_DEBUG_SHOW_INFO_LINES',"UI: Show n lines on info command (default: 10 lines, 0 for unlimited)",   :int],
+    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shoten PATH (like $(Gem)/foo.rb)",                      :bool],
+    skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "UI: Skip on no source code lines (default: false)",              :bool],
+    skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "UI: Skip showing frames for given paths (default: [])",          :path],
+    no_color:       ['RUBY_DEBUG_NO_COLOR',       "UI: Do not use colorize (default: false)",                       :bool],
+    no_sigint_hook: ['RUBY_DEBUG_NO_SIGINT_HOOK', "UI: Do not suspend on SIGINT (default: false)",                  :bool],
+
+    # boot setting
+    nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool],
+    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],
+
+    # 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"],
   }.freeze
 
-  def self.config_to_env config
-    CONFIG_MAP.each{|key, evname|
-      ENV[evname] = config[key].to_s if config[key]
+  CONFIG_MAP = CONFIG_SET.map{|k, (ev, desc)| [k, ev]}.to_h.freeze
+
+  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_config_value name, valstr
+    return valstr unless valstr.kind_of? String
+
+    case CONFIG_SET[name][2]
+    when :bool
+      case valstr
+      when '1', 'true', 'TRUE', 'T'
+        true
+      else
+        false
+      end
+    when :int
+      valstr.to_i
+    when :loglevel
+      if DEBUGGER__::LOG_LEVELS[s = valstr.to_sym]
+        s
+      else
+        raise "Unknown loglevel: #{valstr}"
+      end
+    when :path # array of String
+      valstr.split(/:/).map{|e|
+        if /\A\/(.+)\/\z/ =~ e
+          Regexp.compile $1
+        else
+          e
+        end
+      }
+    else
+      valstr
+    end
+  end
+
   def self.parse_argv argv
     config = {
       mode: :start,
-      use_colorize: true,
     }
     CONFIG_MAP.each{|key, evname|
       if val = ENV[evname]
-        if /_USE_/ =~ evname || /NONSTOP/ =~ evname
-          case val
-          when '1', 'true', 'TRUE', 'T'
-            config[key] = true
-          else
-            config[key] = false
-          end
-        else
-          config[key] = val
-        end
+        config[key] = parse_config_value(key, val)
       end
     }
     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 DEBUG_COMMAND', 'Execute debug command at the beginning of the script.') do |cmd|
         config[:commands] ||= ''
-        config[:commands] << cmd + ';;'
+        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.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('--no-sigint-hook', 'Disable to trap SIGINT') do
+        config[:no_sigint_hook] = 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 ''
+
+      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'
 
@@ -114,6 +171,9 @@ module DEBUGGER__
       o.separator ''
       o.separator "  '#{rdbg} target.rb foo bar'                starts like 'ruby target.rb foo bar'."
       o.separator "  '#{rdbg} -- -r foo -e bar'                 starts like 'ruby -r foo -e bar'."
+      o.separator "  '#{rdbg} -c rake test'                     starts like 'rake test'."
+      o.separator "  '#{rdbg} -c -- rake test -t'               starts like 'rake test -t'."
+      o.separator "  '#{rdbg} -c bundle exec rake test'         starts like 'bundle exec rake test'."
       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."
@@ -133,6 +193,25 @@ 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('--util=NAME', 'Utility mode (used by tools)') do |name|
+        require_relative 'client'
+        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)
@@ -145,10 +224,22 @@ module DEBUGGER__
   def self.set_config kw
     kw.each{|k, v|
       if CONFIG_MAP[k]
-        CONFIG[k] = v # TODO: ractor support
+        CONFIG[k] = parse_config_value(k, v) # TODO: ractor support
       else
-        raise "unknown option: #{k}"
+        raise "Unknown configuration: #{k}"
       end
     }
   end
+
+  def self.append_config key, val
+    if CONFIG_SET[key]
+      if CONFIG_SET[key][2] == :path
+        CONFIG[key] = [*CONFIG[key], *parse_config_value(key, val)];
+      else
+        raise "not an Array type: #{key}"
+      end
+    else
+      raise "Unknown configuration: #{key}"
+    end
+  end
 end