debug 1.0.0.beta4 → 1.0.0.beta8

data/lib/debug/console.rb

@@ -1,14 +1,35 @@
-require_relative 'session'
+# frozen_string_literal: true
+
+require 'io/console/size'
 
 module DEBUGGER__
-  class UI_Console
+  class UI_Console < UI_Base
     def initialize
+      unless CONFIG[:no_sigint_hook]
+        @prev_handler = trap(:SIGINT){
+          ThreadClient.current.on_trap :SIGINT
+        }
+      end
+    end
+
+    def close
+      if @prev_handler
+        trap(:SIGINT, @prev_handler)
+      end
     end
 
     def remote?
       false
     end
 
+    def width
+      if (w = IO.console_size[1]) == 0 # for tests PTY
+        80
+      else
+        w
+      end
+    end
+
     def quit n
       exit n
     end
@@ -16,7 +37,7 @@ module DEBUGGER__
     def ask prompt
       setup_interrupt do
         print prompt
-        (gets || '').strip
+        ($stdin.gets || '').strip
       end
     end
 

data/lib/debug/frame_info.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
 
 module DEBUGGER__
   FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
-                          :has_return_value, :return_value, :show_line)
-
+                          :has_return_value, :return_value,
+                          :has_raised_exception, :raised_exception,
+                          :show_line)
 
   # extend FrameInfo with debug.so
   if File.exist? File.join(__dir__, 'debug.so')
     require_relative 'debug.so'
   else
-    require "debug/debug"
+    require_relative 'debug'
   end
 
   class FrameInfo
@@ -39,33 +41,73 @@ module DEBUGGER__
       end
     end
 
+    def name
+      # p frame_type: frame_type, self: self
+      case frame_type
+      when :block
+        level, block_loc, _args = block_identifier
+        "block in #{block_loc}#{level}"
+      when :method
+        ci, _args = method_identifier
+        "#{ci}"
+      when :c
+        c_identifier
+      when :other
+        other_identifier
+      end
+    end
+
     def file_lines
-      SESSION.source(realpath || path)
+      SESSION.source(self.iseq)
     end
 
-    def call_identifier_str
+    def frame_type
       if binding && iseq
         if iseq.type == :block
-          if (argc = iseq.argc) > 0
-            args = parameters_info iseq.locals[0...argc]
-            args_str = "{|#{args}|}"
-          end
-
-          location.label.sub('block'){ "block#{args_str}" }
-        elsif (callee = binding.eval('__callee__', __FILE__, __LINE__)) && (argc = iseq.argc) > 0
-          args = parameters_info iseq.locals[0...argc]
-          "#{klass_sig}#{callee}(#{args})"
+          :block
+        elsif callee
+          :method
         else
-          location.label
+          :other
         end
       else
-        "[C] #{klass_sig}#{location.base_label}"
+        :c
       end
     end
 
+    BLOCK_LABL_REGEXP = /\Ablock( \(\d+ levels\))* in (.+)\z/
+
+    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]
+    end
+
+    def method_identifier
+      return unless frame_type == :method
+      args = parameters_info(iseq.argc)
+      ci = "#{klass_sig}#{callee}"
+      [ci, args]
+    end
+
+    def c_identifier
+      return unless frame_type == :c
+      "[C] #{klass_sig}#{location.base_label}"
+    end
+
+    def other_identifier
+      return unless frame_type == :other
+      location.label
+    end
+
+    def callee
+      @callee ||= binding&.eval('__callee__', __FILE__, __LINE__)
+    end
+
     def return_str
       if binding && iseq && has_return_value
-        short_inspect(return_value)
+        DEBUGGER__.short_inspect(return_value)
       end
     end
 
@@ -75,31 +117,21 @@ module DEBUGGER__
 
     private
 
-    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 get_singleton_class obj
       obj.singleton_class # TODO: don't use it
     rescue TypeError
       nil
     end
 
-    def parameters_info vars
+    def parameters_info(argc)
+      vars = iseq.locals[0...argc]
       vars.map{|var|
         begin
-          "#{var}=#{short_inspect(binding.local_variable_get(var))}"
+          { name: var, value: DEBUGGER__.short_inspect(binding.local_variable_get(var)) }
         rescue NameError, TypeError
           nil
         end
-      }.compact.join(', ')
+      }.compact
     end
 
     def klass_sig

data/lib/debug/open.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Open the door for the debugger to connect.
 # Users can connect to debuggee program with "rdbg --attach" option.
@@ -6,5 +7,7 @@
 # Otherwise, UNIX domain socket is used.
 #
 
-require_relative 'server'
+require_relative 'session'
+return unless defined?(DEBUGGER__)
+
 DEBUGGER__.open

data/lib/debug/open_nonstop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+#
+# Open the door for the debugger to connect.
+# Unlike debug/open, it does not stop at the beginning of the program.
+# Users can connect to debuggee program with "rdbg --attach" option or
+# VSCode attach type.
+#
+# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
+# Otherwise, UNIX domain socket is used.
+#
+
+require_relative 'session'
+return unless defined?(DEBUGGER__)
+
+DEBUGGER__.open(nonstop: true)

data/lib/debug/server.rb

@@ -1,24 +1,32 @@
+# frozen_string_literal: true
+
 require 'socket'
-require_relative 'session'
 require_relative 'config'
+require_relative 'version'
 
 module DEBUGGER__
-  class UI_ServerBase
+  class UI_ServerBase < UI_Base
     def initialize
       @sock = nil
       @accept_m = Mutex.new
       @accept_cv = ConditionVariable.new
       @client_addr = nil
-      @q_msg = Queue.new
-      @q_ans = Queue.new
+      @q_msg = nil
+      @q_ans = nil
       @unsent_messages = []
+      @width = 80
 
       @reader_thread = Thread.new do
+        # An error on this thread should break the system.
+        Thread.current.abort_on_exception = true
+
         accept do |server|
-          DEBUGGER__.message "Connected."
+          DEBUGGER__.warn "Connected."
 
           @accept_m.synchronize{
             @sock = server
+            greeting
+
             @accept_cv.signal
 
             # flush unsent messages
@@ -26,32 +34,71 @@ module DEBUGGER__
               @sock.puts m
             }
             @unsent_messages.clear
+
+            @q_msg = Queue.new
+            @q_ans = Queue.new
           }
-          @q_msg = Queue.new
-          @q_ans = Queue.new
 
           setup_interrupt do
-            pause
-
-            while line = @sock.gets
-              case line
-              when /\Apause/
-                pause
-              when /\Acommand ?(.+)/
-                @q_msg << $1
-              when /\Aanswer (.*)/
-                @q_ans << $1
-              else
-                STDERR.puts "unsupported: #{line}"
-                exit!
-              end
-            end
+            process
           end
+
+        rescue => e
+          DEBUGGER__.warn "ReaderThreadError: #{e}", :error
         ensure
-          DEBUGGER__.message "Disconnected."
+          DEBUGGER__.warn "Disconnected."
           @sock = nil
           @q_msg.close
+          @q_msg = nil
           @q_ans.close
+          @q_ans = nil
+        end
+      end
+    end
+
+    def greeting
+      case g = @sock.gets
+      when /^version:\s+(.+)\s+width: (\d+) cookie:\s+(.*)$/
+        v, w, c = $1, $2, $3
+        # TODO: protocol version
+        if v != VERSION
+          raise "Incompatible version (#{VERSION} client:#{$1})"
+        end
+
+        cookie = CONFIG[:cookie]
+        if cookie && cookie != c
+          raise "Cookie mismatch (#{$2.inspect} was sent)"
+        end
+
+        @width = w.to_i
+
+      when /^Content-Length: (\d+)/
+        require_relative 'server_dap'
+
+        raise unless @sock.read(2) == "\r\n"
+        self.extend(UI_DAP)
+        dap_setup @sock.read($1.to_i)
+      else
+        raise "Greeting message error: #{g}"
+      end
+    end
+
+    def process
+      pause
+
+      while line = @sock.gets
+        case line
+        when /\Apause/
+          pause
+        when /\Acommand ?(.+)/
+          @q_msg << $1
+        when /\Aanswer (.*)/
+          @q_ans << $1
+        when /\Awidth (.+)/
+          @width = $1.to_i
+        else
+          STDERR.puts "unsupported: #{line}"
+          exit!
         end
       end
     end
@@ -60,6 +107,10 @@ module DEBUGGER__
       true
     end
 
+    def width
+      @width
+    end
+
     def setup_interrupt
       prev_handler = trap(:SIGINT) do
         # $stderr.puts "trapped SIGINT"
@@ -90,12 +141,20 @@ module DEBUGGER__
       if s = @sock         # already connection
         # ok
       elsif skip == true   # skip process
-        return yield nil
+        no_sock = true
+        r = @accept_m.synchronize do
+          if @sock
+            no_sock = false
+          else
+            yield nil
+          end
+        end
+        return r if no_sock
       else                 # wait for connection
         until s = @sock
           @accept_m.synchronize{
             unless @sock
-              DEBUGGER__.message "wait for debuger connection..."
+              DEBUGGER__.warn "wait for debuger connection..."
               @accept_cv.wait(@accept_m)
             end
           }
@@ -139,6 +198,7 @@ module DEBUGGER__
     def readline
       (sock do |s|
         s.puts "input"
+        sleep 0.01 until @q_msg
         @q_msg.pop
       end || 'continue').strip
     end
@@ -158,7 +218,7 @@ module DEBUGGER__
 
   class UI_TcpServer < UI_ServerBase
     def initialize host: nil, port: nil
-      @host = host || ::DEBUGGER__::CONFIG[:host] || 'localhost'
+      @host = host || ::DEBUGGER__::CONFIG[:host] || '127.0.0.1'
       @port = port || begin
         port_str = ::DEBUGGER__::CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
         if /\A\d+\z/ !~ port_str
@@ -173,7 +233,7 @@ module DEBUGGER__
 
     def accept
       Socket.tcp_server_sockets @host, @port do |socks|
-        ::DEBUGGER__.message "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
+        ::DEBUGGER__.warn "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
         Socket.accept_loop(socks) do |sock, client|
           @client_addr = client
           yield sock
@@ -203,15 +263,13 @@ module DEBUGGER__
         @sock_path = DEBUGGER__.create_unix_domain_socket_name(@sock_dir)
       end
 
-      ::DEBUGGER__.message "Debugger can attach via UNIX domain socket (#{@sock_path})"
+      ::DEBUGGER__.warn "Debugger can attach via UNIX domain socket (#{@sock_path})"
       Socket.unix_server_loop @sock_path do |sock, client|
         @client_addr = client
         yield sock
+      ensure
+        sock.close
       end
     end
   end
-
-  def self.message msg
-    $stderr.puts "DEBUGGER: #{msg}"
-  end
 end

data/lib/debug/server_dap.rb

@@ -0,0 +1,607 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module DEBUGGER__
+  module UI_DAP
+    SHOW_PROTOCOL = ENV['RUBY_DEBUG_DAP_SHOW_PROTOCOL'] == '1'
+
+    def dap_setup bytes
+      DEBUGGER__.set_config(no_color: true)
+      @seq = 0
+
+      $stderr.puts '[>]' + bytes if SHOW_PROTOCOL
+      req = JSON.load(bytes)
+
+      # capability
+      send_response(req,
+             ## Supported
+             supportsConfigurationDoneRequest: true,
+             supportsFunctionBreakpoints: true,
+             supportsConditionalBreakpoints: true,
+             supportTerminateDebuggee: true,
+             supportsTerminateRequest: true,
+             exceptionBreakpointFilters: [
+               {
+                 filter: 'any',
+                 label: 'rescue any exception',
+                 #supportsCondition: true,
+                 #conditionDescription: '',
+               },
+               {
+                 filter: 'RuntimeError',
+                 label: 'rescue RuntimeError',
+                 default: true,
+                 #supportsCondition: true,
+                 #conditionDescription: '',
+               },
+             ],
+             supportsExceptionFilterOptions: true,
+
+             ## Will be supported
+             # supportsExceptionOptions: true,
+             # supportsHitConditionalBreakpoints:
+             # supportsEvaluateForHovers:
+             # supportsSetVariable: true,
+             # supportSuspendDebuggee:
+             # supportsLogPoints:
+             # supportsLoadedSourcesRequest:
+             # supportsDataBreakpoints:
+             # supportsBreakpointLocationsRequest:
+
+             ## Possible?
+             # supportsStepBack:
+             # supportsRestartFrame:
+             # supportsCompletionsRequest:
+             # completionTriggerCharacters:
+             # supportsModulesRequest:
+             # additionalModuleColumns:
+             # supportedChecksumAlgorithms:
+             # supportsRestartRequest:
+             # supportsValueFormattingOptions:
+             # supportsExceptionInfoRequest:
+             # supportsDelayedStackTraceLoading:
+             # supportsTerminateThreadsRequest:
+             # supportsSetExpression:
+             # supportsClipboardContext:
+
+             ## Never
+             # supportsGotoTargetsRequest:
+             # supportsStepInTargetsRequest:
+             # supportsReadMemoryRequest:
+             # supportsDisassembleRequest:
+             # supportsCancelRequest:
+             # supportsSteppingGranularity:
+             # supportsInstructionBreakpoints:
+      )
+      send_event 'initialized'
+    end
+
+    def send **kw
+      kw[:seq] = @seq += 1
+      str = JSON.dump(kw)
+      $stderr.puts "[<] #{str}" if SHOW_PROTOCOL
+      # STDERR.puts "[STDERR] [<] #{str}"
+      @sock.print header = "Content-Length: #{str.size}\r\n\r\n"
+      @sock.write str
+    end
+
+    def send_response req, success: true, **kw
+      if kw.empty?
+        send type: 'response',
+             command: req['command'],
+             request_seq: req['seq'],
+             success: success,
+             message: success ? 'Success' : 'Failed'
+      else
+        send type: 'response',
+             command: req['command'],
+             request_seq: req['seq'],
+             success: success,
+             message: success ? 'Success' : 'Failed',
+             body: kw
+      end
+    end
+
+    def send_event name, **kw
+      if kw.empty?
+        send type: 'event', event: name
+      else
+        send type: 'event', event: name, body: kw
+      end
+    end
+
+    def recv_request
+      case header = @sock.gets
+      when /Content-Length: (\d+)/
+        b = @sock.read(2)
+        raise b.inspect unless b == "\r\n"
+
+        l = @sock.read(s = $1.to_i)
+        $stderr.puts "[>] #{l}" if SHOW_PROTOCOL
+        JSON.load(l)
+      when nil
+        nil
+      else
+        raise "unrecognized line: #{l} (#{l.size} bytes)"
+      end
+    end
+
+    def process
+      while req = recv_request
+        raise "not a request: #{req.inpsect}" unless req['type'] == 'request'
+        args = req.dig('arguments')
+
+        case req['command']
+
+        ## boot/configuration
+        when 'launch'
+          send_response req
+        when 'setBreakpoints'
+          path = args.dig('source', 'path')
+          bp_args = args['breakpoints']
+          bps = []
+          bp_args.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)
+        when 'setFunctionBreakpoints'
+          send_response req
+        when 'setExceptionBreakpoints'
+          filters = args.dig('filterOptions').map{|bp_info|
+            case bp_info.dig('filterId')
+            when 'any'
+              bp = SESSION.add_catch_breakpoint 'Exception'
+            when 'RuntimeError'
+              bp = SESSION.add_catch_breakpoint 'RuntimeError'
+            else
+              bp = nil
+            end
+            {
+              verifiled: bp ? true : false,
+              message: bp.inspect,
+            }
+          }
+          send_response req, breakpoints: filters
+        when 'configurationDone'
+          send_response req
+          @q_msg << 'continue'
+        when 'attach'
+          send_response req
+          Process.kill(:SIGINT, Process.pid)
+        when 'disconnect'
+          send_response req
+          @q_msg << 'continue'
+
+        ## control
+        when 'continue'
+          @q_msg << 'c'
+          send_response req, allThreadsContinued: true
+        when 'next'
+          @q_msg << 'n'
+          send_response req
+        when 'stepIn'
+          @q_msg << 's'
+          send_response req
+        when 'stepOut'
+          @q_msg << 'fin'
+          send_response req
+        when 'terminate'
+          send_response req
+          exit
+        when 'pause'
+          send_response req
+          Process.kill(:SIGINT, Process.pid)
+
+        ## query
+        when 'threads'
+          send_response req, threads: SESSION.managed_thread_clients.map{|tc|
+            { id: tc.id,
+              name: tc.name,
+            }
+          }
+
+        when 'stackTrace',
+             'scopes',
+             'variables',
+             'evaluate',
+             'source'
+          @q_msg << req
+        else
+          raise "Unknown request: #{req.inspect}"
+        end
+      end
+    end
+
+    ## called by the SESSION thread
+
+    def readline
+      @q_msg.pop || 'kill!'
+    end
+
+    def sock skip: false
+      yield $stderr
+    end
+
+    def respond req, res
+      send_response(req, **res)
+    end
+
+    def puts result
+      # STDERR.puts "puts: #{result}"
+      # send_event 'output', category: 'stderr', output: "PUTS!!: " + result.to_s
+    end
+
+    def event type, *args
+      case type
+      when :suspend_bp
+        _i, bp = *args
+        if bp.kind_of?(CatchBreakpoint)
+          reason = 'exception'
+          text = bp.description
+        else
+          reason = 'breakpoint'
+          text = bp ? bp.description : 'temporary bp'
+        end
+
+        send_event 'stopped', reason: reason,
+                              description: text,
+                              text: text,
+                              threadId: 1,
+                              allThreadsStopped: true
+      when :suspend_trap
+        send_event 'stopped', reason: 'pause',
+                              threadId: 1,
+                              allThreadsStopped: true
+      when :suspended
+        send_event 'stopped', reason: 'step',
+                              threadId: 1,
+                              allThreadsStopped: true
+      end
+    end
+  end
+
+  class Session
+    def find_tc id
+      @th_clients.each{|th, tc|
+        return tc if tc.id == id
+      }
+      return nil
+    end
+
+    def fail_response req, **kw
+      @ui.respond req, success: false, **kw
+      return :retry
+    end
+
+    def process_dap_request req
+      case req['command']
+      when 'stackTrace'
+        tid = req.dig('arguments', 'threadId')
+        if tc = find_tc(tid)
+          tc << [:dap, :backtrace, req]
+        else
+          fail_response req
+        end
+      when 'scopes'
+        frame_id = req.dig('arguments', 'frameId')
+        if @frame_map[frame_id]
+          tid, fid = @frame_map[frame_id]
+          if tc = find_tc(tid)
+            tc << [:dap, :scopes, req, fid]
+          else
+            fail_response req
+          end
+        else
+          fail_response req
+        end
+      when 'variables'
+        varid = req.dig('arguments', 'variablesReference')
+        if ref = @var_map[varid]
+          case ref[0]
+          when :globals
+            vars = global_variables.map do |name|
+              File.write('/tmp/x', "#{name}\n")
+              gv = 'Not implemented yet...'
+              {
+                name: name,
+                value: gv.inspect,
+                type: (gv.class.name || gv.class.to_s),
+                variablesReference: 0,
+              }
+            end
+
+            @ui.respond req, {
+              variables: vars,
+            }
+            return :retry
+
+          when :scope
+            frame_id = ref[1]
+            tid, fid = @frame_map[frame_id]
+
+            if tc = find_tc(tid)
+              tc << [:dap, :scope, req, fid]
+            else
+              fail_response req
+            end
+
+          when :variable
+            tid, vid = ref[1], ref[2]
+
+            if tc = find_tc(tid)
+              tc << [:dap, :variable, req, vid]
+            else
+              fail_response req
+            end
+          else
+            raise "Uknown type: #{ref.inspect}"
+          end
+        else
+          fail_response req
+        end
+      when 'evaluate'
+        frame_id = req.dig('arguments', 'frameId')
+        if @frame_map[frame_id]
+          tid, fid = @frame_map[frame_id]
+          expr = req.dig('arguments', 'expression')
+          if tc = find_tc(tid)
+            tc << [:dap, :evaluate, req, fid, expr]
+          else
+            fail_response req
+          end
+        else
+          fail_response req, result: "can't evaluate"
+        end
+      when 'source'
+        ref = req.dig('arguments', 'sourceReference')
+        if src = @src_map[ref]
+          @ui.respond req, content: src.join
+        else
+          fail_response req, message: 'not found...'
+        end
+
+        return :retry
+      else
+        raise "Unknown DAP request: #{req.inspect}"
+      end
+    end
+
+    def dap_event args
+      # puts({dap_event: args}.inspect)
+      type, req, result = args
+
+      case type
+      when :backtrace
+        result[:stackFrames].each.with_index{|fi, i|
+          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
+          end
+        }
+        @ui.respond req, result
+      when :scopes
+        frame_id = req.dig('arguments', 'frameId')
+        local_scope = result[:scopes].first
+        local_scope[:variablesReference] = id = @var_map.size + 1
+
+        @var_map[id] = [:scope, frame_id]
+        @ui.respond req, result
+      when :scope
+        tid = result.delete :tid
+        register_vars result[:variables], tid
+        @ui.respond req, result
+      when :variable
+        tid = result.delete :tid
+        register_vars result[:variables], tid
+        @ui.respond req, result
+      when :evaluate
+        tid = result.delete :tid
+        register_var result, tid
+        @ui.respond req, result
+      else
+        raise "unsupported: #{args.inspect}"
+      end
+    end
+
+    def register_var v, tid
+      if (tl_vid = v[:variablesReference]) > 0
+        vid = @var_map.size + 1
+        @var_map[vid] = [:variable, tid, tl_vid]
+        v[:variablesReference] = vid
+      end
+    end
+
+    def register_vars vars, tid
+      raise tid.inspect unless tid.kind_of?(Integer)
+      vars.each{|v|
+        register_var v, tid
+      }
+    end
+  end
+
+  class ThreadClient
+    def process_dap args
+      # pp tc: self, args: args
+      type = args.shift
+      req = args.shift
+
+      case type
+      when :backtrace
+        event! :dap_result, :backtrace, req, {
+          stackFrames: @target_frames.map.with_index{|frame, i|
+            path = frame.realpath
+            ref = frame.file_lines unless File.exist?(path)
+
+            {
+              # id: ??? # filled by SESSION
+              name: frame.name,
+              line: frame.location.lineno,
+              column: 1,
+              source: {
+                name: File.basename(frame.path),
+                path: path,
+                sourceReference: ref,
+              },
+            }
+          }
+        }
+      when :scopes
+        fid = args.shift
+        frame = @target_frames[fid]
+        lnum = frame.binding ? frame.binding.local_variables.size : 0
+
+        event! :dap_result, :scopes, req, scopes: [{
+          name: 'Local variables',
+          presentationHint: 'locals',
+          # variablesReference: N, # filled by SESSION
+          namedVariables: lnum,
+          indexedVariables: 0,
+          expensive: false,
+        }, {
+          name: 'Global variables',
+          presentationHint: 'globals',
+          variablesReference: 1, # GLOBAL
+          namedVariables: global_variables.size,
+          indexedVariables: 0,
+          expensive: false,
+        }]
+      when :scope
+        fid = args.shift
+        frame = @target_frames[fid]
+        if b = frame.binding
+          vars = b.local_variables.map{|name|
+            v = b.local_variable_get(name)
+            variable(name, v)
+          }
+          vars.unshift variable('%raised', frame.raised_exception) if frame.has_raised_exception
+          vars.unshift variable('%return', frame.return_value) if frame.has_return_value
+          vars.unshift variable('%self', b.receiver)
+        else
+          vars = [variable('%self', frame.self)]
+          vars.push variable('%raised', frame.raised_exception) if frame.has_raised_exception
+          vars.push variable('%return', frame.return_value) if frame.has_return_value
+        end
+        event! :dap_result, :scope, req, variables: vars, tid: self.id
+
+      when :variable
+        vid = args.shift
+        obj = @var_map[vid]
+        if obj
+          case req.dig('arguments', 'filter')
+          when 'indexed'
+            start = req.dig('arguments', 'start') || 0
+            count = req.dig('arguments', 'count') || obj.size
+            vars = (start ... (start + count)).map{|i|
+              variable(i.to_s, obj[i])
+            }
+          else
+            vars = []
+
+            case obj
+            when Hash
+              vars = obj.map{|k, v|
+                variable(DEBUGGER__.short_inspect(k), v)
+              }
+            when Struct
+              vars = obj.members.map{|m|
+                variable(m, obj[m])
+              }
+            when String
+              vars = [
+                variable('#length', obj.length),
+                variable('#encoding', obj.encoding)
+              ]
+            when Class, Module
+              vars = obj.instance_variables.map{|iv|
+                variable(iv, obj.instance_variable_get(iv))
+              }
+              vars.unshift variable('%ancestors', obj.ancestors[1..])
+            when Range
+              vars = [
+                variable('#begin', obj.begin),
+                variable('#end', obj.end),
+              ]
+            end
+
+            vars += obj.instance_variables.map{|iv|
+              variable(iv, obj.instance_variable_get(iv))
+            }
+            vars.unshift variable('#class', obj.class)
+          end
+        end
+        event! :dap_result, :variable, req, variables: (vars || []), tid: self.id
+
+      when :evaluate
+        fid, expr = args
+        frame = @target_frames[fid]
+
+        if frame && (b = frame.binding)
+          begin
+            result = b.eval(expr.to_s, '(DEBUG CONSOLE)')
+          rescue Exception => e
+            result = e
+          end
+        else
+          result = 'can not evaluate on this frame...'
+        end
+        event! :dap_result, :evaluate, req, tid: self.id, **evaluate_result(result)
+      else
+        raise "Unkown req: #{args.inspect}"
+      end
+    end
+
+    def evaluate_result r
+      v = variable nil, r
+      v.delete(:name)
+      v[:result] = DEBUGGER__.short_inspect(r)
+      v
+    end
+
+    def variable_ name, obj, indexedVariables: 0, namedVariables: 0, use_short: true
+      if indexedVariables > 0 || namedVariables > 0
+        vid = @var_map.size + 1
+        @var_map[vid] = obj
+      else
+        vid = 0
+      end
+
+      ivnum = obj.instance_variables.size
+
+      { name: name,
+        value: DEBUGGER__.short_inspect(obj, use_short),
+        type: obj.class.name || obj.class.to_s,
+        variablesReference: vid,
+        indexedVariables: indexedVariables,
+        namedVariables: namedVariables + ivnum,
+      }
+    end
+
+    def variable name, obj
+      case obj
+      when Array
+        variable_ name, obj, indexedVariables: obj.size
+      when Hash
+        variable_ name, obj, namedVariables: obj.size
+      when String
+        variable_ name, obj, use_short: false, namedVariables: 3 # #to_str, #length, #encoding
+      when Struct
+        variable_ name, obj, namedVariables: obj.size
+      when Class, Module
+        variable_ name, obj, namedVariables: 1 # %ancestors (#ancestors without self)
+      when Range
+        variable_ name, obj, namedVariables: 2 # #begin, #end
+      else
+        variable_ name, obj, namedVariables: 1 # #class
+      end
+    end
+  end
+end