debug 1.3.3 → 1.5.0

data/lib/debug/source_repository.rb

@@ -4,74 +4,112 @@ require_relative 'color'
 
 module DEBUGGER__
   class SourceRepository
-    SrcInfo = Struct.new(:src, :colored)
+    include Color
 
-    def initialize
-      @files = {} # filename => SrcInfo
-    end
+    if RubyVM.respond_to? :keep_script_lines
+      # Ruby 3.1 and later
+      RubyVM.keep_script_lines = true
+      require 'objspace'
 
-    def add iseq, src
-      if (path = iseq.absolute_path) && File.exist?(path)
-        add_path path
-      elsif src
-        add_iseq iseq, src
+      def initialize
+        # cache
+        @cmap = ObjectSpace::WeakMap.new
       end
-    end
 
-    def all_iseq iseq, rs = []
-      rs << iseq
-      iseq.each_child{|ci|
-        all_iseq(ci, rs)
-      }
-      rs
-    end
+      def add iseq, src
+        # do nothing
+      end
+
+      def get iseq
+        return unless iseq
 
-    private def add_iseq iseq, src
-      line = iseq.first_line
-      if line > 1
-        src = ("\n" * (line - 1)) + src
+        if lines = iseq.script_lines&.map(&:chomp)
+          lines
+        else
+          if (path = (iseq.absolute_path || iseq.path)) && File.exist?(path)
+            File.readlines(path, chomp: true)
+          else
+            nil
+          end
+        end
       end
-      si = SrcInfo.new(src.lines)
 
-      all_iseq(iseq).each{|e|
-        e.instance_variable_set(:@debugger_si, si)
-        e.freeze
-      }
-    end
+      def get_colored iseq
+        if lines = @cmap[iseq]
+          lines
+        else
+          if src_lines = get(iseq)
+            @cmap[iseq] = colorize_code(src_lines.join("\n")).lines
+          else
+            nil
+          end
+        end
+      end
+    else
+      # ruby 3.0 or earlier
+      SrcInfo = Struct.new(:src, :colored)
 
-    private def add_path path
-      begin
-        src = File.read(path)
-        src = src.gsub("\r\n", "\n") # CRLF -> LF
-        @files[path] = SrcInfo.new(src.lines)
-      rescue SystemCallError
+      def initialize
+        @files = {} # filename => SrcInfo
+      end
+
+      def add iseq, src
+        if (path = (iseq.absolute_path || iseq.path)) && File.exist?(path)
+          add_path path
+        elsif src
+          add_iseq iseq, src
+        end
       end
-    end
 
-    private def get_si iseq
-      return unless iseq
+      private def all_iseq iseq, rs = []
+        rs << iseq
+        iseq.each_child{|ci|
+          all_iseq(ci, rs)
+        }
+        rs
+      end
 
-      if iseq.instance_variable_defined?(:@debugger_si)
-        iseq.instance_variable_get(:@debugger_si)
-      elsif @files.has_key?(path = iseq.absolute_path)
-        @files[path]
-      elsif path
-        add_path(path)
+      private def add_iseq iseq, src
+        line = iseq.first_line
+        if line > 1
+          src = ("\n" * (line - 1)) + src
+        end
+        si = SrcInfo.new(src.lines)
+        all_iseq(iseq).each{|e|
+          e.instance_variable_set(:@debugger_si, si)
+          e.freeze
+        }
       end
-    end
 
-    def get iseq
-      if si = get_si(iseq)
-        si.src
+      private def add_path path
+        src_lines = File.readlines(path, chomp: true)
+        @files[path] = SrcInfo.new(src_lines)
+      rescue SystemCallError
       end
-    end
 
-    include Color
+      private def get_si iseq
+        return unless iseq
+      
+        if iseq.instance_variable_defined?(:@debugger_si)
+          iseq.instance_variable_get(:@debugger_si)
+        elsif @files.has_key?(path = (iseq.absolute_path || iseq.path))
+          @files[path]
+        elsif path
+          add_path(path)
+        end
+      end
+
+      def get iseq
+        if si = get_si(iseq)
+          si.src
+        end
+      end
 
-    def get_colored iseq
-      if si = get_si(iseq)
-        si.colored || begin
-          si.colored = colorize_code(si.src.join).lines
+      def get_colored iseq
+        if si = get_si(iseq)
+          si.colored || begin
+            si.colored = colorize_code(si.src.join("\n")).lines
+          end
         end
       end
     end

data/lib/debug/thread_client.rb

@@ -8,7 +8,11 @@ require_relative 'color'
 module DEBUGGER__
   module SkipPathHelper
     def skip_path?(path)
-      (skip_paths = CONFIG[:skip_path]) && skip_paths.any?{|skip_path| path.match?(skip_path)}
+      !path || skip_internal_path?(path) || (skip_paths = CONFIG[:skip_path]) && skip_paths.any?{|skip_path| path.match?(skip_path)}
+    end
+
+    def skip_internal_path?(path)
+      path.start_with?(__dir__) || path.start_with?('<internal:')
     end
 
     def skip_location?(loc)
@@ -22,7 +26,7 @@ module DEBUGGER__
       if thc = Thread.current[:DEBUGGER__ThreadClient]
         thc
       else
-        thc = SESSION.thread_client
+        thc = SESSION.get_thread_client
         Thread.current[:DEBUGGER__ThreadClient] = thc
       end
     end
@@ -30,7 +34,11 @@ module DEBUGGER__
     include Color
     include SkipPathHelper
 
-    attr_reader :location, :thread, :id, :recorder
+    attr_reader :thread, :id, :recorder
+
+    def location
+      current_frame&.location
+    end
 
     def assemble_arguments(args)
       args.map do |arg|
@@ -67,7 +75,7 @@ module DEBUGGER__
       result = "#{call_identifier_str} at #{location_str}"
 
       if return_str = frame.return_str
-        result += " #=> #{colorize_magenta(frame.return_str)}"
+        result += " #=> #{colorize_magenta(return_str)}"
       end
 
       result
@@ -84,6 +92,7 @@ module DEBUGGER__
       @output = []
       @frame_formatter = method(:default_frame_formatter)
       @var_map = {} # { thread_local_var_id => obj } for DAP
+      @obj_map = {} # { object_id => obj } for CDP
       @recorder = nil
       @mode = :waiting
       set_mode :running
@@ -100,13 +109,13 @@ module DEBUGGER__
       @is_management
     end
 
-    def is_management
+    def mark_as_management
       @is_management = true
     end
 
     def set_mode mode
       # STDERR.puts "#{@mode} => #{mode} @ #{caller.inspect}"
-      #pp caller
+      # pp caller
 
       # mode transition check
       case mode
@@ -148,14 +157,7 @@ module DEBUGGER__
     end
 
     def to_s
-      loc = current_frame&.location
-
-      if loc
-        str = "(#{@thread.name || @thread.status})@#{loc}"
-      else
-        str = "(#{@thread.name || @thread.status})@#{@thread.to_s}"
-      end
-
+      str = "(#{@thread.name || @thread.status})@#{current_frame&.location || @thread.to_s}"
       str += " (not under control)" unless self.waiting?
       str
     end
@@ -228,7 +230,7 @@ module DEBUGGER__
       suspend :pause
     end
 
-    def suspend event, tp = nil, bp: nil, sig: nil, postmortem_frames: nil, replay_frames: nil
+    def suspend event, tp = nil, bp: nil, sig: nil, postmortem_frames: nil, replay_frames: nil, postmortem_exc: nil
       return if management?
 
       @current_frame_index = 0
@@ -245,7 +247,6 @@ module DEBUGGER__
 
       cf = @target_frames.first
       if cf
-        @location = cf.location
         case event
         when :return, :b_return, :c_return
           cf.has_return_value = true
@@ -256,10 +257,15 @@ module DEBUGGER__
           cf.has_raised_exception = true
           cf.raised_exception = bp.last_exc
         end
+
+        if postmortem_exc
+          cf.has_raised_exception = true
+          cf.raised_exception = postmortem_exc
+        end
       end
 
       if event != :pause
-        show_src max_lines: (CONFIG[:show_src_lines] || 10)
+        show_src
         show_frames CONFIG[:show_frames] || 2
 
         set_mode :waiting
@@ -292,15 +298,15 @@ module DEBUGGER__
       SUPPORT_TARGET_THREAD = false
     end
 
-    def step_tp iter
+    def step_tp iter, events = [:line, :b_return, :return]
       @step_tp.disable if @step_tp
 
       thread = Thread.current
 
       if SUPPORT_TARGET_THREAD
-        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+        @step_tp = TracePoint.new(*events){|tp|
           next if SESSION.break_at? tp.path, tp.lineno
-          next if !yield
+          next if !yield(tp.event)
           next if tp.path.start_with?(__dir__)
           next if tp.path.start_with?('<internal:trace_point>')
           next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
@@ -313,10 +319,10 @@ module DEBUGGER__
         }
         @step_tp.enable(target_thread: thread)
       else
-        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+        @step_tp = TracePoint.new(*events){|tp|
           next if thread != Thread.current
           next if SESSION.break_at? tp.path, tp.lineno
-          next if !yield
+          next if !yield(tp.event)
           next if tp.path.start_with?(__dir__)
           next if tp.path.start_with?('<internal:trace_point>')
           next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
@@ -333,43 +339,83 @@ module DEBUGGER__
 
     ## cmd helpers
 
-    # this method is extracted to hide frame_eval's local variables from C method eval's binding
-    def instance_eval_for_cmethod frame_self, src
-      frame_self.instance_eval(src)
+    if TracePoint.respond_to? :allow_reentry
+      def tp_allow_reentry
+        TracePoint.allow_reentry do
+          yield
+        end
+      rescue RuntimeError => e
+        # on the postmortem mode, it is not stopped in TracePoint
+        if e.message == 'No need to allow reentrance.'
+          yield
+        else
+          raise
+        end
+      end
+    else
+      def tp_allow_reentry
+        yield
+      end
+    end
+
+    def frame_eval_core src, b
+      saved_target_frames = @target_frames
+      saved_current_frame_index = @current_frame_index
+
+      if b
+        f, _l = b.source_location
+
+        tp_allow_reentry do
+          b.eval(src, "(rdbg)/#{f}")
+        end
+      else
+        frame_self = current_frame.self
+
+        tp_allow_reentry do
+          frame_self.instance_eval(src)
+        end
+      end
+    ensure
+      @target_frames = saved_target_frames
+      @current_frame_index = saved_current_frame_index
     end
 
+    SPECIAL_LOCAL_VARS = [
+      [:raised_exception, "_raised"],
+      [:return_value,     "_return"],
+    ]
+
     def frame_eval src, re_raise: false
-      begin
-        @success_last_eval = false
+      @success_last_eval = false
 
-        b = current_frame&.eval_binding || TOPLEVEL_BINDING
+      b = current_frame.eval_binding
 
-        result = if b
-                   f, _l = b.source_location
-                   b.eval(src, "(rdbg)/#{f}")
-                 else
-                   frame_self = current_frame.self
-                   instance_eval_for_cmethod(frame_self, src)
-                 end
-        @success_last_eval = true
-        result
+      special_local_variables current_frame do |name, var|
+        b.local_variable_set(name, var) if /\%/ !~ name
+      end
 
-      rescue Exception => e
-        return yield(e) if block_given?
+      result = frame_eval_core(src, b)
 
-        puts "eval error: #{e}"
+      @success_last_eval = true
+      result
 
-        e.backtrace_locations&.each do |loc|
-          break if loc.path == __FILE__
-          puts "  #{loc}"
-        end
-        raise if re_raise
+    rescue SystemExit
+      raise
+    rescue Exception => e
+      return yield(e) if block_given?
+
+      puts "eval error: #{e}"
+
+      e.backtrace_locations&.each do |loc|
+        break if loc.path == __FILE__
+        puts "  #{loc}"
       end
+      raise if re_raise
     end
 
     def show_src(frame_index: @current_frame_index,
                  update_line: false,
-                 max_lines: 10,
+                 max_lines: CONFIG[:show_src_lines] || 10,
                  start_line: nil,
                  end_line: nil,
                  dir: +1)
@@ -419,31 +465,50 @@ module DEBUGGER__
     end
 
     def current_frame
+      get_frame(@current_frame_index)
+    end
+
+    def get_frame(index)
       if @target_frames
-        @target_frames[@current_frame_index]
+        @target_frames[index]
       else
         nil
       end
     end
 
-    ## cmd: show
+    def collect_locals(frame)
+      locals = []
 
-    def show_locals pat
-      if s = current_frame&.self
-        puts_variable_info '%self', s, pat
+      if s = frame&.self
+        locals << ["%self", s]
       end
-      if current_frame&.has_return_value
-        puts_variable_info '%return', current_frame.return_value, pat
-      end
-      if current_frame&.has_raised_exception
-        puts_variable_info "%raised", current_frame.raised_exception, pat
+      special_local_variables frame do |name, val|
+        locals << [name, val]
       end
 
-      if vars = current_frame&.local_variables
+      if vars = frame&.local_variables
         vars.each{|var, val|
-          puts_variable_info var, val, pat
+          locals << [var, val]
         }
       end
+
+      locals
+    end
+
+    ## cmd: show
+
+    def special_local_variables frame
+      SPECIAL_LOCAL_VARS.each do |mid, name|
+        next unless frame&.send("has_#{mid}")
+        name = name.sub('_', '%') if frame.eval_binding.local_variable_defined?(name)
+        yield name, frame.send(mid)
+      end
+    end
+
+    def show_locals pat
+      collect_locals(current_frame).each do |var, val|
+        puts_variable_info(var, val, pat)
+      end
     end
 
     def show_ivars pat
@@ -508,28 +573,32 @@ module DEBUGGER__
       w = SESSION::width
 
       if mono_info.length >= w
-        info = truncate(mono_info, width: w)
+        maximum_value_width = w - "#{label} = ".length
+        valstr = truncate(inspected, width: maximum_value_width)
       else
         valstr = colored_inspect(obj, width: 2 ** 30)
         valstr = inspected if valstr.lines.size > 1
-        info = "#{colorize_cyan(label)} = #{valstr}"
       end
 
+      info = "#{colorize_cyan(label)} = #{valstr}"
+
       puts info
     end
 
     def truncate(string, width:)
-      str = string[0 .. (width-4)] + '...'
-      str += ">" if str.start_with?("#<")
-      str
+      if string.start_with?("#<")
+        string[0 .. (width-5)] + '...>'
+      else
+        string[0 .. (width-4)] + '...'
+      end
     end
 
     ### cmd: show edit
 
     def show_by_editor path = nil
       unless path
-        if @target_frames && frame = @target_frames[@current_frame_index]
-          path = frame.path
+        if current_frame
+          path = current_frame.path
         else
           return # can't get path
         end
@@ -633,8 +702,8 @@ module DEBUGGER__
     def make_breakpoint args
       case args.first
       when :method
-        klass_name, op, method_name, cond, cmd = args[1..]
-        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond: cond, command: cmd)
+        klass_name, op, method_name, cond, cmd, path = args[1..]
+        bp = MethodBreakpoint.new(current_frame.eval_binding, klass_name, op, method_name, cond: cond, command: cmd, path: path)
         begin
           bp.enable
         rescue Exception => e
@@ -644,8 +713,8 @@ module DEBUGGER__
 
         bp
       when :watch
-        ivar, object, result = args[1..]
-        WatchIVarBreakpoint.new(ivar, object, result)
+        ivar, object, result, cond, command, path = args[1..]
+        WatchIVarBreakpoint.new(ivar, object, result, cond: cond, command: command, path: path)
       else
         raise "unknown breakpoint: #{args}"
       end
@@ -732,10 +801,11 @@ module DEBUGGER__
             break
 
           when :finish
-            depth = @target_frames.first.frame_depth
-            step_tp iter do
-              # 3 is debugger's frame count
-              DEBUGGER__.frame_depth - 3 < depth
+            finish_frames = (iter || 1) - 1
+            goal_depth = @target_frames.first.frame_depth - finish_frames
+
+            step_tp nil, [:return, :b_return] do
+              DEBUGGER__.frame_depth - 3 <= goal_depth ? true : false
             end
             break
 
@@ -834,6 +904,7 @@ module DEBUGGER__
           else
             raise "unsupported frame operation: #{arg.inspect}"
           end
+
           event! :result, nil
 
         when :show
@@ -887,7 +958,7 @@ module DEBUGGER__
             bp = make_breakpoint args
             event! :result, :method_breakpoint, bp
           when :watch
-            ivar = args[1]
+            ivar, cond, command, path = args[1..]
             result = frame_eval(ivar)
 
             if @success_last_eval
@@ -897,7 +968,7 @@ module DEBUGGER__
                 else
                   current_frame.self
                 end
-              bp = make_breakpoint [:watch, ivar, object, result]
+              bp = make_breakpoint [:watch, ivar, object, result, cond, command, path]
               event! :result, :watch_breakpoint, bp
             else
               event! :result, nil
@@ -982,8 +1053,8 @@ module DEBUGGER__
 
         @tp_recorder ||= TracePoint.new(:line){|tp|
           next unless Thread.current == thread
-          next if tp.path.start_with? __dir__
-          next if tp.path.start_with? '<internal:'
+          # can't be replaced by skip_location
+          next if skip_internal_path?(tp.path)
           loc = caller_locations(1, 1).first
           next if skip_location?(loc)
 
@@ -1067,7 +1138,7 @@ module DEBUGGER__
       end
     end
 
-    # copyed from irb
+    # copied from irb
     class Output
       include Color
 

data/lib/debug/tracer.rb

@@ -66,15 +66,7 @@ module DEBUGGER__
     end
 
     def skip? tp
-      if tp.path.start_with?(__dir__) ||
-         tp.path.start_with?('<internal:') ||
-         ThreadClient.current.management? ||
-         skip_path?(tp.path) ||
-         skip_with_pattern?(tp)
-        true
-      else
-        false
-      end
+      ThreadClient.current.management? || skip_path?(tp.path) || skip_with_pattern?(tp)
     end
 
     def skip_with_pattern?(tp)
@@ -89,11 +81,13 @@ module DEBUGGER__
         ThreadClient.current.on_trace self.object_id, buff
       else
         @output.puts buff
+        @output.flush
       end
     end
 
     def puts msg
       @output.puts msg
+      @output.flush
     end
 
     def minfo tp
@@ -142,7 +136,7 @@ module DEBUGGER__
           out tp, ">#{sp}#{call_identifier_str}", depth
         when :return, :c_return, :b_return
           depth += 1 if tp.event == :c_return
-          return_str = colorize_magenta(DEBUGGER__.short_inspect(tp.return_value))
+          return_str = colorize_magenta(DEBUGGER__.safe_inspect(tp.return_value, short: true))
           out tp, "<#{sp}#{call_identifier_str} #=> #{return_str}", depth
         end
       }

data/lib/debug/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DEBUGGER__
-  VERSION = "1.3.3"
+  VERSION = "1.5.0"
 end