debug 1.0.0.beta4 → 1.0.0.beta8

data/lib/debug/source_repository.rb

@@ -1,55 +1,77 @@
-require 'irb/color' # IRB::Color.colorize_code
+# frozen_string_literal: true
+
+require_relative 'color'
 
 module DEBUGGER__
   class SourceRepository
+    SrcInfo = Struct.new(:src, :colored)
+
     def initialize
-      @files = {} # filename => [src, iseq]
-      @color_files = {}
+      @files = {} # filename => SrcInfo
     end
 
     def add iseq, src
-      path = iseq.absolute_path
-      path = '-e' if iseq.path == '-e'
-      add_path path, src: src
+      if (path = iseq.absolute_path) && File.exist?(path)
+        add_path path
+      elsif src
+        add_iseq iseq, src
+      end
     end
 
-    def add_path path, src: nil
-      case
-      when src
-        if File.file?(path)
-          path = '(eval)' + path
-          src = nil
-        end
-      when path == '-e'
-      when path
-        begin
-          src = File.read(path)
-        rescue SystemCallError
-        end
-      else
-        src = nil
+    def all_iseq iseq, rs = []
+      rs << iseq
+      iseq.each_child{|ci|
+        all_iseq(ci, rs)
+      }
+      rs
+    end
+
+    private def add_iseq iseq, src
+      line = iseq.first_line
+      if line > 1
+        src = ("\n" * (line - 1)) + src
       end
+      si = SrcInfo.new(src.lines)
 
-      if src
+      all_iseq(iseq).each{|e|
+        e.instance_variable_set(:@debugger_si, si)
+        e.freeze
+      }
+    end
+
+    private def add_path path
+      begin
+        src = File.read(path)
         src = src.gsub("\r\n", "\n") # CRLF -> LF
-        @files[path] = src.lines
+        @files[path] = SrcInfo.new(src.lines)
+      rescue SystemCallError
       end
     end
 
-    def get path
-      if @files.has_key? path
+    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)
         @files[path]
-      else
-        add_path path
+      elsif path
+        add_path(path)
       end
     end
 
-    def get_colored path
-      if src_lines = @color_files[path]
-        return src_lines
-      else
-        if src_lines = get(path)
-          @color_files[path] = IRB::Color.colorize_code(src_lines.join).lines
+    def get iseq
+      if si = get_si(iseq)
+        si.src
+      end
+    end
+
+    include Color
+
+    def get_colored iseq
+      if si = get_si(iseq)
+        si.colored || begin
+          si.colored = colorize_code(si.src.join).lines
         end
       end
     end

data/lib/debug/start.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'session'
+return unless defined?(DEBUGGER__)
+DEBUGGER__.start

data/lib/debug/thread_client.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'objspace'
 require 'pp'
-require 'irb/color'
+
 require_relative 'frame_info'
+require_relative 'color'
 
 module DEBUGGER__
   class ThreadClient
@@ -12,23 +15,46 @@ module DEBUGGER__
       end
     end
 
+    include Color
+
     attr_reader :location, :thread, :mode, :id
 
-    def colorize str, color
-      if CONFIG[:use_colorize]
-        IRB::Color.colorize str, color
-      else
-        str
-      end
+    def assemble_arguments(args)
+      args.map do |arg|
+        "#{colorize_cyan(arg[:name])}=#{arg[:value]}"
+      end.join(", ")
     end
 
     def default_frame_formatter frame
-      call_identifier_str = colorize(frame.call_identifier_str, [:BLUE, :BOLD])
-      location_str = colorize(frame.location_str, [:YELLOW])
+      call_identifier_str =
+        case frame.frame_type
+        when :block
+          level, block_loc, args = frame.block_identifier
+
+          if !args.empty?
+            args_str = " {|#{assemble_arguments(args)}|}"
+          end
+
+          "#{colorize_blue("block")}#{args_str} in #{colorize_blue(block_loc + level)}"
+        when :method
+          ci, args = frame.method_identifier
+
+          if !args.empty?
+            args_str = "(#{assemble_arguments(args)})"
+          end
+
+          "#{colorize_blue(ci)}#{args_str}"
+        when :c
+          colorize_blue(frame.c_identifier)
+        when :other
+          colorize_blue(frame.other_identifier)
+        end
+
+      location_str = colorize(frame.location_str, [:GREEN])
       result = "#{call_identifier_str} at #{location_str}"
 
       if return_str = frame.return_str
-        return_str = colorize(frame.return_str, [:MAGENTA])
+        return_str = colorize(frame.return_str, [:MAGENTA, :BOLD])
         result += " #=> #{return_str}"
       end
 
@@ -38,14 +64,20 @@ module DEBUGGER__
     def initialize id, q_evt, q_cmd, thr = Thread.current
       @id = id
       @thread = thr
+      @target_frames = nil
       @q_evt = q_evt
       @q_cmd = q_cmd
       @step_tp = nil
       @output = []
-      @src_lines_on_stop = (::DEBUGGER__::CONFIG[:show_src_lines]   || 10).to_i
-      @show_frames_on_stop = (::DEBUGGER__::CONFIG[:show_frames] || 2).to_i
       @frame_formatter = method(:default_frame_formatter)
+      @var_map = {} # { thread_local_var_id => obj } for DAP
       set_mode nil
+
+      ::DEBUGGER__.info("Thread \##{@id} is created.")
+    end
+
+    def name
+      "##{@id} #{@thread.name || @thread.backtrace.last}"
     end
 
     def close
@@ -71,8 +103,14 @@ module DEBUGGER__
       @q_cmd << req
     end
 
+    def generate_info
+      return unless current_frame
+
+      { location: current_frame.location_str, line: current_frame.location.lineno }
+    end
+
     def event! ev, *args
-      @q_evt << [self, @output, ev, *args]
+      @q_evt << [self, @output, ev, generate_info, *args]
       @output = []
     end
 
@@ -100,6 +138,11 @@ module DEBUGGER__
       wait_next_action
     end
 
+    def on_init name
+      event! :init, name
+      wait_next_action
+    end
+
     def on_breakpoint tp, bp
       on_suspend tp.event, tp, bp: bp
     end
@@ -116,11 +159,16 @@ module DEBUGGER__
           cf.has_return_value = true
           cf.return_value = tp.return_value
         end
+
+        if CatchBreakpoint === bp
+          cf.has_raised_exception = true
+          cf.raised_exception = bp.last_exc
+        end
       end
 
       if event != :pause
-        show_src max_lines: @src_lines_on_stop
-        show_frames @show_frames_on_stop
+        show_src max_lines: (::DEBUGGER__::CONFIG[:show_src_lines] || 10)
+        show_frames ::DEBUGGER__::CONFIG[:show_frames] || 2
 
         if bp
           event! :suspend, :breakpoint, bp.key
@@ -187,7 +235,6 @@ module DEBUGGER__
                  start_line: nil,
                  end_line: nil,
                  dir: +1)
-
       if @target_frames && frame = @target_frames[frame_index]
         if file_lines = frame.file_lines
           frame_line = frame.location.lineno - 1
@@ -229,6 +276,10 @@ module DEBUGGER__
           puts "# No sourcefile available for #{frame.path}"
         end
       end
+    rescue Exception => e
+      p e
+      pp e.backtrace
+      exit!
     end
 
     def show_by_editor path = nil
@@ -253,16 +304,39 @@ module DEBUGGER__
       end
     end
 
+    def puts_variable_info label, obj
+      info = "#{colorize_cyan(label)} => #{colored_inspect(obj)}".lines
+      w = SESSION.width
+      max_inspect_lines = CONFIG[:show_inspect_lines] || 10
+
+      if (max_inspect_lines > 0 && (info.size > max_inspect_lines)) || info.any?{|l| l.size > w}
+        info = "#{colorize_cyan(label)} => #{colored_inspect(obj, no_color: true)}".lines
+        if max_inspect_lines > 0 && info.size > max_inspect_lines
+          info = info.first(max_inspect_lines - 2) +
+                 ["...(#{info.size - (max_inspect_lines - 1)} lines)\n" + info.last]
+        end
+        info.map!{|l|
+          l.length > w ? l[0..(w-4)] + '...' : l
+        }
+      end
+
+      puts info
+    end
+
     def show_locals
       if s = current_frame&.self
-        puts " %self => #{s}"
+        puts_variable_info '%self', s
       end
       if current_frame&.has_return_value
-        puts " %return => #{current_frame.return_value}"
+        puts_variable_info '%return', current_frame.return_value
+      end
+      if current_frame&.has_raised_exception
+        puts_variable_info "%raised", current_frame.raised_exception
       end
       if b = current_frame&.binding
         b.local_variables.each{|loc|
-          puts " #{loc} => #{b.local_variable_get(loc).inspect}"
+          value = b.local_variable_get(loc)
+          puts_variable_info loc, value
         }
       end
     end
@@ -270,22 +344,27 @@ module DEBUGGER__
     def show_ivars
       if s = current_frame&.self
         s.instance_variables.each{|iv|
-          puts " #{iv} => #{s.instance_variable_get(iv)}"
+          value = s.instance_variable_get(iv)
+          puts_variable_info iv, value
         }
       end
     end
 
+    def instance_eval_for_cmethod frame_self, src
+      frame_self.instance_eval(src)
+    end
+
     def frame_eval src, re_raise: false
       begin
         @success_last_eval = false
 
         b = current_frame.binding
         result = if b
-                   f, l = b.source_location
+                   f, _l = b.source_location
                    b.eval(src, "(rdbg)/#{f}")
                  else
                    frame_self = current_frame.self
-                   frame_self.instance_eval(src)
+                   instance_eval_for_cmethod(frame_self, src)
                  end
         @success_last_eval = true
         result
@@ -303,21 +382,35 @@ module DEBUGGER__
       end
     end
 
-    def frame_str(i)
+    def frame_str(i, frame: @target_frames[i])
       cur_str = (@current_frame_index == i ? '=>' : '  ')
       prefix = "#{cur_str}##{i}"
-      frame = @target_frames[i]
       frame_string = @frame_formatter.call(frame)
       "#{prefix}\t#{frame_string}"
     end
 
-    def show_frames max = (@target_frames || []).size
-      if max > 0 && frames = @target_frames
-        size = @target_frames.size
-        max += 1 if size == max + 1
+    def show_frames max = nil, pattern = nil
+      if @target_frames && (max ||= @target_frames.size) > 0
+        frames = []
+        @target_frames.each_with_index{|f, i|
+          next if pattern && !(f.name.match?(pattern) || f.location_str.match?(pattern))
+          next if CONFIG[:skip_path] && CONFIG[:skip_path].any?{|pat|
+            case pat
+            when String
+              f.location_str.start_with?(pat)
+            when Regexp
+              f.location_str.match?(pat)
+            end
+          }
+
+          frames << [i, f]
+        }
+
+        size = frames.size
         max.times{|i|
-          break if i >= size
-          puts frame_str(i)
+          break unless frames[i]
+          index, frame = frames[i]
+          puts frame_str(index, frame: frame)
         }
         puts "  # and #{size - max} frames (use `bt' command for all frames)" if max < size
       end
@@ -345,18 +438,22 @@ module DEBUGGER__
       end
     end
 
-    def add_breakpoint args
+    def make_breakpoint args
       case args.first
       when :method
-        klass_name, op, method_name, cond = args[1..]
-        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond)
+        klass_name, op, method_name, cond, cmd = args[1..]
+        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond, command: cmd)
         begin
           bp.enable
         rescue Exception => e
           puts e.message
           ::DEBUGGER__::METHOD_ADDED_TRACKER.enable
         end
-        event! :result, :method_breakpoint, bp
+
+        bp
+      when :watch
+        ivar, object, result = args[1..]
+        WatchIVarBreakpoint.new(ivar, object, result)
       else
         raise "unknown breakpoint: #{args}"
       end
@@ -369,6 +466,8 @@ module DEBUGGER__
     def wait_next_action
       set_mode :wait_next_action
 
+      SESSION.check_forked
+
       while cmds = @q_cmd.pop
         # pp [self, cmds: cmds]
 
@@ -386,20 +485,28 @@ module DEBUGGER__
             frame = @target_frames.first
             path = frame.location.absolute_path || "!eval:#{frame.path}"
             line = frame.location.lineno
-            frame.iseq.traceable_lines_norec(lines = {})
-            next_line = lines.keys.bsearch{|e| e > line}
-            if !next_line && (last_line = frame.iseq.last_line) > line
-              next_line = last_line
+
+            if frame.iseq
+              frame.iseq.traceable_lines_norec(lines = {})
+              next_line = lines.keys.bsearch{|e| e > line}
+              if !next_line && (last_line = frame.iseq.last_line) > line
+                next_line = last_line
+              end
             end
+
             depth = @target_frames.first.frame_depth
 
             step_tp{
               loc = caller_locations(2, 1).first
               loc_path = loc.absolute_path || "!eval:#{loc.path}"
 
+              # same stack depth
+              (DEBUGGER__.frame_depth - 3 <= depth) ||
+
+              # different frame
               (next_line && loc_path == path &&
-                (loc_lineno = loc.lineno) > line && loc_lineno <= next_line) ||
-              (DEBUGGER__.frame_depth - 3 < depth)
+               (loc_lineno = loc.lineno) > line &&
+               loc_lineno <= next_line)
             }
           when :finish
             depth = @target_frames.first.frame_depth
@@ -414,20 +521,16 @@ module DEBUGGER__
         when :eval
           eval_type, eval_src = *args
 
-          case eval_type
-          when :display, :try_display
-          else
-            result = frame_eval(eval_src)
-          end
           result_type = nil
 
           case eval_type
           when :p
+            result = frame_eval(eval_src)
             puts "=> " + result.inspect
           when :pp
+            result = frame_eval(eval_src)
             puts "=> "
-            PP.pp(result, out = ''.dup)
-            puts out
+            puts color_pp(result, SESSION.width)
           when :call
             result = frame_eval(eval_src)
           when :display, :try_display
@@ -442,14 +545,6 @@ module DEBUGGER__
 
             result_type = eval_type
             result = failed_results
-          when :watch
-            if @success_last_eval
-              puts "#{eval_src} = #{result}"
-              result = WatchExprBreakpoint.new(eval_src, result)
-              result_type = :watch
-            else
-              result = nil
-            end
           else
             raise "unknown error option: #{args.inspect}"
           end
@@ -490,7 +585,8 @@ module DEBUGGER__
 
           case type
           when :backtrace
-            show_frames
+            max_lines, pattern = *args
+            show_frames max_lines, pattern
 
           when :list
             show_src(update_line: true, **(args.first || {}))
@@ -512,9 +608,30 @@ module DEBUGGER__
           end
 
           event! :result, nil
-
         when :breakpoint
-          add_breakpoint args
+          case args[0]
+          when :method
+            bp = make_breakpoint args
+            event! :result, :method_breakpoint, bp
+          when :watch
+            ivar = args[1]
+            result = frame_eval(ivar)
+
+            if @success_last_eval
+              object =
+                if b = current_frame.binding
+                  b.receiver
+                else
+                  current_frame.self
+                end
+              bp = make_breakpoint [:watch, ivar, object, result]
+              event! :result, :watch_breakpoint, bp
+            else
+              event! :result, nil
+            end
+          end
+        when :dap
+          process_dap args
         else
           raise [cmd, *args].inspect
         end
@@ -523,7 +640,7 @@ module DEBUGGER__
     rescue SystemExit
       raise
     rescue Exception => e
-      pp [__FILE__, __LINE__, e, e.backtrace]
+      pp ["DEBUGGER Exception: #{__FILE__}:#{__LINE__}", e, e.backtrace]
       raise
     ensure
       set_mode nil