debug 1.4.0 → 1.9.2

data/lib/debug/config.rb

@@ -7,46 +7,54 @@ module DEBUGGER__
     ERROR:   2,
     WARN:    3,
     INFO:    4,
+    DEBUG:   5
   }.freeze
 
   CONFIG_SET = {
     # UI setting
-    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],
-    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shorten PATH (like $(Gem)/foo.rb)",                      :bool],
-    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],
-    no_reline:      ['RUBY_DEBUG_NO_RELINE',      "UI: Do not use Reline library (default: false)",                 :bool],
+    log_level:      ['RUBY_DEBUG_LOG_LEVEL',      "UI: Log level same as Logger",               :loglevel, "WARN"],
+    show_src_lines: ['RUBY_DEBUG_SHOW_SRC_LINES', "UI: Show n lines source code on breakpoint", :int, "10"],
+    show_evaledsrc: ['RUBY_DEBUG_SHOW_EVALEDSRC', "UI: Show actually evaluated source",         :bool, "false"],
+    show_frames:    ['RUBY_DEBUG_SHOW_FRAMES',    "UI: Show n frames on breakpoint",            :int, "2"],
+    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shorten PATH (like $(Gem)/foo.rb)", :bool, "false"],
+    no_color:       ['RUBY_DEBUG_NO_COLOR',       "UI: Do not use colorize",                    :bool, "false"],
+    no_sigint_hook: ['RUBY_DEBUG_NO_SIGINT_HOOK', "UI: Do not suspend on SIGINT",               :bool, "false"],
+    no_reline:      ['RUBY_DEBUG_NO_RELINE',      "UI: Do not use Reline library",              :bool, "false"],
+    no_hint:        ['RUBY_DEBUG_NO_HINT',        "UI: Do not show the hint on the REPL",       :bool, "false"],
+    no_lineno:      ['RUBY_DEBUG_NO_LINENO',      "UI: Do not show line numbers",               :bool, "false"],
+    irb_console:    ["RUBY_DEBUG_IRB_CONSOLE",    "UI: Use IRB as the console",                 :bool, "false"],
 
     # control setting
-    skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "CONTROL: Skip showing/entering frames for given paths (default: [])", :path],
-    skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "CONTROL: Skip on no source code lines (default: false)",              :bool],
-    keep_alloc_site:['RUBY_DEBUG_KEEP_ALLOC_SITE',"CONTROL: Keep allocation site and p, pp shows it (default: false)",   :bool],
-    postmortem:     ['RUBY_DEBUG_POSTMORTEM',     "CONTROL: Enable postmortem debug (default: false)",                   :bool],
-    fork_mode:      ['RUBY_DEBUG_FORK_MODE',      "CONTROL: Control which process activates a debugger after fork (both/parent/child) (default: both)", :forkmode],
-    sigdump_sig:    ['RUBY_DEBUG_SIGDUMP_SIG',    "CONTROL: Sigdump signal (default: disabled)"],
+    skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "CONTROL: Skip showing/entering frames for given paths", :path],
+    skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "CONTROL: Skip on no source code lines",              :bool, "false"],
+    keep_alloc_site:['RUBY_DEBUG_KEEP_ALLOC_SITE',"CONTROL: Keep allocation site and p, pp shows it",   :bool, "false"],
+    postmortem:     ['RUBY_DEBUG_POSTMORTEM',     "CONTROL: Enable postmortem debug",                   :bool, "false"],
+    fork_mode:      ['RUBY_DEBUG_FORK_MODE',      "CONTROL: Control which process activates a debugger after fork (both/parent/child)", :forkmode, "both"],
+    sigdump_sig:    ['RUBY_DEBUG_SIGDUMP_SIG',    "CONTROL: Sigdump signal", :bool, "false"],
 
     # boot setting
-    nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool],
-    stop_at_load:   ['RUBY_DEBUG_STOP_AT_LOAD',"BOOT: Stop at just loading location",                               :bool],
+    nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool, "false"],
+    stop_at_load:   ['RUBY_DEBUG_STOP_AT_LOAD',"BOOT: Stop at just loading location",                               :bool, "false"],
     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],
-    history_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file (default: ~/.rdbg_history)"],
-    save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines (default: 10,000)"],
+    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, "false"],
+    history_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file",               :string, "~/.rdbg_history"],
+    save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines", :int, "10000"],
 
     # remote setting
+    open:           ['RUBY_DEBUG_OPEN',         "REMOTE: Open remote port (same as `rdbg --open` option)"],
     port:           ['RUBY_DEBUG_PORT',         "REMOTE: TCP/IP remote debugging: port"],
-    host:           ['RUBY_DEBUG_HOST',         "REMOTE: TCP/IP remote debugging: host (localhost if not given)"],
+    host:           ['RUBY_DEBUG_HOST',         "REMOTE: TCP/IP remote debugging: host", :string, "127.0.0.1"],
     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"],
+    local_fs_map:   ['RUBY_DEBUG_LOCAL_FS_MAP', "REMOTE: Specify local fs map", :path_map],
+    skip_bp:        ['RUBY_DEBUG_SKIP_BP',      "REMOTE: Skip breakpoints if no clients are attached", :bool, 'false'],
     cookie:         ['RUBY_DEBUG_COOKIE',       "REMOTE: Cookie for negotiation"],
-    open_frontend:  ['RUBY_DEBUG_OPEN_FRONTEND',"REMOTE: frontend used by open command (vscode, chrome, default: rdbg)."],
+    session_name:   ['RUBY_DEBUG_SESSION_NAME', "REMOTE: Session name for differentiating multiple sessions"],
     chrome_path:    ['RUBY_DEBUG_CHROME_PATH',  "REMOTE: Platform dependent path of Chrome (For more information, See [here](https://github.com/ruby/debug/pull/334/files#diff-5fc3d0a901379a95bc111b86cf0090b03f857edfd0b99a0c1537e26735698453R55-R64))"],
 
     # obsolete
-    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "OBSOLETE: Keep debugging parent process on fork (default: false)",     :bool],
+    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "OBSOLETE: Keep debugging parent process on fork",     :bool, "false"],
   }.freeze
 
   CONFIG_MAP = CONFIG_SET.map{|k, (ev, _)| [k, ev]}.to_h.freeze
@@ -63,7 +71,17 @@ module DEBUGGER__
         raise 'Can not make multiple configurations in one process'
       end
 
-      update self.class.parse_argv(argv)
+      config = self.class.parse_argv(argv)
+
+      # apply defaults
+      CONFIG_SET.each do |k, config_detail|
+        unless config.key?(k)
+          default_value = config_detail[3]
+          config[k] = parse_config_value(k, default_value)
+        end
+      end
+
+      update config
     end
 
     def inspect
@@ -114,11 +132,13 @@ module DEBUGGER__
       self.class.instance_variable_set(:@config, conf.freeze)
 
       # Post process
-      if_updated old_conf, conf, :keep_alloc_site do |_, new|
+      if_updated old_conf, conf, :keep_alloc_site do |old, new|
         if new
           require 'objspace'
           ObjectSpace.trace_object_allocations_start
-        else
+        end
+
+        if old && !new
           ObjectSpace.trace_object_allocations_stop
         end
       end
@@ -132,6 +152,28 @@ module DEBUGGER__
       if_updated old_conf, conf, :sigdump_sig do |old_sig, new_sig|
         setup_sigdump old_sig, new_sig
       end
+
+      if_updated old_conf, conf, :no_sigint_hook do |old, new|
+        if defined?(SESSION)
+          SESSION.set_no_sigint_hook old, new
+        end
+      end
+
+      if_updated old_conf, conf, :irb_console do |old, new|
+        if defined?(SESSION) && SESSION.active?
+          # irb_console is switched from true to false
+          if old
+            SESSION.deactivate_irb_integration
+          # irb_console is switched from false to true
+          else
+            if CONFIG[:open]
+              SESSION.instance_variable_get(:@ui).puts "\nIRB is not supported on the remote console."
+            else
+              SESSION.activate_irb_integration
+            end
+          end
+        end
+      end
     end
 
     private def if_updated old_conf, new_conf, key
@@ -215,6 +257,8 @@ module DEBUGGER__
             e
           end
         }
+      when :path_map
+        valstr.split(',').map{|e| e.split(':')}
       else
         valstr
       end
@@ -223,6 +267,7 @@ module DEBUGGER__
     def self.parse_argv argv
       config = {
         mode: :start,
+        no_color: (nc = ENV['NO_COLOR']) && !nc.empty?,
       }
       CONFIG_MAP.each{|key, evname|
         if val = ENV[evname]
@@ -239,6 +284,8 @@ module DEBUGGER__
       require 'optparse'
       require_relative 'version'
 
+      have_shown_version = false
+
       opt = OptionParser.new do |o|
         o.banner = "#{$0} [options] -- [debuggee options]"
         o.separator ''
@@ -279,8 +326,25 @@ module DEBUGGER__
                                         'If TCP/IP options are not given, a UNIX domain socket will be used.',
                                         'If FRONTEND is given, prepare for the FRONTEND.',
                                         'Now rdbg, vscode and chrome is supported.') do |f|
-          config[:remote] = true
-          config[:open_frontend] = f.downcase if f
+
+          case f # some format patterns are not documented yet
+          when nil
+            config[:open] = true
+          when /\A\d\z/
+            config[:open] = true
+            config[:port] = f.to_i
+          when /\A(\S+):(\d+)\z/
+            config[:open] = true
+            config[:host] = $1
+            config[:port] = $2.to_i
+          when 'tcp'
+            config[:open] = true
+            config[:port] ||= 0
+          when 'vscode', 'chrome', 'cdp'
+            config[:open] = f&.downcase
+          else
+            raise "Unknown option for --open: #{f}"
+          end
         end
         o.on('--sock-path=SOCK_PATH', 'UNIX Domain socket path') do |path|
           config[:sock_path] = path
@@ -294,6 +358,9 @@ module DEBUGGER__
         o.on('--cookie=COOKIE', 'Set a cookie for connection') do |c|
           config[:cookie] = c
         end
+        o.on('--session-name=NAME', 'Session name') do |name|
+          config[:session_name] = name
+        end
 
         rdbg = 'rdbg'
 
@@ -329,6 +396,16 @@ module DEBUGGER__
         o.separator ''
         o.separator 'Other options:'
 
+        o.on('-v', 'Show version number') do
+          puts o.ver
+          have_shown_version = true
+        end
+
+        o.on('--version', 'Show version number and exit') do
+          puts o.ver
+          exit
+        end
+
         o.on("-h", "--help", "Print help") do
           puts o
           exit
@@ -352,6 +429,13 @@ module DEBUGGER__
 
       opt.parse!(argv)
 
+      if argv.empty?
+        case
+        when have_shown_version && config[:mode] == :start
+          exit
+        end
+      end
+
       config
     end
 
@@ -361,6 +445,8 @@ module DEBUGGER__
           case CONFIG_SET[key][2]
           when :path
             valstr = config[key].map{|e| e.kind_of?(Regexp) ? e.inspect : e}.join(':')
+          when :path_map
+            valstr = config[key].map{|e| e.join(':')}.join(',')
           else
             valstr = config[key].to_s
           end
@@ -380,8 +466,9 @@ module DEBUGGER__
     unless (dir_uid = fs.uid) == (uid = Process.uid)
       raise "#{path} uid is #{dir_uid}, but Process.uid is #{uid}"
     end
-    unless (dir_mode = fs.mode) == 040700 # 4: dir, 7:rwx
-      raise "#{path}'s mode is #{dir_mode.to_s(8)} (should be 040700)"
+
+    if fs.world_writable? && !fs.sticky?
+      raise "#{path} is world writable but not sticky"
     end
 
     path
@@ -391,7 +478,7 @@ module DEBUGGER__
     require 'tmpdir'
 
     if tmpdir = Dir.tmpdir
-      path = File.join(tmpdir, "ruby-debug-sock-#{Process.uid}")
+      path = File.join(tmpdir, "rdbg-#{Process.uid}")
 
       unless File.exist?(path)
         d = Dir.mktmpdir
@@ -404,7 +491,7 @@ module DEBUGGER__
 
   def self.unix_domain_socket_homedir
     if home = ENV['HOME']
-      path = File.join(home, '.ruby-debug-sock')
+      path = File.join(home, '.rdbg-sock')
 
       unless File.exist?(path)
         Dir.mkdir(path, 0700)
@@ -428,12 +515,14 @@ module DEBUGGER__
   end
 
   def self.create_unix_domain_socket_name_prefix(base_dir = unix_domain_socket_dir)
-    user = ENV['USER'] || 'ruby-debug'
-    File.join(base_dir, "ruby-debug-#{user}")
+    File.join(base_dir, "rdbg")
   end
 
   def self.create_unix_domain_socket_name(base_dir = unix_domain_socket_dir)
-    create_unix_domain_socket_name_prefix(base_dir) + "-#{Process.pid}"
+    suffix = "-#{Process.pid}"
+    name = CONFIG[:session_name]
+    suffix << "-#{name}" if name
+    create_unix_domain_socket_name_prefix(base_dir) + suffix
   end
 
   ## Help
@@ -448,10 +537,14 @@ module DEBUGGER__
       when /\A\s*### (.+)/
         cat = $1
         break if $1 == 'END'
-      when /\A      when (.+)/
+      when /\A      register_command (.+)/
         next unless cat
         next unless desc
-        ws = $1.split(/,\s*/).map{|e| e.gsub('\'', '')}
+
+        ws = []
+        $1.gsub(/'([a-z]+)'/){|w|
+          ws << $1
+        }
         helps[cat] << [ws, desc]
         desc = nil
         max_w = ws.max_by{|w| w.length}

data/lib/debug/console.rb

@@ -5,30 +5,21 @@ module DEBUGGER__
       raise LoadError if CONFIG[:no_reline]
       require 'reline'
 
-      # reline 0.2.7 or later is required.
-      raise LoadError if Reline::VERSION < '0.2.7'
-
       require_relative 'color'
-      include Color
 
-      begin
-        prev = trap(:SIGWINCH, nil)
-        trap(:SIGWINCH, prev)
-        SIGWINCH_SUPPORTED = true
-      rescue ArgumentError
-        SIGWINCH_SUPPORTED = false
-      end
+      include Color
 
-      # 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
+      def parse_input buff, commands
+        c, rest = get_command buff
+        case
+        when commands.keys.include?(c)
+          :command
+        when !rest && /\A\s*[a-z]*\z/ =~ c
+          nil
+        else
+          :ruby
         end
-        prepend m
-      end if SIGWINCH_SUPPORTED
+      end
 
       def readline_setup prompt
         load_history_if_not_loaded
@@ -38,7 +29,17 @@ module DEBUGGER__
         prev_output_modifier_proc = Reline.output_modifier_proc
         prev_prompt_proc = Reline.prompt_proc
 
-        Reline.prompt_proc = nil
+        # prompt state
+        state = nil # :command, :ruby, nil (unknown)
+
+        Reline.prompt_proc = -> args, *kw do
+          case state = parse_input(args.first, commands)
+          when nil, :command
+            [prompt]
+          when :ruby
+            [prompt.sub('rdbg'){colorize('ruby', [:RED])}]
+          end * args.size
+        end
 
         Reline.completion_proc = -> given do
           buff = Reline.line_buffer
@@ -52,17 +53,16 @@ module DEBUGGER__
             end
             files
           else
-            commands.keys.grep(/\A#{given}/)
+            commands.keys.grep(/\A#{Regexp.escape(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])
+          case state
+          when :command
+            cmd = colorize(c, [:CYAN, :UNDERLINE])
 
             if commands[c] == c
               rprompt = colorize("    # command", [:DIM])
@@ -70,14 +70,14 @@ module DEBUGGER__
               rprompt = colorize("    # #{commands[c]} command", [:DIM])
             end
 
-            rest = (rest ? colorize_code(rest) : '') + rprompt
-            cmd + rest
-          when !rest && /\A\s*[a-z]*\z/ =~ c
+            rest = rest ? colorize_code(rest) : ''
+            cmd + rest + rprompt
+          when nil
             buff
-          else
-            colorize_code(buff.chomp) + colorize("    # ruby", [:DIM])
+          when :ruby
+            colorize_code(buff)
           end
-        end
+        end unless CONFIG[:no_hint]
 
         yield
 
@@ -90,9 +90,9 @@ module DEBUGGER__
       private def get_command line
         case line.chomp
         when /\A(\s*[a-z]+)(\s.*)?\z$/
-          return $1, $2
+          return $1.strip, $2
         else
-          line.chomp
+          line.strip
         end
       end
 
@@ -143,7 +143,7 @@ module DEBUGGER__
       rescue LoadError
         def readline prompt
           print prompt
-          gets
+          $stdin.gets
         end
 
         def history
@@ -153,7 +153,13 @@ module DEBUGGER__
     end
 
     def history_file
-      CONFIG[:history_file] || File.expand_path("~/.rdbg_history")
+      history_file = CONFIG[:history_file]
+
+      if !history_file.empty?
+        File.expand_path(history_file)
+      else
+        history_file
+      end
     end
 
     FH = "# Today's OMIKUJI: "
@@ -181,7 +187,7 @@ module DEBUGGER__
       if history && @init_history_lines
         added_records = history.to_a[@init_history_lines .. -1]
         path = history_file
-        max = CONFIG[:save_history] || 10_000
+        max = CONFIG[:save_history]
 
         if !added_records.empty? && !path.empty?
           orig_records = read_history_file
@@ -197,11 +203,11 @@ module DEBUGGER__
     end
 
     def load_history
-      read_history_file.count{|line|
+      read_history_file.each{|line|
         line.strip!
         history << line unless line.empty?
-      }
+      } if history.empty?
+      history.count
     end
   end # class Console
 end
-