debug 1.3.4 → 1.6.0

data/lib/debug/color.rb

@@ -48,33 +48,29 @@ module DEBUGGER__
 
     if defined? IRB::ColorPrinter.pp
       def color_pp obj, width
-        if !CONFIG[:no_color]
-          IRB::ColorPrinter.pp(obj, "".dup, width)
-        else
-          obj.pretty_inspect
+        with_inspection_error_guard do
+          if !CONFIG[:no_color]
+            IRB::ColorPrinter.pp(obj, "".dup, width)
+          else
+            obj.pretty_inspect
+          end
         end
       end
     else
       def color_pp obj, width
-        obj.pretty_inspect
+        with_inspection_error_guard do
+          obj.pretty_inspect
+        end
       end
     end
 
     def colored_inspect obj, width: SESSION.width, no_color: false
-      if !no_color
-        color_pp obj, width
-      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
+      with_inspection_error_guard do
+        if !no_color
+          color_pp obj, width
+        else
+          obj.pretty_inspect
+        end
       end
     end
 
@@ -109,5 +105,19 @@ module DEBUGGER__
     def colorize_dim(str)
       colorize(str, [:DIM])
     end
+
+    def with_inspection_error_guard
+      yield
+    rescue Exception => 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
   end
 end

data/lib/debug/config.rb

@@ -7,60 +7,79 @@ 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_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"],
 
     # 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)"],
+    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
     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)."],
+    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, desc)| [k, ev]}.to_h.freeze
+  CONFIG_MAP = CONFIG_SET.map{|k, (ev, _)| [k, ev]}.to_h.freeze
 
   class Config
+    @config = nil
+
     def self.config
       @config
     end
 
     def initialize argv
-      if self.class.instance_variable_defined? :@config
+      @skip_all = false
+
+      if self.class.config
         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
@@ -75,6 +94,14 @@ module DEBUGGER__
       set_config(key => val)
     end
 
+    def skip_all
+      @skip_all = true
+    end
+
+    def skip?
+      @skip_all
+    end
+
     def set_config(**kw)
       conf = config.dup
       kw.each{|k, v|
@@ -111,11 +138,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
@@ -212,6 +241,8 @@ module DEBUGGER__
             e
           end
         }
+      when :path_map
+        valstr.split(',').map{|e| e.split(':')}
       else
         valstr
       end
@@ -220,6 +251,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]
@@ -358,6 +390,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
@@ -425,7 +459,7 @@ module DEBUGGER__
   end
 
   def self.create_unix_domain_socket_name_prefix(base_dir = unix_domain_socket_dir)
-    user = ENV['USER'] || 'ruby-debug'
+    user = ENV['USER'] || 'UnknownUser'
     File.join(base_dir, "ruby-debug-#{user}")
   end
 
@@ -480,7 +514,7 @@ module DEBUGGER__
     self.helps.each{|cat, cmds|
       r << "### #{cat}"
       r << ''
-      cmds.each{|ws, desc|
+      cmds.each{|_, desc|
         r << desc
       }
       r << ''

data/lib/debug/console.rb

@@ -30,10 +30,38 @@ module DEBUGGER__
         prepend m
       end if SIGWINCH_SUPPORTED
 
+      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
+      end
+
       def readline_setup prompt
         load_history_if_not_loaded
         commands = DEBUGGER__.commands
 
+        prev_completion_proc = Reline.completion_proc
+        prev_output_modifier_proc = Reline.output_modifier_proc
+        prev_prompt_proc = Reline.prompt_proc
+
+        # 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, prompt]
+          when :ruby
+            [prompt.sub('rdbg'){colorize('ruby', [:RED])}] * 2
+          end
+        end
+
         Reline.completion_proc = -> given do
           buff = Reline.line_buffer
           Reline.completion_append_character= ' '
@@ -46,17 +74,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])
@@ -64,28 +91,36 @@ 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.chomp)
           end
-        end
+        end unless CONFIG[:no_hint]
+
+        yield
+
+      ensure
+        Reline.completion_proc = prev_completion_proc
+        Reline.output_modifier_proc = prev_output_modifier_proc
+        Reline.prompt_proc = prev_prompt_proc
       end
 
       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
 
       def readline prompt
-        readline_setup prompt
-        Reline.readmultiline(prompt, true){ true }
+        readline_setup prompt do
+          Reline.readmultiline(prompt, true){ true }
+        end
       end
 
       def history
@@ -139,13 +174,19 @@ 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: "
 
     def read_history_file
-      if history && File.exists?(path = history_file)
+      if history && File.exist?(path = history_file)
         f = (['', 'DAI-', 'CHU-', 'SHO-'].map{|e| e+'KICHI'}+['KYO']).sample
         ["#{FH}#{f}".dup] + File.readlines(path)
       else
@@ -167,7 +208,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

data/lib/debug/frame_info.rb

@@ -2,10 +2,11 @@
 
 module DEBUGGER__
   FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
-                          :has_return_value, :return_value,
+                          :has_return_value,     :return_value,
                           :has_raised_exception, :raised_exception,
                           :show_line,
-                          :_local_variables, :_callee # for recorder
+                          :_local_variables, :_callee, # for recorder
+                          :dupped_binding,
                         )
 
   # extend FrameInfo with debug.so
@@ -26,12 +27,12 @@ module DEBUGGER__
       location.absolute_path
     end
 
-    def pretty_path
-      return '#<none>' unless path = self.path
+    def self.pretty_path path
+      return '#<none>' unless path
       use_short_path = CONFIG[:use_short_path]
 
       case
-      when use_short_path && path.start_with?(dir = CONFIG["rubylibdir"] + '/')
+      when use_short_path && path.start_with?(dir = RbConfig::CONFIG["rubylibdir"] + '/')
         path.sub(dir, '$(rubylibdir)/')
       when use_short_path && Gem.path.any? do |gp|
           path.start_with?(dir = gp + '/gems/')
@@ -44,15 +45,18 @@ module DEBUGGER__
       end
     end
 
+    def pretty_path
+      FrameInfo.pretty_path path
+    end
+
     def name
       # p frame_type: frame_type, self: self
       case frame_type
       when :block
-        level, block_loc, _args = block_identifier
+        level, block_loc = block_identifier
         "block in #{block_loc}#{level}"
       when :method
-        ci, _args = method_identifier
-        "#{ci}"
+        method_identifier
       when :c
         c_identifier
       when :other
@@ -82,16 +86,13 @@ module DEBUGGER__
 
     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]
+      [level || "", block_loc]
     end
 
     def method_identifier
       return unless frame_type == :method
-      args = parameters_info(iseq.argc)
-      ci = "#{klass_sig}#{callee}"
-      [ci, args]
+      "#{klass_sig}#{callee}"
     end
 
     def c_identifier
@@ -105,32 +106,34 @@ module DEBUGGER__
     end
 
     def callee
-      self._callee ||= self.binding&.eval('__callee__')
+      self._callee ||= begin
+                         self.binding&.eval('__callee__')
+                       rescue NameError # BasicObject
+                         nil
+                       end
     end
 
     def return_str
       if self.binding && iseq && has_return_value
-        DEBUGGER__.short_inspect(return_value)
+        DEBUGGER__.safe_inspect(return_value, short: true)
       end
     end
 
-    def location_str
-      "#{pretty_path}:#{location.lineno}"
+    def matchable_location
+      # realpath can sometimes be nil so we can't use it here
+      "#{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__
+    def location_str
+      "#{pretty_path}:#{location.lineno}"
     end
 
     def eval_binding
-      if b = self.binding
+      if b = self.dupped_binding
         b
-      elsif self.local_variables
-        make_binding
+      else
+        b = self.binding || TOPLEVEL_BINDING
+        self.dupped_binding = b.dup
       end
     end
 
@@ -144,9 +147,18 @@ module DEBUGGER__
       end
     end
 
-    private
+    def parameters_info
+      vars = iseq.parameters_symbols
+      vars.map{|var|
+        begin
+          { name: var, value: DEBUGGER__.safe_inspect(local_variable_get(var), short: true) }
+        rescue NameError, TypeError
+          nil
+        end
+      }.compact
+    end
 
-    def get_singleton_class obj
+    private def get_singleton_class obj
       obj.singleton_class # TODO: don't use it
     rescue TypeError
       nil
@@ -156,18 +168,7 @@ module DEBUGGER__
       local_variables[var]
     end
 
-    def parameters_info(argc)
-      vars = iseq.locals[0...argc]
-      vars.map{|var|
-        begin
-          { name: var, value: DEBUGGER__.short_inspect(local_variable_get(var)) }
-        rescue NameError, TypeError
-          nil
-        end
-      }.compact
-    end
-
-    def klass_sig
+    private def klass_sig
       if self.class == get_singleton_class(self.self)
         "#{self.self}."
       else

data/lib/debug/local.rb

@@ -98,7 +98,7 @@ module DEBUGGER__
           # only check child process from its parent
           begin
             # wait for all child processes to keep terminal
-            loop{ Process.waitpid }
+            Process.waitpid
           rescue Errno::ESRCH, Errno::ECHILD
           end
         end

data/lib/debug/prelude.rb

@@ -2,9 +2,9 @@
 
 return if defined?(::DEBUGGER__)
 
+# Put the following line in your login script (e.g. ~/.bash_profile) with modified path:
 #
-# put the following line in .bash_profile
-#   export RUBYOPT="-r .../debug/prelude $(RUBYOPT)"
+#   export RUBYOPT="-r /path/to/debug/prelude $(RUBYOPT)"
 #
 module Kernel
   def debugger(*a, up_level: 0, **kw)