debug 1.7.2 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bac91980fb350e0e37a0639612064bba25a8e441661a6d797e0d9f996ce0205
-  data.tar.gz: 3294757150ec0731ccadd0c26a57c8e920c0479e4a967b4900e999dae4afcf9c
+  metadata.gz: 39fceaae982c712433b6bf0bc855328c5d923524658a399926e7a032f5d7cdbf
+  data.tar.gz: 4f80f39348e0cd46882bd54e04398342c3d124133aa15edcc57a18f1a20fe449
 SHA512:
-  metadata.gz: 7a0259c1f8fa904d9a425be5035e2642de89e69cd81cc61bd81bae2e9e7b17dbd18a78addce9e5ed8e3c7723417c0de1113a26922131760e490e77e91bb8493d
-  data.tar.gz: fd55333ccf690b4338729a2b84d55a21464ba2de71bdf5edcb0b82f309594477333224eb3be0a89c6b7c477042c4f904f8b743f74bba3931f6db4de7a9ff7dd9
+  metadata.gz: 67a369a45e2debb29dbb42fcbc32d36e1c40467249d657f45caa8a04a5fb3521a10c91860a3f3407caaa8f97cf81ad35f8a3e5ac83a124b99811d82363afe2cf
+  data.tar.gz: b29458d948196114b7cb5c7c182decca2685495b96707d904674714a2256a46bd0244efdde5d1ada8a460d881dff7ad4acafaa2c433c6e0eddbcf928425f6748

data/README.md

@@ -476,6 +476,7 @@ config set no_color true
   * `RUBY_DEBUG_NO_SIGINT_HOOK` (`no_sigint_hook`): Do not suspend on SIGINT (default: false)
   * `RUBY_DEBUG_NO_RELINE` (`no_reline`): Do not use Reline library (default: false)
   * `RUBY_DEBUG_NO_HINT` (`no_hint`): Do not show the hint on the REPL (default: false)
+  * `RUBY_DEBUG_NO_LINENO` (`no_lineno`): Do not show line numbers (default: false)
 
 * CONTROL
   * `RUBY_DEBUG_SKIP_PATH` (`skip_path`): Skip showing/entering frames for given paths
@@ -908,6 +909,8 @@ Attach mode:
   'rdbg -A host port' tries to connect to host:port via TCP/IP.
 
 Other options:
+    -v                               Show version number
+        --version                    Show version number and exit
     -h, --help                       Print help
         --util=NAME                  Utility mode (used by tools)
         --stop-at-load               Stop immediately when the debugging feature is loaded.

data/lib/debug/config.rb

@@ -21,6 +21,7 @@ module DEBUGGER__
     no_sigint_hook: ['RUBY_DEBUG_NO_SIGINT_HOOK', "UI: Do not suspend on SIGINT",               :bool, "false"],
     no_reline:      ['RUBY_DEBUG_NO_RELINE',      "UI: Do not use Reline library",              :bool, "false"],
     no_hint:        ['RUBY_DEBUG_NO_HINT',        "UI: Do not show the hint on the REPL",       :bool, "false"],
+    no_lineno:      ['RUBY_DEBUG_NO_LINENO',      "UI: Do not show line numbers",               :bool, "false"],
 
     # control setting
     skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "CONTROL: Skip showing/entering frames for given paths", :path],

data/lib/debug/dap_custom/traceInspector.rb

@@ -0,0 +1,336 @@
+module DEBUGGER__
+  module DAP_TraceInspector
+    class MultiTracer < Tracer
+      def initialize ui, evts, trace_params, max_log_size: nil, **kw
+        @evts = evts
+        @log = []
+        @trace_params = trace_params
+        if max_log_size
+          @max_log_size = max_log_size
+        else
+          @max_log_size = 50000
+        end
+        @dropped_trace_cnt = 0
+        super(ui, **kw)
+        @type = 'multi'
+        @name = 'TraceInspector'
+      end
+  
+      attr_accessor :dropped_trace_cnt
+      attr_reader :log
+  
+      def setup
+        @tracer = TracePoint.new(*@evts){|tp|
+          next if skip?(tp)
+  
+          case tp.event
+          when :call, :c_call, :b_call
+            if @trace_params
+              params = parameters_info tp
+            end
+            append(call_trace_log(tp, params: params))
+          when :return, :c_return, :b_return
+            return_str = DEBUGGER__.safe_inspect(tp.return_value, short: true, max_length: 4096)
+            append(call_trace_log(tp, return_str: return_str))
+          when :line
+            append(line_trace_log(tp))
+          end
+        }
+      end
+
+      def parameters_info tp
+        b = tp.binding
+        tp.parameters.map{|_type, name|
+          begin
+            { name: name, value: DEBUGGER__.safe_inspect(b.local_variable_get(name), short: true, max_length: 4096) }
+          rescue NameError, TypeError
+            nil
+          end
+        }.compact
+      end
+  
+      def call_identifier_str tp
+        if tp.defined_class
+          minfo(tp)
+        else
+          "block"
+        end
+      end
+  
+      def append log
+        if @log.size >= @max_log_size
+          @dropped_trace_cnt += 1
+          @log.shift
+        end
+        @log << log
+      end
+  
+      def call_trace_log tp, return_str: nil, params: nil
+        log = {
+          depth: DEBUGGER__.frame_depth,
+          name: call_identifier_str(tp),
+          threadId: Thread.current.instance_variable_get(:@__thread_client_id),
+          location: {
+            path: tp.path,
+            line: tp.lineno
+          }
+        }
+        log[:returnValue] = return_str if return_str
+        log[:parameters] = params if params && params.size > 0
+        log
+      end
+  
+      def line_trace_log tp
+        {
+          depth: DEBUGGER__.frame_depth,
+          threadId: Thread.current.instance_variable_get(:@__thread_client_id),
+          location: {
+            path: tp.path,
+            line: tp.lineno
+          }
+        }
+      end
+  
+      def skip? tp
+        super || !@evts.include?(tp.event)
+      end
+
+      def skip_with_pattern?(tp)
+        super && !tp.method_id&.match?(@pattern)
+      end
+    end
+
+    class Custom_Recorder < ThreadClient::Recorder
+      def initialize max_log_size: nil
+        if max_log_size
+          @max_log_size = max_log_size
+        else
+          @max_log_size = 50000
+        end
+        @dropped_trace_cnt = 0
+        super()
+      end
+
+      attr_accessor :dropped_trace_cnt
+
+      def append frames
+        if @log.size >= @max_log_size
+          @dropped_trace_cnt += 1
+          @log.shift
+        end
+        @log << frames
+      end
+    end
+
+    module Custom_UI_DAP
+      def custom_dap_request_rdbgTraceInspector(req)
+        @q_msg << req
+      end
+    end
+
+    module Custom_Session
+      def process_trace_cmd req
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          events = req.dig('arguments', 'events')
+          evts = []
+          trace_params = false
+          filter = req.dig('arguments', 'filterRegExp')
+          max_log_size = req.dig('arguments', 'maxLogSize')
+          events.each{|evt|
+            case evt
+            when 'traceLine'
+              evts << :line
+            when 'traceCall'
+              evts << :call
+              evts << :b_call
+            when 'traceReturn'
+              evts << :return
+              evts << :b_return
+            when 'traceParams'
+              trace_params = true
+            when 'traceClanguageCall'
+              evts << :c_call
+            when 'traceClanguageReturn'
+              evts << :c_return
+            else
+              raise "unknown trace type #{evt}"
+            end
+          }
+          add_tracer MultiTracer.new @ui, evts, trace_params, max_log_size: max_log_size, pattern: filter
+          @ui.respond req, {}
+        when 'disable'
+          if t = find_multi_trace
+            t.disable
+          end
+          @ui.respond req, {}
+        when 'collect'
+          logs = []
+          if t = find_multi_trace
+            logs = t.log
+            if t.dropped_trace_cnt > 0
+              @ui.puts "Return #{logs.size} traces and #{t.dropped_trace_cnt} traces are dropped"
+            else
+              @ui.puts "Return #{logs.size} traces"
+            end
+            t.dropped_trace_cnt = 0
+          end
+          @ui.respond req, logs: logs
+        else
+          raise "Unknown trace sub command #{cmd}"
+        end
+        return :retry
+      end
+
+      def find_multi_trace
+        @tracers.values.each{|t|
+          if t.type == 'multi'
+            return t
+          end
+        }
+        return nil
+      end
+
+      def process_record_cmd req
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          @tc << [:dap, :rdbgTraceInspector, req]
+        when 'disable'
+          @tc << [:dap, :rdbgTraceInspector, req]
+        when 'step'
+          tid = req.dig('arguments', 'threadId')
+          count = req.dig('arguments', 'count')
+          if tc = find_waiting_tc(tid)
+            @ui.respond req, {}
+            tc << [:step, :in, count]
+          else
+            fail_response req
+          end
+        when 'stepBack'
+          tid = req.dig('arguments', 'threadId')
+          count = req.dig('arguments', 'count')
+          if tc = find_waiting_tc(tid)
+            @ui.respond req, {}
+            tc << [:step, :back, count]
+          else
+            fail_response req
+          end
+        when 'collect'
+          tid = req.dig('arguments', 'threadId')
+          if tc = find_waiting_tc(tid)
+            tc << [:dap, :rdbgTraceInspector, req]
+          else
+            fail_response req
+          end
+        else
+          raise "Unknown record sub command #{cmd}"
+        end
+      end
+
+      def custom_dap_request_rdbgTraceInspector(req)
+        cmd = req.dig('arguments', 'command')
+        case cmd
+        when 'trace'
+          process_trace_cmd req
+        when 'record'
+          process_record_cmd req
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+
+      def custom_dap_request_event_rdbgTraceInspector(req, result)
+        cmd = req.dig('arguments', 'command')
+        case cmd
+        when 'record'
+          process_event_record_cmd(req, result)
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+
+      def process_event_record_cmd(req, result)
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          @ui.respond req, {}
+        when 'disable'
+          @ui.respond req, {}
+        when 'collect'
+          cnt = result.delete :dropped_trace_cnt
+          if cnt > 0
+            @ui.puts "Return #{result[:logs].size} traces and #{cnt} traces are dropped"
+          else
+            @ui.puts "Return #{result[:logs].size} traces"
+          end
+          @ui.respond req, result
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+    end
+
+    module Custom_ThreadClient
+      def custom_dap_request_rdbgTraceInspector(req)
+        cmd = req.dig('arguments', 'command')
+        case cmd
+        when 'record'
+          process_record_cmd(req)
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+
+      def process_record_cmd(req)
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          size = req.dig('arguments', 'maxLogSize')
+          @recorder = Custom_Recorder.new max_log_size: size
+          @recorder.enable
+          event! :protocol_result, :rdbgTraceInspector, req
+        when 'disable'
+          if @recorder&.enabled?
+            @recorder.disable
+          end
+          @recorder = nil
+          event! :protocol_result, :rdbgTraceInspector, req
+        when 'collect'
+          logs = []
+          log_index = nil
+          trace_cnt = 0
+          unless @recorder.nil?
+            log_index = @recorder.log_index
+            @recorder.log.each{|frames|
+              crt_frame = frames[0]
+              log = {
+                name: crt_frame.name,
+                location: {
+                  path: crt_frame.location.path,
+                  line: crt_frame.location.lineno,
+                },
+                depth: crt_frame.frame_depth
+              }
+              if params = crt_frame.iseq_parameters_info
+                log[:parameters] = params
+              end
+              if return_str = crt_frame.return_str
+                log[:returnValue] = return_str
+              end
+              logs << log
+            }
+            trace_cnt = @recorder.dropped_trace_cnt
+            @recorder.dropped_trace_cnt = 0
+          end
+          event! :protocol_result, :rdbgTraceInspector, req, logs: logs, stoppedIndex: log_index, dropped_trace_cnt: trace_cnt
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+    end
+
+    ::DEBUGGER__::SESSION.extend_feature session: Custom_Session, thread_client: Custom_ThreadClient, ui: Custom_UI_DAP
+  end
+end

data/lib/debug/frame_info.rb

@@ -147,6 +147,15 @@ module DEBUGGER__
       end
     end
 
+    def iseq_parameters_info
+      case frame_type
+      when :block, :method
+        parameters_info
+      else
+        nil
+      end
+    end
+
     def parameters_info
       vars = iseq.parameters_symbols
       vars.map{|var|

data/lib/debug/server_cdp.rb

@@ -849,27 +849,25 @@ module DEBUGGER__
           unless s_id = @scr_id_map[path]
             s_id = (@scr_id_map.size + 1).to_s
             @scr_id_map[path] = s_id
+            lineno = 0
+            src = ''
             if path && File.exist?(path)
               src = File.read(path)
+              @src_map[s_id] = src
+              lineno = src.lines.count
             end
-            @src_map[s_id] = src
-          end
-          if src = @src_map[s_id]
-            lineno = src.lines.count
-          else
-            lineno = 0
-          end
-          frame[:location][:scriptId] = s_id
-          frame[:functionLocation][:scriptId] = s_id
-          @ui.fire_event 'Debugger.scriptParsed',
+            @ui.fire_event 'Debugger.scriptParsed',
                           scriptId: s_id,
-                          url: frame[:url],
+                          url: path,
                           startLine: 0,
                           startColumn: 0,
                           endLine: lineno,
                           endColumn: 0,
                           executionContextId: 1,
                           hash: src.hash.inspect
+          end
+          frame[:location][:scriptId] = s_id
+          frame[:functionLocation][:scriptId] = s_id
 
           frame[:scopeChain].each {|s|
             oid = s.dig(:object, :objectId)

data/lib/debug/server_dap.rb

@@ -274,198 +274,225 @@ module DEBUGGER__
       retry
     end
 
+    def load_extensions req
+      if exts = req.dig('arguments', 'rdbgExtensions')
+        exts.each{|ext|
+          require_relative "dap_custom/#{File.basename(ext)}"
+        }
+      end
+
+      if scripts = req.dig('arguments', 'rdbgInitialScripts')
+        scripts.each do |script|
+          begin
+            eval(script)
+          rescue Exception => e
+            puts e.message
+            puts e.backtrace.inspect
+          end
+        end
+      end
+    end
+
     def process
       while req = recv_request
-        raise "not a request: #{req.inspect}" unless req['type'] == 'request'
-        args = req.dig('arguments')
+        process_request(req)
+      end
+    ensure
+      send_event :terminated unless @sock.closed?
+    end
 
-        case req['command']
+    def process_request req
+      raise "not a request: #{req.inspect}" unless req['type'] == 'request'
+      args = req.dig('arguments')
 
-        ## boot/configuration
-        when 'launch'
-          send_response req
-          # `launch` runs on debuggee on the same file system
-          UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap') || true
-          @nonstop = true
+      case req['command']
 
-        when 'attach'
-          send_response req
-          UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
+      ## boot/configuration
+      when 'launch'
+        send_response req
+        # `launch` runs on debuggee on the same file system
+        UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap') || true
+        @nonstop = true
 
-          if req.dig('arguments', 'nonstop') == true
-            @nonstop = true
-          else
-            @nonstop = false
-          end
+        load_extensions req
 
-        when 'configurationDone'
-          send_response req
+      when 'attach'
+        send_response req
+        UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
 
-          if @nonstop
-            @q_msg << 'continue'
-          else
-            if SESSION.in_subsession?
-              send_event 'stopped', reason: 'pause',
-                                    threadId: 1, # maybe ...
-                                    allThreadsStopped: true
-            end
-          end
+        if req.dig('arguments', 'nonstop') == true
+          @nonstop = true
+        else
+          @nonstop = false
+        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
+        load_extensions req
 
-        when 'setFunctionBreakpoints'
-          send_response req
+      when 'configurationDone'
+        send_response req
 
-        when 'setExceptionBreakpoints'
-          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,
-              }
-            }
+        if @nonstop
+          @q_msg << 'continue'
+        else
+          if SESSION.in_subsession?
+            send_event 'stopped', reason: 'pause',
+                                  threadId: 1, # maybe ...
+                                  allThreadsStopped: true
+          end
+        end
 
-            SESSION.clear_catch_breakpoints 'Exception', 'RuntimeError'
+      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
 
-            filters = args.fetch('filters').map {|filter_id|
-              process_filter.call(filter_id)
+      when 'setFunctionBreakpoints'
+        send_response req
+
+      when 'setExceptionBreakpoints'
+        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,
             }
+          }
+
+          SESSION.clear_catch_breakpoints 'Exception', 'RuntimeError'
 
-            filters += args.fetch('filterOptions', {}).map{|bp_info|
-            process_filter.call(bp_info['filterId'], bp_info['condition'])
+          filters = args.fetch('filters').map {|filter_id|
+            process_filter.call(filter_id)
           }
 
-          send_response req, breakpoints: filters
+          filters += args.fetch('filterOptions', {}).map{|bp_info|
+          process_filter.call(bp_info['filterId'], bp_info['condition'])
+        }
 
-        when 'disconnect'
-          terminate = args.fetch("terminateDebuggee", false)
+        send_response req, breakpoints: filters
 
-          SESSION.clear_all_breakpoints
-          send_response req
+      when 'disconnect'
+        terminate = args.fetch("terminateDebuggee", false)
 
-          if SESSION.in_subsession?
-            if terminate
-              @q_msg << 'kill!'
-            else
-              @q_msg << 'continue'
-            end
-          else
-            if terminate
-              @q_msg << 'kill!'
-              pause
-            end
-          end
+        SESSION.clear_all_breakpoints
+        send_response req
 
-        ## control
-        when 'continue'
-          @q_msg << 'c'
-          send_response req, allThreadsContinued: true
-        when 'next'
-          begin
-            @session.check_postmortem
-            @q_msg << 'n'
-            send_response req
-          rescue PostmortemError
-            send_response req,
-                          success: false, message: 'postmortem mode',
-                          result: "'Next' is not supported while postmortem mode"
-          end
-        when 'stepIn'
-          begin
-            @session.check_postmortem
-            @q_msg << 's'
-            send_response req
-          rescue PostmortemError
-            send_response req,
-                          success: false, message: 'postmortem mode',
-                          result: "'stepIn' is not supported while postmortem mode"
+        if SESSION.in_subsession?
+          if terminate
+            @q_msg << 'kill!'
+          else
+            @q_msg << 'continue'
           end
-        when 'stepOut'
-          begin
-            @session.check_postmortem
-            @q_msg << 'fin'
-            send_response req
-          rescue PostmortemError
-            send_response req,
-                          success: false, message: 'postmortem mode',
-                          result: "'stepOut' is not supported while postmortem mode"
+        else
+          if terminate
+            @q_msg << 'kill!'
+            pause
           end
-        when 'terminate'
+        end
+
+      ## control
+      when 'continue'
+        @q_msg << 'c'
+        send_response req, allThreadsContinued: true
+      when 'next'
+        begin
+          @session.check_postmortem
+          @q_msg << 'n'
           send_response req
-          exit
-        when 'pause'
+        rescue PostmortemError
+          send_response req,
+                        success: false, message: 'postmortem mode',
+                        result: "'Next' is not supported while postmortem mode"
+        end
+      when 'stepIn'
+        begin
+          @session.check_postmortem
+          @q_msg << 's'
           send_response req
-          Process.kill(UI_ServerBase::TRAP_SIGNAL, Process.pid)
-        when 'reverseContinue'
+        rescue PostmortemError
           send_response req,
-                        success: false, message: 'cancelled',
-                        result: "Reverse Continue is not supported. Only \"Step back\" is supported."
-        when 'stepBack'
-          @q_msg << req
+                        success: false, message: 'postmortem mode',
+                        result: "'stepIn' is not supported while postmortem mode"
+        end
+      when 'stepOut'
+        begin
+          @session.check_postmortem
+          @q_msg << 'fin'
+          send_response req
+        rescue PostmortemError
+          send_response req,
+                        success: false, message: 'postmortem mode',
+                        result: "'stepOut' is not supported while postmortem mode"
+        end
+      when 'terminate'
+        send_response req
+        exit
+      when 'pause'
+        send_response req
+        Process.kill(UI_ServerBase::TRAP_SIGNAL, Process.pid)
+      when 'reverseContinue'
+        send_response req,
+                      success: false, message: 'cancelled',
+                      result: "Reverse Continue is not supported. Only \"Step back\" is supported."
+      when 'stepBack'
+        @q_msg << req
 
-        ## query
-        when 'threads'
-          send_response req, threads: SESSION.managed_thread_clients.map{|tc|
-            { id: tc.id,
-              name: tc.name,
-            }
+      ## query
+      when 'threads'
+        send_response req, threads: SESSION.managed_thread_clients.map{|tc|
+          { id: tc.id,
+            name: tc.name,
           }
+        }
 
-        when 'evaluate'
-          expr = req.dig('arguments', 'expression')
-          if /\A\s*,(.+)\z/ =~ expr
-            dbg_expr = $1.strip
-            dbg_expr.split(';;') { |cmd| @q_msg << cmd }
+      when 'evaluate'
+        expr = req.dig('arguments', 'expression')
+        if /\A\s*,(.+)\z/ =~ expr
+          dbg_expr = $1.strip
+          dbg_expr.split(';;') { |cmd| @q_msg << cmd }
 
-            send_response req,
-                          result: "(rdbg:command) #{dbg_expr}",
-                          variablesReference: 0
-          else
-            @q_msg << req
-          end
-        when 'stackTrace',
-             'scopes',
-             'variables',
-             'source',
-             'completions'
+          send_response req,
+                        result: "(rdbg:command) #{dbg_expr}",
+                        variablesReference: 0
+        else
           @q_msg << req
+        end
+      when 'stackTrace',
+           'scopes',
+           'variables',
+           'source',
+           'completions'
+        @q_msg << req
 
+      else
+        if respond_to? mid = "custom_dap_request_#{req['command']}"
+          __send__ mid, req
         else
-          if respond_to? mid = "custom_dap_request_#{req['command']}"
-            __send__ mid, req
-          else
-            raise "Unknown request: #{req.inspect}"
-          end
+          raise "Unknown request: #{req.inspect}"
         end
       end
-    ensure
-      send_event :terminated unless @sock.closed?
     end
 
     ## called by the SESSION thread
@@ -625,6 +652,7 @@ module DEBUGGER__
           expr = req.dig('arguments', 'expression')
 
           if find_waiting_tc(tid)
+            restart_all_threads
             request_tc [:dap, :evaluate, req, fid, expr, context]
           else
             fail_response req
@@ -701,6 +729,7 @@ module DEBUGGER__
         register_vars result[:variables], tid
         @ui.respond req, result
       when :evaluate
+        stop_all_threads
         message = result.delete :message
         if message
           @ui.respond req, success: false, message: message
@@ -867,7 +896,7 @@ module DEBUGGER__
               }
             when String
               vars = [
-                variable('#lengthddsfsd', obj.length),
+                variable('#length', obj.length),
                 variable('#encoding', obj.encoding),
               ]
               printed_str = value_inspect(obj)
@@ -1014,7 +1043,7 @@ module DEBUGGER__
       klass = M_CLASS.bind_call(obj)
 
       begin
-        klass.name || klass.to_s
+        M_NAME.bind_call(klass) || klass.to_s
       rescue Exception => e
         "<Error: #{e.message} (#{e.backtrace.first}>"
       end

data/lib/debug/session.rb

@@ -1993,6 +1993,13 @@ module DEBUGGER__
     def after_fork_parent
       @ui.after_fork_parent
     end
+
+    # experimental API
+    def extend_feature session: nil, thread_client: nil, ui: nil
+      Session.include session if session
+      ThreadClient.include thread_client if thread_client
+      @ui.extend ui if ui
+    end
   end
 
   class ProcessGroup
@@ -2517,7 +2524,17 @@ module DEBUGGER__
 
   module TrapInterceptor
     def trap sig, *command, &command_proc
-      case sig&.to_sym
+      sym =
+        case sig
+        when String
+          sig.to_sym
+        when Integer
+          Signal.signame(sig)&.to_sym
+        else
+          sig
+        end
+
+      case sig&.to_s&.to_sym
       when :INT, :SIGINT
         if defined?(SESSION) && SESSION.active? && SESSION.intercept_trap_sigint?
           return SESSION.save_int_trap(command.empty? ? command_proc : command.first)

data/lib/debug/thread_client.rb

@@ -14,6 +14,7 @@ module DEBUGGER__
   M_RESPOND_TO_P = method(:respond_to?).unbind
   M_METHOD = method(:method).unbind
   M_OBJECT_ID = method(:object_id).unbind
+  M_NAME = method(:name).unbind
 
   module SkipPathHelper
     def skip_path?(path)
@@ -468,10 +469,14 @@ module DEBUGGER__
       if file_lines = frame.file_lines
         frame_line = frame.location.lineno - 1
 
-        lines = file_lines.map.with_index do |e, i|
-          cur = i == frame_line ? '=>' : '  '
-          line = colorize_dim('%4d|' % (i+1))
-          "#{cur}#{line} #{e}"
+        if CONFIG[:no_lineno]
+          lines = file_lines
+        else
+          lines = file_lines.map.with_index do |e, i|
+            cur = i == frame_line ? '=>' : '  '
+            line = colorize_dim('%4d|' % (i+1))
+            "#{cur}#{line} #{e}"
+          end
         end
 
         unless start_line
@@ -607,12 +612,17 @@ module DEBUGGER__
 
     def get_consts expr = nil, only_self: false, &block
       if expr && !expr.empty?
-        _self = frame_eval(expr)
-        if M_KIND_OF_P.bind_call(_self, Module)
-          iter_consts _self, &block
-          return
+        begin
+          _self = frame_eval(expr, re_raise: true)
+        rescue Exception => e
+          # ignore
         else
-          raise "#{_self.inspect} (by #{expr}) is not a Module."
+          if M_KIND_OF_P.bind_call(_self, Module)
+            iter_consts _self, &block
+            return
+          else
+            puts "#{_self.inspect} (by #{expr}) is not a Module."
+          end
         end
       elsif _self = current_frame&.self
         cs = {}
@@ -1300,10 +1310,14 @@ module DEBUGGER__
               frame._callee = b.eval('__callee__')
             end
           }
-          @log << frames
+          append(frames)
         }
       end
 
+      def append frames
+        @log << frames
+      end
+
       def enable
         unless @tp_recorder.enabled?
           @log.clear

data/lib/debug/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: debug
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.8.0
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-28 00:00:00.000000000 Z
+date: 2023-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -66,6 +66,7 @@ files:
 - lib/debug/color.rb
 - lib/debug/config.rb
 - lib/debug/console.rb
+- lib/debug/dap_custom/traceInspector.rb
 - lib/debug/frame_info.rb
 - lib/debug/local.rb
 - lib/debug/open.rb