byebug-dap 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdcb974e222d9a64fea6f7f070e0352dc746dfd6f331d4b7230aad278ba563db
-  data.tar.gz: 91af303a92685b001c2fee3039f47cba119b67f3edefdeb11b9f28d54d6e2608
+  metadata.gz: 18d52dd5f136afc3350836a23abe3c9b957646358a566e15bfac0aedd070189c
+  data.tar.gz: 615c83e3512cc884f1d9dd2661b578cdf4314ebe2f3bab55f4c76f70a7fb17fc
 SHA512:
-  metadata.gz: c29328a148dc9e690452fdb09acbb5f63a6612a85f1e5c5cfa7a14b72ed5517b99d0fca4077ca3001d9d4cfbe0b25afa9f3475d65d21ee01369cb623af8462a4
-  data.tar.gz: 79f5f2dcfb469ab62250543620473f34c9dce69204eef8bb27cfeb1b636041716effb1f1486cd50ebb1c72e2770b627be5361112e2e64a6b97fd4d93fa9768d4
+  metadata.gz: f5932e26ae7fe7f9518e35df4a22aad7cb363f57d56680e8416e2f6dfa3aed447b7a38270e752313b08a7244108a13f64daee74b58d715ce333b95e4230abbf8
+  data.tar.gz: 4e150cd4ba325258f41d91496ab6d6914294d15330a124c1501ec50b28991a8619d49be3420d4f22305c5067c5d42de167a62dbf2a919b501af9dcb75c18f6f1

data/CHANGELOG.md

@@ -1,13 +1,24 @@
 # Change Log
 
+## 0.1.3
+
+- Support for output capture
+- Support for setting function breakpoints
+- Support for breakpoint locations request
+- Support for delayed stack trace loading
+- Basic support for exception breakpoints
+- Support for conditional breakpoints
+- Support for hit conditional breakpoints
+- Support for logpoints
+
 ## 0.1.2
 
 - Fix possible failure when a breakpoint is hit but can't be resolved
 - Fix possible failure when frame arguments can't be evaluated
 - Exit on disconnect when started by 'launch'
-- Expose `Server#wait_for_client` instead of passing a block
-- Expose `Interface#stop!` to allow the debugee to stop
-- Support specifying a start sequence with `--on-start CODE`
+- Expose `Byebug::DAP::Server#wait_for_client` instead of passing a block
+- Expose `Byebug::DAP#stop!` to allow the debugee to stop
+- Support for specifying a start sequence with `--on-start CODE`
 - Support for child processes
 
 ## 0.1.1

data/README.md

@@ -5,8 +5,8 @@ Protocol](https://microsoft.github.io/debug-adapter-protocol) support to Byebug.
 
 ## TODO
 
-- Multi-process support
-- Stdout/stderr
-  - In STDIO mode, spawn with extra FDs and use those instead of 0/1?
-- Many DAP features are already supported by Byebug and just need to be
-  implemented in DAP mode
+- In STDIO mode, spawn with extra FDs and use those instead of 0/1?
+- Set class-only or instance-only method breakpoints. Blocked by
+  [byebug#734](https://github.com/deivid-rodriguez/byebug/issues/734).
+- Support advanced exception breakpoints. Requires client support (VSCode
+  extension).

data/bin/byebug-dap

@@ -11,14 +11,20 @@ def next_arg
   arg = ARGV.pop
   return arg if arg
 
-  STDERR.puts USAGE
+  LOG.puts USAGE
   exit!
 end
 
 options = {}
+
 OptionParser.new do |opts|
   opts.banner = USAGE
 
+  opts.on("--version", "Print version information") do |v|
+    puts "#{Byebug::DAP::NAME} #{Byebug::DAP::VERSION}"
+    exit
+  end
+
   opts.on("--stdio", "Listen on STDIN and STDOUT") { |v| options[:stdio] = v }
   opts.on("--listen PORT", "Listen on a TCP port") { |v| options[:listen] = v }
   opts.on("--unix SOCKET", "Listen on a unix socket") { |v| options[:unix] = v }
@@ -27,8 +33,14 @@ OptionParser.new do |opts|
   opts.on("--debug-protocol", "Debug DAP") { |v| Byebug::DAP::Debug.protocol = true if v }
   opts.on("--debug-evaluate", "Debug variable evaluation") { |v| Byebug::DAP::Debug.evaluate = true if v }
   opts.on("--on-start CODE", "Code to print once the debugger is available") { |v| options[:start_code] = v }
+  opts.on("--capture-output", "Capture stdout and stderr") { |v| options[:capture_output] = v }
+  opts.on("--supress-output", "Supress stdout and stderr when capturing") { |v| options[:suppress_output] = v }
+
+  opts.on("--log FD", "Log to the specified file descriptor") { |v| Kernel::LOG = IO.new(v.to_i) }
 end.parse!
 
+Kernel::LOG = STDERR.dup unless defined?(Kernel::LOG)
+
 program = next_arg
 if program == '-'
   program = next_arg
@@ -55,27 +67,32 @@ elsif options[:unix]
   end
 
 else
-  STDERR.puts USAGE, "One of --stdio, --listen, or --unix is required"
+  LOG.puts USAGE, "One of --stdio, --listen, or --unix is required"
   exit!
 end
 
 begin
-  STDERR.print "Starting DAP... " unless options[:start_code]
+  LOG.print "Starting DAP... " unless options[:start_code]
 
-  server = Byebug.start_dap(host, port)
+  server = Byebug::DAP::Server.new(capture: options[:capture_output], forward: !options[:suppress_output])
+  server.start(host, port)
 
-  STDERR.puts options[:start_code] if options[:start_code]
-  STDERR.flush
+  LOG.puts options[:start_code] if options[:start_code]
 
   if options[:wait]
-    STDERR.print "waiting for debugger... " unless options[:start_code]
+    LOG.print "waiting for debugger... " unless options[:start_code]
+    hINT = Signal.trap("INT") { LOG.puts; exit }
     server.wait_for_client
+    Signal.trap("INT", hINT)
   end
 
-  STDERR.puts "ok" unless options[:start_code]
+  LOG.puts "ok" unless options[:start_code]
 
   require File.realpath(program)
 
+rescue => e
+  LOG.puts "#{e.message} (#{e.class.name})", *e.backtrace
+
 ensure
   File.delete(port) if File.exist?(port) if host == :unix
 end

data/lib/byebug/dap.rb

@@ -3,32 +3,62 @@ require 'byebug'
 require 'byebug/core'
 require 'byebug/remote'
 
-require_relative 'dap/channel'
-require_relative 'dap/child_spawned_event_body'
-require_relative 'dap/handles'
-require_relative 'dap/invalid_request_argument_error'
-require_relative 'dap/safe_helpers'
+require_relative 'gem'
 
-require_relative 'dap/server'
+# load helpers
+Dir[File.join(__dir__, 'dap', 'helpers', '*.rb')].each { |file| require file }
+
+# load command base classes
+require_relative 'dap/command'
+require_relative 'dap/contextual_command'
+
+# load commands
+Dir[File.join(__dir__, 'dap', 'commands', '*.rb')].each { |file| require file }
+
+# load everything else
 require_relative 'dap/command_processor'
-require_relative 'dap/controller'
-require_relative 'dap/interface'
+require_relative 'dap/session'
+require_relative 'dap/server'
 
 module Byebug
-  module DAP
-    module Debug
-      class << self
-        @protocol = false
-        @evaluate = false
-
-        attr_accessor :protocol, :evaluate
-      end
+  class << self
+    def start_dap(host, port = 0, &block)
+      DAP::Server.new(&block).start(host, port)
     end
   end
 
+  class Context
+    public :processor
+  end
+
+  class Frame
+    attr_reader :context
+  end
+end
+
+module Byebug::DAP
+  Protocol = ::DAP
+
   class << self
-    def start_dap(host, port = 0, &block)
-      DAP::Server.new(&block).start(host, port)
+    def child_spawned(*args)
+      Session.child_spawned(*args)
+    end
+
+    def stop!
+      interface = Byebug::Context.interface
+      return false unless interface.is_a?(Session)
+
+      interface.stop!
+      true
     end
   end
 end
+
+module Byebug::DAP::Debug
+  class << self
+    @protocol = false
+    @evaluate = false
+
+    attr_accessor :protocol, :evaluate
+  end
+end

data/lib/byebug/dap/command.rb

@@ -0,0 +1,250 @@
+module Byebug::DAP
+  class Command
+    EVAL_ERROR = "*Error in evaluation*"
+
+    include SafeHelpers
+
+    def self.command
+      return @command_name if defined?(@command_name)
+
+      raise "Not a command" if self == Byebug::DAP::Command
+      raise "Not a command" unless self < Byebug::DAP::Command
+      raise "Not a command" unless self.name.start_with?('Byebug::DAP::Command::')
+
+      last = self.name.split('::').last
+      @command_name = "#{last[0].downcase}#{last[1..]}"
+    end
+
+    def self.register!
+      (@@commands ||= {})[command] = self
+    end
+
+    def self.resolve!(session, request)
+      cls = @@commands[request.command]
+      return cls if cls
+
+      session.respond! request, success: false, message: 'Invalid command'
+    end
+
+    def self.execute(session, request, *args)
+      return unless command = resolve!(session, request)
+
+      command.new(session, request, *args).safe_execute
+    end
+
+    def initialize(session, request)
+      @session = session
+      @request = request
+    end
+
+    def log(*args)
+      @session.log(*args)
+    end
+
+    def safe_execute
+      execute
+
+    rescue InvalidRequestArgumentError => e
+      message =
+        case e.error
+        when String
+          e.error
+
+        when :missing_argument
+          "Argument is unspecified: #{e.scope}"
+
+        when :missing_entry
+          "Cannot locate #{e.scope} ##{e.value}"
+
+        when :invalid_entry
+          "Error resolving #{e.scope}: #{e.value}"
+
+        else
+          log "#{e.message} (#{e.class})", *e.backtrace
+          "An internal error occured"
+        end
+
+      respond! success: false, message: message
+
+    rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+      :disconnected
+
+    rescue CommandProcessor::TimeoutError => e
+      respond! success: false, message: "Debugger on thread ##{e.context.thnum} is not responding"
+
+    rescue StandardError => e
+      respond! success: false, message: "An internal error occured"
+      log "#{e.message} (#{e.class})", *e.backtrace
+    end
+
+    private
+
+    def event!(*args, **values)
+      @session.event! *args, **values
+      return
+    end
+
+    def respond!(*args, **values)
+      raise "Cannot respond without a request" unless @request
+
+      @session.respond! @request, *args, **values
+      return
+    end
+
+    def stopped!
+      return if !Byebug.started?
+
+      respond! success: false, message: "Cannot #{@request.command} - debugger is already running"
+    end
+
+    def started!
+      return if Byebug.started?
+
+      respond! success: false, message: "Cannot #{@request.command} - debugger is not running"
+    end
+
+    def args
+      @request.arguments
+    end
+
+    def exception_description(ex)
+      safe(-> { "#{ex.message} (#{ex.class.name})" }, :call) { EVAL_ERROR }
+    end
+
+    def execute_on_thread(thnum, block, &on_error)
+      return safe(block, :call, &on_error) if thnum == 0 || @context&.thnum == thnum
+
+      p = find_thread(thnum).processor
+      safe(-> { p.execute(&block) }, :call, &on_error)
+    end
+
+    def find_thread(thnum)
+      raise InvalidRequestArgumentError.new(:missing_argument, scope: 'thread ID') unless thnum
+
+      ctx = Byebug.contexts.find { |c| c.thnum == thnum }
+      raise InvalidRequestArgumentError.new(:missing_entry, value: thnum, scope: 'thread') unless ctx
+
+      ctx
+    end
+
+    def find_frame(ctx, frnum)
+      raise InvalidRequestArgumentError.new(:missing_entry, value: frnum, scope: 'frame') unless frnum < ctx.stack_size
+
+      ::Byebug::Frame.new(ctx, frnum)
+    end
+
+    def resolve_frame_id(id)
+      raise InvalidRequestArgumentError.new(:missing_argument, scope: 'frame ID') unless id
+
+      entry = @session.restore_frame(id)
+      raise InvalidRequestArgumentError.new(:missing_entry, value: id, scope: 'frame ID') unless entry
+
+      thnum, frnum = entry
+      ctx = find_thread(thnum)
+      frame = find_frame(ctx, frnum)
+      return frame, thnum, frnum
+    end
+
+    def resolve_variables_reference(ref)
+      raise InvalidRequestArgumentError.new(:missing_argument, scope: 'variables reference') unless ref
+
+      entry = @session.restore_variables(ref)
+      raise InvalidRequestArgumentError.new(:missing_entry, value: ref, scope: 'variables reference') unless entry
+
+      thnum, frnum, kind, *entry = entry
+
+      case kind
+      when :locals
+        frame = find_frame(find_thread(thnum), frnum)
+        named, indexed = entry[0], []
+        get = ->(key) {
+          return frame._self if key == :self
+          return frame.context.processor.last_exception if key == :$!
+          values ||= frame.locals
+          values[key]
+        }
+
+      when :globals
+        frame = find_frame(find_thread(thnum), frnum)
+        named, indexed = entry[0], []
+        get = ->(key) { frame._binding.eval(key.to_s) }
+
+      when :variable, :evaluate
+        value, named, indexed = entry
+        get = ->(key) { value.instance_eval { binding }.eval(key.to_s) }
+        index = ->(key) { value[key] }
+
+      else
+        raise InvalidRequestArgumentError.new(:invalid_entry, value: kind, scope: 'variable scope')
+      end
+
+      return thnum, frnum, named.map { |k| [k, get] }, indexed.map { |k| [k, index] }
+    end
+
+    def can_read_file!(path)
+      path = File.realpath(path)
+      return path if File.readable?(path)
+
+      if File.exist?(path)
+        respond! success: false, message: "Source file '#{path}' exists but cannot be read"
+      else
+        respond! success: false, message: "No source file available for '#{path}'"
+      end
+
+      return nil
+    end
+
+    def potential_breakpoint_lines(path)
+      ::Byebug::Breakpoint.potential_lines(path)
+    rescue ScriptError, StandardError => e
+      yield(e)
+    end
+
+    def convert_breakpoint_condition(condition)
+      return nil if condition.nil? || condition.empty?
+      return nil unless condition.is_a?(String)
+      return condition
+    end
+
+    def convert_breakpoint_hit_condition(condition)
+      return nil if condition.nil? || condition.empty?
+      return nil unless condition.is_a?(String)
+
+      m = /^(?<op><|<=|=|==|===|=>|>|%)?\s*(?<value>[0-9]+)$/.match(condition)
+      raise InvalidRequestArgumentError.new("'#{condition}' is not a valid hit condition") unless m
+
+      v = m[:value].to_i
+      case m[:op]
+      when nil, '=', '==', '==='
+        return :eq, v
+
+      when '>'
+        return :ge, v - 1
+
+      when '>='
+        return :ge, v
+
+      when '%'
+        return :mod, v
+
+      else
+        raise InvalidRequestArgumentError.new("Byebug does not support hit conditions using '#{m[:op]}'") unless m
+      end
+    end
+
+    def find_or_add_breakpoint(verified, existing, source, pos)
+      if bp = verified.find { |bp| bp.source == source && bp.pos == pos }
+        return bp
+      end
+
+      if bp = existing.find { |bp| bp.source == source && bp.pos == pos }
+        existing.delete(bp)
+      else
+        bp = Byebug::Breakpoint.add(source, pos.is_a?(String) ? pos.to_sym : pos)
+      end
+
+      verified << bp
+      bp
+    end
+  end
+end