byebug-dap 0.1.2 → 0.1.3

data/lib/byebug/dap/commands/set_breakpoints.rb

@@ -0,0 +1,48 @@
+module Byebug::DAP
+  class Command::SetBreakpoints < Command
+    # "Sets multiple breakpoints for a single source and clears all previous breakpoints in that source.
+    # "To clear all breakpoint for a source, specify an empty array.
+    # "When a breakpoint is hit, a ‘stopped’ event (with reason ‘breakpoint’) is generated.
+
+    register!
+
+    def execute
+      return unless path = can_read_file!(args.source.path)
+      if args.lines.empty? && args.breakpoints.empty?
+        Byebug.breakpoints.reject! { |bp| bp.source == path }
+        respond! body: { breakpoints: [] }
+        return
+      end
+
+      existing = Byebug.breakpoints.filter { |bp| bp.source == path }
+      verified = []
+      lines = potential_breakpoint_lines(path) { |e|
+        respond! success: false, message: "Failed to resolve breakpoints for #{path}"
+        return
+      }
+
+      (args.lines & lines).each do |l|
+        find_or_add_breakpoint(verified, existing, path, l)
+      end
+
+      args.breakpoints.filter { |rq| lines.include?(rq.line) }.each do |rq|
+        bp = find_or_add_breakpoint(verified, existing, path, rq.line)
+        bp.expr = convert_breakpoint_condition(rq.condition)
+        bp.hit_condition, bp.hit_value = convert_breakpoint_hit_condition(rq.hitCondition)
+        @session.set_log_point(bp, rq.logMessage)
+      end
+
+      @session.clear_breakpoints(*existing)
+
+      respond! body: {
+        breakpoints: verified.map { |bp|
+          {
+            id: bp.id,
+            line: bp.pos,
+            verified: true,
+          }
+        }
+      }
+    end
+  end
+end

data/lib/byebug/dap/commands/set_exception_breakpoints.rb

@@ -0,0 +1,28 @@
+module Byebug::DAP
+  class Command::SetExceptionBreakpoints < Command
+    # "The request configures the debuggers response to thrown exceptions.
+    # "If an exception is configured to break, a ‘stopped’ event is fired (with reason ‘exception’).
+
+    FILTERS = [
+      {
+        filter: 'all',
+        label: 'Exceptions',
+      },
+    ]
+
+    register!
+
+    def execute
+      Byebug.catchpoints.clear
+
+      args.filters.each do |f|
+        case f
+        when 'all'
+          Byebug.add_catchpoint('Exception')
+        end
+      end
+
+      respond!
+    end
+  end
+end

data/lib/byebug/dap/commands/set_function_breakpoints.rb

@@ -0,0 +1,96 @@
+module Byebug::DAP
+  class Command::SetFunctionBreakpoints < Command
+    # "Replaces all existing function breakpoints with new function breakpoints.
+    # "To clear all function breakpoints, specify an empty array.
+    # "When a function breakpoint is hit, a ‘stopped’ event (with reason ‘function breakpoint’) is generated.
+
+    register!
+
+    def execute
+      ::Byebug.breakpoints.each { |bp| ::Byebug::Breakpoint.remove(bp.id) if bp.pos.is_a?(String) }
+
+      existing = Byebug.breakpoints.filter { |bp| bp.pos.is_a?(String) }
+      verified = []
+      results = []
+
+      args.breakpoints.each do |rq|
+        m = /^(?<class>[:\w]+)(?<sep>\.|#)(?<method>\w+)$/.match(rq.name)
+        unless m
+          results << {
+            verified: false,
+            message: "'#{rq.name}' is not a valid method identifier",
+          }
+          next
+        end
+
+        bp = find_or_add_breakpoint(verified, existing, m[:class], m[:method])
+        bp.expr = convert_breakpoint_condition(rq.condition)
+        bp.hit_condition, bp.hit_value = convert_breakpoint_hit_condition(rq.hitCondition)
+      end
+
+      verified.each do |bp|
+        cm, im = resolve_method(bp.source, bp.pos)
+
+        if cm.nil? && im.nil?
+          results << {
+            id: bp.id,
+            verified: true
+          }
+        end
+
+        unless cm.nil?
+          results << {
+            id: bp.id,
+            verified: true,
+            source: ::DAP::Source.new(name: File.basename(cm[0]), path: cm[0]),
+            line: cm[1]
+          }
+        end
+
+        unless im.nil?
+          results << {
+            id: bp.id,
+            verified: true,
+            source: ::DAP::Source.new(name: File.basename(im[0]), path: im[0]),
+            line: im[1]
+          }
+        end
+      end
+
+      @session.clear_breakpoints(*existing)
+
+      respond! body: { breakpoints: results }
+    end
+
+    private
+
+    def resolve_method(class_name, method_name)
+      scope = Object
+      class_name.split('::').each do |n|
+        scope = scope.const_get(n)
+      rescue NameError
+        return nil
+      end
+
+      class_method =
+        begin
+          scope.method(method_name)&.source_location
+        rescue NameError
+          nil
+        end
+
+      instance_method =
+        begin
+          scope.instance_method(method_name)&.source_location
+        rescue NameError
+          nil
+        end
+
+      return class_method, instance_method
+
+    rescue StandardError => e
+      LOG.puts "#{e.message} (#{e.class.name})", *e.backtrace if Debug.evaluate
+      nil
+    end
+  end
+end

data/lib/byebug/dap/commands/source.rb

@@ -0,0 +1,12 @@
+module Byebug::DAP
+  class Command::Source < Command
+    # "The request retrieves the source code for a given source reference.
+
+    register!
+
+    def execute
+      return unless path = can_read_file!(args.source.path)
+      respond! body: { content: IO.read(path) }
+    end
+  end
+end

data/lib/byebug/dap/commands/stack_trace.rb

@@ -0,0 +1,50 @@
+module Byebug::DAP
+  class Command::StackTrace < Command
+    # "The request returns a stacktrace from the current execution state.
+
+    register!
+
+    def execute
+      started!
+
+      ctx = find_thread(args.threadId)
+
+      first = args.startFrame || 0
+      if !args.levels
+        last = ctx.stack_size
+      else
+        last = first + args.levels
+        if last > ctx.stack_size
+          last = ctx.stack_size
+        end
+      end
+
+      frames = (first...last).map do |i|
+        frame = ::Byebug::Frame.new(ctx, i)
+        {
+          id: @session.save_frame(ctx.thnum, i),
+          name: frame_name(frame),
+          source: {
+            name: File.basename(frame.file),
+            path: File.expand_path(frame.file),
+          },
+          line: frame.line,
+          column: 1,
+        }
+      end
+
+      respond! body: {
+        stackFrames: frames,
+        totalFrames: ctx.stack_size,
+      }
+    end
+
+    private
+
+    def frame_name(frame)
+      frame.deco_call
+    rescue
+      frame.deco_block + frame.deco_class + frame.deco_method + "(?)"
+    end
+  end
+end

data/lib/byebug/dap/commands/step_in.rb

@@ -0,0 +1,24 @@
+module Byebug::DAP
+  class Command::StepIn < ContextualCommand
+    # "The request starts the debuggee to step into a function/method if possible.
+    # "If it cannot step into a target, ‘stepIn’ behaves like ‘next’.
+    # "The debug adapter first sends the response and then a ‘stopped’ event (with reason ‘step’) after the step has completed.
+    # "If there are multiple function/method calls (or other targets) on the source line,
+    # "the optional argument ‘targetId’ can be used to control into which target the ‘stepIn’ should occur.
+    # "The list of possible targets for a given source line can be retrieved via the ‘stepInTargets’ request.
+
+    register!
+
+    def execute_in_context
+      @context.step_into(1, @context.frame.pos)
+      :stop
+    end
+
+    private
+
+    def forward_to_context(ctx)
+      super
+      respond!
+    end
+  end
+end

data/lib/byebug/dap/commands/step_out.rb

@@ -0,0 +1,21 @@
+module Byebug::DAP
+  class Command::StepOut < ContextualCommand
+    # "The request starts the debuggee to run again for one step.
+    # "The debug adapter first sends the response and then a ‘stopped’ event (with reason ‘step’) after the step has completed.
+
+    register!
+
+    def execute_in_context
+      @context.step_out(@context.frame.pos + 1, false)
+      @context.frame = 0
+      :stop
+    end
+
+    private
+
+    def forward_to_context(ctx)
+      super
+      respond!
+    end
+  end
+end

data/lib/byebug/dap/commands/threads.rb

@@ -0,0 +1,20 @@
+module Byebug::DAP
+  class Command::Threads < Command
+    # "The request retrieves a list of all threads.
+
+    register!
+
+    def execute
+      started!
+
+      respond! body: ::DAP::ThreadsResponseBody.new(
+        threads: Byebug
+          .contexts
+          .filter { |ctx| !ctx.thread.is_a?(::Byebug::DebugThread) }
+          .map { |ctx| ::DAP::Thread.new(
+            id: ctx.thnum,
+            name: ctx.thread.name || "Thread ##{ctx.thnum}"
+          ).validate! })
+    end
+  end
+end

data/lib/byebug/dap/commands/variables.rb

@@ -0,0 +1,33 @@
+module Byebug::DAP
+  class Command::Variables < Command
+    # "Retrieves all child variables for the given variable reference.
+    # "An optional filter can be used to limit the fetched children to either named or indexed children
+
+    include ValueHelpers
+
+    register!
+
+    def execute
+      started!
+
+      thnum, frnum, named, indexed = resolve_variables_reference(args.variablesReference)
+
+      case args.filter
+      when 'named'
+        indexed = []
+      when 'indexed'
+        named = []
+      end
+
+      vars = named + indexed
+
+      first = args.start || 0
+      last = args.count ? first + args.count : vars.size
+      last = vars.size unless last < vars.size
+
+      variables = vars[first...last].map { |var, get| prepare_value_response(thnum, frnum, :variable, name: var) { get.call(var) } }
+
+      respond! body: ::DAP::VariablesResponseBody.new(variables: variables)
+    end
+  end
+end

data/lib/byebug/dap/contextual_command.rb

@@ -0,0 +1,30 @@
+module Byebug::DAP
+  class ContextualCommand < Command
+    def self.resolve!(session, request)
+      return unless cls = super
+      return cls if cls < ContextualCommand
+
+      raise "Not a contextual command: #{command}"
+    end
+
+    def initialize(session, request, processor = nil)
+      super(session, request)
+      @processor = processor
+      @context = processor&.context
+    end
+
+    def execute
+      return execute_in_context if @processor
+
+      started!
+
+      forward_to_context find_thread(args.threadId)
+    end
+
+    private
+
+    def forward_to_context(ctx)
+      ctx.processor << @request
+    end
+  end
+end

data/lib/byebug/dap/helpers/captured_io.rb

@@ -0,0 +1,65 @@
+module Byebug::DAP
+  class CapturedIO
+    def initialize(forward_stdout, forward_stderr)
+      @forward_stdout = forward_stdout
+      @forward_stderr = forward_stderr
+      @stdout = CapturedOutput.new STDOUT
+      @stderr = CapturedOutput.new STDERR
+      @stop = false
+
+      Byebug::DebugThread.new { capture }
+    end
+
+    def log
+      if defined?(LOG)
+        LOG
+      elsif @stderr
+        @stderr.original
+      else
+        STDERR
+      end
+    end
+
+    def restore
+      @stop = true
+      @stdout.restore
+      @stderr.restore
+    end
+
+    private
+
+    def capture
+      until @stop do
+        r, = IO.select([@stdout.captured, @stderr.captured])
+
+        r.each do |r|
+          case r
+          when @stdout.captured
+            b = @stdout.captured.read_nonblock(1024)
+            @stdout.original.write(b) if @forward_stdout
+            send(:stdout, b)
+
+          when @stderr.captured
+            b = @stderr.captured.read_nonblock(1024)
+            @stderr.original.write(b) if @forward_stderr
+            send(:stderr, b)
+          end
+        end
+      end
+
+    rescue EOFError, Errno::EBADF
+    rescue StandardError => e
+      log.puts "#{e.message} (#{e.class})", *e.backtrace
+    end
+
+    def send(source, data)
+      session = Byebug::Context.interface
+      return unless session.is_a?(Session)
+
+      session.event! 'output', category: source.to_s, output: data
+
+    rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+      # client disconnected
+    end
+  end
+end

data/lib/byebug/dap/helpers/captured_output.rb

@@ -0,0 +1,21 @@
+module Byebug::DAP
+  class CapturedOutput
+    attr_reader :original, :captured
+
+    def initialize(io)
+      @io = io
+      @original = io.dup
+      @captured, pw = IO.pipe
+
+      io.reopen(pw)
+      pw.close
+    end
+
+    def restore
+      @io.reopen(@original)
+      @original.close
+      @captured.close
+      return nil
+    end
+  end
+end