debug 1.0.0.beta2 → 1.0.0.beta7

data/lib/debug/source_repository.rb

@@ -1,27 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'color'
+
 module DEBUGGER__
   class SourceRepository
+    SrcInfo = Struct.new(:src, :colored)
+
     def initialize
-      @files = {} # filename => [src, iseq]
+      @files = {} # filename => SrcInfo
     end
 
     def add iseq, src
-      path = iseq.absolute_path
-      path = '-e' if iseq.path == '-e'
+      if (path = iseq.absolute_path) && File.exist?(path)
+        add_path path
+      elsif src
+        add_iseq iseq, src
+      end
+    end
 
-      case
-      when path = iseq.absolute_path
+    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)
+
+      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)
-      when iseq.path == '-e'
-        path = '-e'
-      else
-        src = nil
+        src = src.gsub("\r\n", "\n") # CRLF -> LF
+        @files[path] = SrcInfo.new(src.lines)
+      rescue SystemCallError
       end
+    end
+
+    private def get_si iseq
+      return unless iseq
 
-      @files[path] = src.lines if src
+      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)
+      end
     end
 
-    def get path
-      @files[path]
+    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
   end
 end

data/lib/debug/thread_client.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
 require 'objspace'
 require 'pp'
 
+require_relative 'frame_info'
+require_relative 'color'
+
 module DEBUGGER__
   class ThreadClient
     def self.current
@@ -10,18 +15,73 @@ module DEBUGGER__
       end
     end
 
+    include Color
+
     attr_reader :location, :thread, :mode, :id
 
+    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 =
+        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, :BOLD])
+        result += " #=> #{return_str}"
+      end
+
+      result
+    end
+
     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
+      @q_cmd.close
     end
 
     def inspect
@@ -43,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
 
@@ -72,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
@@ -88,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
@@ -125,6 +201,8 @@ module DEBUGGER__
           next if SESSION.break? tp.path, tp.lineno
           next if !yield
           next if tp.path.start_with?(__dir__)
+          next unless File.exist?(tp.path) if ::DEBUGGER__::CONFIG[:skip_nosrc]
+
           tp.disable
           on_suspend tp.event, tp
         }
@@ -134,6 +212,8 @@ module DEBUGGER__
           next if thread != Thread.current
           next if SESSION.break? tp.path, tp.lineno
           next if !yield
+          next unless File.exist?(tp.path) if ::DEBUGGER__::CONFIG[:skip_nosrc]
+
           tp.disable
           on_suspend tp.event, tp
         }
@@ -149,23 +229,14 @@ module DEBUGGER__
       end
     end
 
-    def file_lines path
-      if (src_lines = SESSION.source(path))
-        src_lines
-      elsif File.exist?(path)
-        File.readlines(path)
-      end
-    end
-
     def show_src(frame_index: @current_frame_index,
                  update_line: false,
                  max_lines: 10,
                  start_line: nil,
                  end_line: nil,
                  dir: +1)
-      #
       if @target_frames && frame = @target_frames[frame_index]
-        if file_lines = file_lines(path = frame.location.path)
+        if file_lines = frame.file_lines
           frame_line = frame.location.lineno - 1
 
           lines = file_lines.map.with_index do |e, i|
@@ -197,18 +268,24 @@ module DEBUGGER__
             frame.show_line = end_line
           end
 
-          if start_line != end_line
-            puts "[#{start_line+1}, #{end_line}] in #{path}" unless update_line
+          if start_line != end_line && max_lines
+            puts "[#{start_line+1}, #{end_line}] in #{frame.pretty_path}" if !update_line && max_lines != 1
             puts lines[start_line ... end_line]
           end
+        else # no file lines
+          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
       unless path
         if @target_frames && frame = @target_frames[@current_frame_index]
-          path = frame.location.path
+          path = frame.path
         else
           return # can't get path
         end
@@ -227,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
@@ -244,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
@@ -277,81 +382,37 @@ module DEBUGGER__
       end
     end
 
-    def parameters_info b, vars
-      vars.map{|var|
-        begin
-          "#{var}=#{short_inspect(b.local_variable_get(var))}"
-        rescue NameError, TypeError
-          nil
-        end
-      }.compact.join(', ')
-    end
-
-    def klass_sig frame
-      klass = frame.class
-      if klass == frame.self.singleton_class
-        "#{frame.self}."
-      else
-        "#{frame.class}#"
-      end
-    end
-
-    SHORT_INSPECT_LENGTH = 40
-
-    def short_inspect obj
-      str = obj.inspect
-      if str.length > SHORT_INSPECT_LENGTH
-        str[0...SHORT_INSPECT_LENGTH] + '...'
-      else
-        str
-      end
-    end
-
-    def frame_str i
-      buff = ''.dup
-      frame = @target_frames[i]
-      b = frame.binding
-
-      buff << (@current_frame_index == i ? '--> ' : '    ')
-      if b
-        buff << "##{i}\t#{frame.location}"
-      else
-        buff << "##{i}\t[C] #{frame.location}"
-      end
-
-      if b && (iseq = frame.iseq)
-        if iseq.type == :block
-          if (argc = iseq.argc) > 0
-            args = parameters_info b, iseq.locals[0...argc]
-            buff << " {|#{args}|}"
-          end
-        else
-          if (callee = b.eval('__callee__', __FILE__, __LINE__)) && (argc = iseq.argc) > 0
-            args = parameters_info b, iseq.locals[0...argc]
-            ksig = klass_sig frame
-            buff << " #{ksig}#{callee}(#{args})"
-          end
-        end
-
-        if frame.has_return_value
-          buff << " #=> #{short_inspect(frame.return_value)}"
-        end
-      else
-        # p frame.self
-      end
+    def frame_str(i, frame: @target_frames[i])
+      cur_str = (@current_frame_index == i ? '=>' : '  ')
+      prefix = "#{cur_str}##{i}"
+      frame_string = @frame_formatter.call(frame)
+      "#{prefix}\t#{frame_string}"
+    end
+
+    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
+          }
 
-      buff
-    end
+          frames << [i, f]
+        }
 
-    def show_frames max = (@target_frames || []).size
-      if max > 0 && frames = @target_frames
-        size = @target_frames.size
-        max += 1 if size == max + 1
+        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
+        puts "  # and #{size - max} frames (use `bt' command for all frames)" if max < size
       end
     end
 
@@ -377,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
@@ -401,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]
 
@@ -416,22 +483,30 @@ module DEBUGGER__
             step_tp{true}
           when :next
             frame = @target_frames.first
-            path = frame.location.absolute_path || "!eval:#{frame.location.path}"
+            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
@@ -446,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
@@ -474,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
@@ -492,7 +555,7 @@ module DEBUGGER__
           case type
           when :up
             if @current_frame_index + 1 < @target_frames.size
-              @current_frame_index += 1 
+              @current_frame_index += 1
               show_src max_lines: 1
               show_frame(@current_frame_index)
             end
@@ -522,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 || {}))
@@ -544,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
@@ -555,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