debug 1.7.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a84e87e9582c98cf24ca8aa9f1f30032c10736bf4dbc1c44da016db564a7a574
-  data.tar.gz: da093ef6ebfd8fc5e4a10fcc39c59826e45829ec09da0d9dc164b9cd71085286
+  metadata.gz: 39fceaae982c712433b6bf0bc855328c5d923524658a399926e7a032f5d7cdbf
+  data.tar.gz: 4f80f39348e0cd46882bd54e04398342c3d124133aa15edcc57a18f1a20fe449
 SHA512:
-  metadata.gz: d663b6db0dba8921aaaa535f834e768367e07fef03613e6a277a27724fb75ecf830c7557465521998d42cbb41744e6335495958f626285468d6e38ae6ec52515
-  data.tar.gz: cb24e62c5875c069812ff1b056dda3b912a20069d09123b72dbd0da69e61aed66968bc4dc5f80e9b599df743fb7755a2399f1461f344fc43ed9ea6bbf20f251c
+  metadata.gz: 67a369a45e2debb29dbb42fcbc32d36e1c40467249d657f45caa8a04a5fb3521a10c91860a3f3407caaa8f97cf81ad35f8a3e5ac83a124b99811d82363afe2cf
+  data.tar.gz: b29458d948196114b7cb5c7c182decca2685495b96707d904674714a2256a46bd0244efdde5d1ada8a460d881dff7ad4acafaa2c433c6e0eddbcf928425f6748

data/CONTRIBUTING.md

@@ -149,10 +149,10 @@ If the file already exists, **only method** will be added to it.
 ```ruby
 # frozen_string_literal: true
 
-require_relative '../support/test_case'
+require_relative '../support/console_test_case'
 
 module DEBUGGER__
-  class FooTest < TestCase
+  class FooTest < ConsoleTestCase
     def program
       <<~RUBY
         1| module Foo

data/README.md

@@ -26,7 +26,7 @@ New debug.rb has several advantages:
   * Support threads (almost done) and ractors (TODO).
   * Support suspending and entering to the console debugging with `Ctrl-C` at most of timing.
   * Show parameters on backtrace command.
-  * Support recording & reply debugging.
+  * Support recording & replay debugging.
 
 # Installation
 
@@ -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
@@ -563,9 +564,9 @@ The `<...>` notation means the argument.
 * `u[ntil]`
   * Similar to `next` command, but only stop later lines or the end of the current frame.
   * Similar to gdb's `advance` command.
-* `u[ntil] <[file:]line>
+* `u[ntil] <[file:]line>`
   * Run til the program reaches given location or the end of the current frame.
-* `u[ntil] <name>
+* `u[ntil] <name>`
   * Run til the program invokes a method `<name>`. `<name>` can be a regexp with `/name/`.
 * `c` or `cont` or `continue`
   * Resume the program.
@@ -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/Rakefile

@@ -35,9 +35,14 @@ task :check_readme do
   end
 end
 
+desc "Run debug.gem test-framework tests"
+Rake::TestTask.new(:test_test) do |t|
+  t.test_files = FileList["test/support/*_test.rb"]
+end
+
 desc "Run all debugger console related tests"
 Rake::TestTask.new(:test_console) do |t|
-  t.test_files = FileList["test/console/*_test.rb", "test/support/*_test.rb"]
+  t.test_files = FileList["test/console/*_test.rb"]
 end
 
 desc "Run all debugger protocols (CAP & DAP) related tests"
@@ -46,7 +51,7 @@ Rake::TestTask.new(:test_protocol) do |t|
 end
 
 task test: 'test_console' do
-  warn '`rake test` doesn\'t run protocol tests. Use `rake test-all` to test all.'
+  warn '`rake test` doesn\'t run protocol tests. Use `rake test_all` to test all.'
 end
 
-task test_all: [:test_console, :test_protocol]
+task test_all: [:test_test, :test_console, :test_protocol]

data/lib/debug/breakpoint.rb

@@ -101,10 +101,6 @@ module DEBUGGER__
     def generate_label(name)
       colorize(" BP - #{name} ", [:YELLOW, :BOLD, :REVERSE])
     end
-
-    def pending_until_load?
-      false
-    end
   end
 
   if RUBY_VERSION.to_f <= 2.7
@@ -163,10 +159,6 @@ module DEBUGGER__
       @pending = !@iseq
     end
 
-    def pending_until_load?
-      @pending
-    end
-
     def setup
       return unless @type
 
@@ -207,6 +199,8 @@ module DEBUGGER__
       if @pending && !@oneshot
         DEBUGGER__.info "#{self} is activated."
       end
+
+      @pending = false
     end
 
     def activate_exact iseq, events, line
@@ -299,6 +293,10 @@ module DEBUGGER__
     def inspect
       "<#{self.class.name} #{self.to_s}>"
     end
+
+    def path_is? path
+      DEBUGGER__.compare_path(@path, path)
+    end
   end
 
   class CatchBreakpoint < Breakpoint

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],
@@ -265,6 +266,8 @@ module DEBUGGER__
       require 'optparse'
       require_relative 'version'
 
+      have_shown_version = false
+
       opt = OptionParser.new do |o|
         o.banner = "#{$0} [options] -- [debuggee options]"
         o.separator ''
@@ -372,6 +375,16 @@ module DEBUGGER__
         o.separator ''
         o.separator 'Other options:'
 
+        o.on('-v', 'Show version number') do
+          puts o.ver
+          have_shown_version = true
+        end
+
+        o.on('--version', 'Show version number and exit') do
+          puts o.ver
+          exit
+        end
+
         o.on("-h", "--help", "Print help") do
           puts o
           exit
@@ -395,6 +408,14 @@ module DEBUGGER__
 
       opt.parse!(argv)
 
+      if argv.empty?
+        case
+        when have_shown_version && config[:mode] == :start
+          pp config
+          exit
+        end
+      end
+
       config
     end
 
@@ -425,8 +446,9 @@ module DEBUGGER__
     unless (dir_uid = fs.uid) == (uid = Process.uid)
       raise "#{path} uid is #{dir_uid}, but Process.uid is #{uid}"
     end
-    unless (dir_mode = fs.mode) == 040700 # 4: dir, 7:rwx
-      raise "#{path}'s mode is #{dir_mode.to_s(8)} (should be 040700)"
+
+    if fs.world_writable? && !fs.sticky?
+      raise "#{path} is world writable but not sticky"
     end
 
     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.rb

@@ -406,14 +406,13 @@ module DEBUGGER__
       require_relative 'server_cdp'
 
       @uuid = SecureRandom.uuid
-      unless @chrome_pid = UI_CDP.setup_chrome(@local_addr.inspect_sockaddr, @uuid)
-        DEBUGGER__.warn <<~EOS
-          With Chrome browser, type the following URL in the address-bar:
+      @chrome_pid = UI_CDP.setup_chrome(@local_addr.inspect_sockaddr, @uuid)
+      DEBUGGER__.warn <<~EOS
+        With Chrome browser, type the following URL in the address-bar:
 
-             devtools://devtools/bundled/inspector.html?v8only=true&panel=sources&ws=#{@local_addr.inspect_sockaddr}/#{@uuid}
+           devtools://devtools/bundled/inspector.html?v8only=true&panel=sources&ws=#{@local_addr.inspect_sockaddr}/#{@uuid}
 
-          EOS
-      end
+        EOS
     end
 
     def accept