debug 1.5.0 → 1.6.0

data/lib/debug/server_dap.rb

@@ -18,7 +18,7 @@ module DEBUGGER__
       end
 
       at_exit do
-        CONFIG[:skip_path] = [//] # skip all
+        CONFIG.skip_all
         FileUtils.rm_rf dir if tempdir
       end
 
@@ -70,20 +70,69 @@ module DEBUGGER__
       end
     end
 
-    @local_fs = false
+    # true: all localfs
+    # Array: part of localfs
+    # nil: no localfs
+    @local_fs_map = nil
+
+    def self.remote_to_local_path path
+      case @local_fs_map
+      when nil
+        nil
+      when true
+        path
+      else # Array
+        @local_fs_map.each do |(remote_path_prefix, local_path_prefix)|
+          if path.start_with? remote_path_prefix
+            return path.sub(remote_path_prefix){ local_path_prefix }
+          end
+        end
 
-    def self.local_fs
-      @local_fs
+        nil
+      end
     end
 
-    def self.local_fs_set
-      @local_fs = true
+    def self.local_to_remote_path path
+      case @local_fs_map
+      when nil
+        nil
+      when true
+        path
+      else # Array
+        @local_fs_map.each do |(remote_path_prefix, local_path_prefix)|
+          if path.start_with? local_path_prefix
+            return path.sub(local_path_prefix){ remote_path_prefix }
+          end
+        end
+
+        nil
+      end
+    end
+
+    def self.local_fs_map_set map
+      return if @local_fs_map # already setup
+
+      case map
+      when String
+        @local_fs_map = map.split(',').map{|e| e.split(':').map{|path| path.delete_suffix('/') + '/'}}
+      when true
+        @local_fs_map = map
+      when nil
+        @local_fs_map = CONFIG[:local_fs_map]
+      end
     end
 
     def dap_setup bytes
       CONFIG.set_config no_color: true
       @seq = 0
-      UI_DAP.local_fs_set if self.kind_of?(UI_UnixDomainServer)
+
+      case self
+      when UI_UnixDomainServer
+        UI_DAP.local_fs_map_set true
+      when UI_TcpServer
+        # TODO: loopback address can be used to connect other FS env, like Docker containers
+        # UI_DAP.local_fs_set if @local_addr.ipv4_loopback? || @local_addr.ipv6_loopback?
+      end
 
       show_protocol :>, bytes
       req = JSON.load(bytes)
@@ -100,14 +149,13 @@ module DEBUGGER__
                {
                  filter: 'any',
                  label: 'rescue any exception',
-                 #supportsCondition: true,
+                 supportsCondition: true,
                  #conditionDescription: '',
                },
                {
                  filter: 'RuntimeError',
                  label: 'rescue RuntimeError',
-                 default: true,
-                 #supportsCondition: true,
+                 supportsCondition: true,
                  #conditionDescription: '',
                },
              ],
@@ -153,10 +201,12 @@ module DEBUGGER__
     end
 
     def send **kw
-      kw[:seq] = @seq += 1
-      str = JSON.dump(kw)
-      @sock.write "Content-Length: #{str.bytesize}\r\n\r\n#{str}"
-      show_protocol '<', str
+      if sock = @sock
+        kw[:seq] = @seq += 1
+        str = JSON.dump(kw)
+        sock.write "Content-Length: #{str.bytesize}\r\n\r\n#{str}"
+        show_protocol '<', str
+      end
     end
 
     def send_response req, success: true, message: nil, **kw
@@ -221,70 +271,97 @@ module DEBUGGER__
         ## boot/configuration
         when 'launch'
           send_response req
-          @is_attach = false
-          UI_DAP.local_fs_set if req.dig('arguments', 'localfs')
+          UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
+          @is_launch = true
+
         when 'attach'
           send_response req
-          Process.kill(UI_ServerBase::TRAP_SIGNAL, Process.pid)
-          @is_attach = true
-          UI_DAP.local_fs_set if req.dig('arguments', 'localfs')
-        when 'setBreakpoints'
-          path = args.dig('source', 'path')
-          SESSION.clear_line_breakpoints path
-
-          bps = []
-          args['breakpoints'].each{|bp|
-            line = bp['line']
-            if cond = bp['condition']
-              bps << SESSION.add_line_breakpoint(path, line, cond: cond)
-            else
-              bps << SESSION.add_line_breakpoint(path, line)
+          UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
+          @is_launch = false
+
+        when 'configurationDone'
+          send_response req
+
+          if @is_launch
+            @q_msg << 'continue'
+          else
+            if SESSION.in_subsession?
+              send_event 'stopped', reason: 'pause',
+                                    threadId: 1, # maybe ...
+                                    allThreadsStopped: true
             end
-          }
-          send_response req, breakpoints: (bps.map do |bp| {verified: true,} end)
+          end
+
+        when 'setBreakpoints'
+          req_path = args.dig('source', 'path')
+          path = UI_DAP.local_to_remote_path(req_path)
+
+          if path
+            SESSION.clear_line_breakpoints path
+
+            bps = []
+            args['breakpoints'].each{|bp|
+              line = bp['line']
+              if cond = bp['condition']
+                bps << SESSION.add_line_breakpoint(path, line, cond: cond)
+              else
+                bps << SESSION.add_line_breakpoint(path, line)
+              end
+            }
+            send_response req, breakpoints: (bps.map do |bp| {verified: true,} end)
+          else
+            send_response req, success: false, message: "#{req_path} is not available"
+          end
+
         when 'setFunctionBreakpoints'
           send_response req
+
         when 'setExceptionBreakpoints'
-          process_filter = ->(filter_id) {
-            case filter_id
-            when 'any'
-              bp = SESSION.add_catch_breakpoint 'Exception'
-            when 'RuntimeError'
-              bp = SESSION.add_catch_breakpoint 'RuntimeError'
-            else
-              bp = nil
-            end
-            {
-              verified: bp ? true : false,
-              message: bp.inspect,
+          process_filter = ->(filter_id, cond = nil) {
+            bp =
+              case filter_id
+              when 'any'
+                SESSION.add_catch_breakpoint 'Exception', cond: cond
+              when 'RuntimeError'
+                SESSION.add_catch_breakpoint 'RuntimeError', cond: cond
+              else
+                nil
+              end
+              {
+                verified: !bp.nil?,
+                message: bp.inspect,
+              }
             }
-          }
 
-          filters = args.fetch('filters').map {|filter_id|
-            process_filter.call(filter_id)
-          }
+            SESSION.clear_catch_breakpoints 'Exception', 'RuntimeError'
+
+            filters = args.fetch('filters').map {|filter_id|
+              process_filter.call(filter_id)
+            }
 
-          filters += args.fetch('filterOptions', {}).map{|bp_info|
-            process_filter.call(bp_info.dig('filterId'))
+            filters += args.fetch('filterOptions', {}).map{|bp_info|
+            process_filter.call(bp_info['filterId'], bp_info['condition'])
           }
 
           send_response req, breakpoints: filters
-        when 'configurationDone'
-          send_response req
-          if defined?(@is_attach) && @is_attach
-            @q_msg << 'p'
-            send_event 'stopped', reason: 'pause',
-                                  threadId: 1,
-                                  allThreadsStopped: true
-          else
-            @q_msg << 'continue'
-          end
+
         when 'disconnect'
-          if args.fetch("terminateDebuggee", false)
-            @q_msg << 'kill!'
+          terminate = args.fetch("terminateDebuggee", false)
+
+          if SESSION.in_subsession?
+            if terminate
+              @q_msg << 'kill!'
+            else
+              @q_msg << 'continue'
+            end
           else
-            @q_msg << 'continue'
+            if terminate
+              @q_msg << 'kill!'
+              pause
+            end
           end
+
+          SESSION.clear_all_breakpoints
           send_response req
 
         ## control
@@ -360,14 +437,6 @@ module DEBUGGER__
 
     ## called by the SESSION thread
 
-    def readline prompt
-      @q_msg.pop || 'kill!'
-    end
-
-    def sock skip: false
-      yield $stderr
-    end
-
     def respond req, res
       send_response(req, **res)
     end
@@ -379,6 +448,16 @@ module DEBUGGER__
 
     def event type, *args
       case type
+      when :load
+        file_path, reloaded = *args
+
+        if file_path
+          send_event 'loadedSource',
+                     reason: (reloaded ? :changed : :new),
+                     source: {
+                       path: file_path,
+                     }
+        end
       when :suspend_bp
         _i, bp, tid = *args
         if bp.kind_of?(CatchBreakpoint)
@@ -425,15 +504,16 @@ module DEBUGGER__
       case req['command']
       when 'stepBack'
         if @tc.recorder&.can_step_back?
-          @tc << [:step, :back]
+          request_tc [:step, :back]
         else
           fail_response req, message: 'cancelled'
         end
 
       when 'stackTrace'
         tid = req.dig('arguments', 'threadId')
+
         if tc = find_waiting_tc(tid)
-          tc << [:dap, :backtrace, req]
+          request_tc [:dap, :backtrace, req]
         else
           fail_response req
         end
@@ -442,7 +522,7 @@ module DEBUGGER__
         if @frame_map[frame_id]
           tid, fid = @frame_map[frame_id]
           if tc = find_waiting_tc(tid)
-            tc << [:dap, :scopes, req, fid]
+            request_tc [:dap, :scopes, req, fid]
           else
             fail_response req
           end
@@ -474,7 +554,7 @@ module DEBUGGER__
             tid, fid = @frame_map[frame_id]
 
             if tc = find_waiting_tc(tid)
-              tc << [:dap, :scope, req, fid]
+              request_tc [:dap, :scope, req, fid]
             else
               fail_response req
             end
@@ -483,7 +563,7 @@ module DEBUGGER__
             tid, vid = ref[1], ref[2]
 
             if tc = find_waiting_tc(tid)
-              tc << [:dap, :variable, req, vid]
+              request_tc [:dap, :variable, req, vid]
             else
               fail_response req
             end
@@ -501,7 +581,7 @@ module DEBUGGER__
           tid, fid = @frame_map[frame_id]
           expr = req.dig('arguments', 'expression')
           if tc = find_waiting_tc(tid)
-            tc << [:dap, :evaluate, req, fid, expr, context]
+            request_tc [:dap, :evaluate, req, fid, expr, context]
           else
             fail_response req
           end
@@ -527,7 +607,7 @@ module DEBUGGER__
           if col  = req.dig('arguments', 'column')
             text = text.split(/\n/)[line.to_i - 1][0...(col.to_i - 1)]
           end
-          tc << [:dap, :completions, req, fid, text]
+          request_tc [:dap, :completions, req, fid, text]
         else
           fail_response req
         end
@@ -542,13 +622,18 @@ module DEBUGGER__
 
       case type
       when :backtrace
-        result[:stackFrames].each.with_index{|fi, i|
+        result[:stackFrames].each{|fi|
+          frame_depth = fi[:id]
           fi[:id] = id = @frame_map.size + 1
-          @frame_map[id] = [req.dig('arguments', 'threadId'), i]
-          if fi[:source] && src = fi[:source][:sourceReference]
-            src_id = @src_map.size + 1
-            @src_map[src_id] = src
-            fi[:source][:sourceReference] = src_id
+          @frame_map[id] = [req.dig('arguments', 'threadId'), frame_depth]
+          if fi[:source]
+            if src = fi[:source][:sourceReference]
+              src_id = @src_map.size + 1
+              @src_map[src_id] = src
+              fi[:source][:sourceReference] = src_id
+            else
+              fi[:source][:sourceReference] = 0
+            end
           end
         }
         @ui.respond req, result
@@ -600,6 +685,11 @@ module DEBUGGER__
   end
 
   class ThreadClient
+    def value_inspect obj
+      # TODO: max length should be configuarable?
+      DEBUGGER__.safe_inspect obj, short: true, max_length: 4 * 1024
+    end
+
     def process_dap args
       # pp tc: self, args: args
       type = args.shift
@@ -607,27 +697,38 @@ module DEBUGGER__
 
       case type
       when :backtrace
-        event! :dap_result, :backtrace, req, {
-          stackFrames: @target_frames.map{|frame|
-            path = frame.realpath || frame.path
-            source_name = path ? File.basename(path) : frame.location.to_s
-
-            if !UI_DAP.local_fs || !(path && File.exist?(path))
-              ref = frame.file_lines
-            end
+        start_frame = req.dig('arguments', 'startFrame') || 0
+        levels = req.dig('arguments', 'levels') || 1_000
+        frames = []
+        @target_frames.each_with_index do |frame, i|
+          next if i < start_frame
+          break if (levels -= 1) < 0
+
+          path = frame.realpath || frame.path
+          source_name = path ? File.basename(path) : frame.location.to_s
+
+          if (path && File.exist?(path)) && (local_path = UI_DAP.remote_to_local_path(path))
+            # ok
+          else
+            ref = frame.file_lines
+          end
 
-            {
-              # id: ??? # filled by SESSION
-              name: frame.name,
-              line: frame.location.lineno,
-              column: 1,
-              source: {
-                name: source_name,
-                path: path,
-                sourceReference: ref,
-              },
-            }
+          frames << {
+            id: i, # id is refilled by SESSION
+            name: frame.name,
+            line: frame.location.lineno,
+            column: 1,
+            source: {
+              name: source_name,
+              path: (local_path || path),
+              sourceReference: ref,
+            },
           }
+        end
+
+        event! :dap_result, :backtrace, req, {
+          stackFrames: frames,
+          totalFrames: @target_frames.size,
         }
       when :scopes
         fid = args.shift
@@ -682,7 +783,7 @@ module DEBUGGER__
             case obj
             when Hash
               vars = obj.map{|k, v|
-                variable(DEBUGGER__.safe_inspect(k), v,)
+                variable(value_inspect(k), v,)
               }
             when Struct
               vars = obj.members.map{|m|
@@ -705,10 +806,10 @@ module DEBUGGER__
               ]
             end
 
-            vars += obj.instance_variables.map{|iv|
-              variable(iv, obj.instance_variable_get(iv))
+            vars += M_INSTANCE_VARIABLES.bind_call(obj).map{|iv|
+              variable(iv, M_INSTANCE_VARIABLE_GET.bind_call(obj, iv))
             }
-            vars.unshift variable('#class', obj.class)
+            vars.unshift variable('#class', M_CLASS.bind_call(obj))
           end
         end
         event! :dap_result, :variable, req, variables: (vars || []), tid: self.id
@@ -735,7 +836,7 @@ module DEBUGGER__
             case expr
             when /\A\@\S/
               begin
-                result = b.receiver.instance_variable_get(expr)
+                result = M_INSTANCE_VARIABLE_GET.bind_call(b.receiver, expr)
               rescue NameError
                 message = "Error: Not defined instance variable: #{expr.inspect}"
               end
@@ -746,6 +847,8 @@ module DEBUGGER__
                   break false
                 end
               } and (message = "Error: Not defined global variable: #{expr.inspect}")
+            when /\Aself$/
+              result = b.receiver
             when /(\A((::[A-Z]|[A-Z])\w*)+)/
               unless result = search_const(b, $1)
                 message = "Error: Not defined constants: #{expr.inspect}"
@@ -755,8 +858,8 @@ module DEBUGGER__
                 result = b.local_variable_get(expr)
               rescue NameError
                 # try to check method
-                if b.receiver.respond_to? expr, include_all: true
-                  result = b.receiver.method(expr)
+                if M_RESPOND_TO_P.bind_call(b.receiver, expr, include_all: true)
+                  result = M_METHOD.bind_call(b.receiver, expr)
                 else
                   message = "Error: Can not evaluate: #{expr.inspect}"
                 end
@@ -780,6 +883,8 @@ module DEBUGGER__
         end
 
         event! :dap_result, :completions, req, targets: (words || []).map{|phrase|
+          detail = nil
+
           if /\b([_a-zA-Z]\w*[!\?]?)\z/ =~ phrase
             w = $1
           else
@@ -788,13 +893,14 @@ module DEBUGGER__
 
           begin
             v = b.local_variable_get(w)
-            phrase += " (variable:#{DEBUGGER__.safe_inspect(v)})"
+            detail ="(variable: #{value_inspect(v)})"
           rescue NameError
           end
 
           {
             label: phrase,
             text: w,
+            detail: detail,
           }
         }
 
@@ -824,7 +930,7 @@ module DEBUGGER__
       v = variable nil, r
       v.delete :name
       v.delete :value
-      v[:result] = DEBUGGER__.safe_inspect(r)
+      v[:result] = value_inspect(r)
       v
     end
 
@@ -836,11 +942,11 @@ module DEBUGGER__
         vid = 0
       end
 
-      ivnum = obj.instance_variables.size
+      ivnum = M_INSTANCE_VARIABLES.bind_call(obj).size
 
       { name: name,
-        value: DEBUGGER__.safe_inspect(obj),
-        type: obj.class.name || obj.class.to_s,
+        value: value_inspect(obj),
+        type: (klass = M_CLASS.bind_call(obj)).name || klass.to_s,
         variablesReference: vid,
         indexedVariables: indexedVariables,
         namedVariables: namedVariables + ivnum,