byebug-dap 0.1.2 → 0.1.3

data/lib/byebug/dap/command_processor.rb

@@ -12,16 +12,21 @@ module Byebug
         end
       end
 
-      attr_reader :context, :interface
+      attr_reader :context, :last_exception
+      attr_writer :pause_requested
 
-      def initialize(context, interface)
+      def initialize(context, session)
         @context = context
-        @interface = interface
+        @session = session
         @requests = Channel.new
         @exec_mu = Mutex.new
         @exec_ch = Channel.new
       end
 
+      def log(*args)
+        @session.log(*args)
+      end
+
       def <<(message)
         @requests.push(message, timeout: 1) { raise TimeoutError.new(context) }
       end
@@ -54,67 +59,61 @@ module Byebug
             next
           end
 
-          case request.command
-          when 'continue'
-            # "The request starts the debuggee to run again.
-
-            break
-
-          when 'pause'
-            # "The request suspends the debuggee.
-            # "The debug adapter first sends the response and then a ‘stopped’ event (with reason ‘pause’) after the thread has been paused successfully.
+          break if ContextualCommand.execute(@session, request, self) == :stop
+        end
 
-            @pause_requested = true
+        @last_exception = nil
+        @session.invalidate_handles!
 
-          when 'next'
-            # "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.
+      rescue StandardError => e
+        log "\n! #{e.message} (#{e.class})", *e.backtrace
+      end
 
-            context.step_over(1, context.frame.pos)
-            break
+      def logpoint!
+        return false unless @last_breakpoint
 
-          when 'stepIn'
-            # "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.
+        breakpoint, @last_breakpoint = @last_breakpoint, nil
+        expr = @session.get_log_point(breakpoint)
+        return false unless expr
 
-            context.step_into(1, context.frame.pos)
-            break
+        binding = @context.frame._binding
+        msg = expr.gsub(/\{([^\}]+)\}/) do |x|
+          safe(binding, :eval, x[1...-1]) { return true } # ignore bad log points
+        end
 
-          when 'stepOut'
-            # "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.
+        body = {
+          category: 'console',
+          output: msg + "\n",
+        }
 
-            context.step_out(context.frame.pos + 1, false)
-            context.frame = 0
-            break
-          end
+        if breakpoint.pos.is_a?(Integer)
+          body[:line] = breakpoint.pos
+          body[:source] = {
+            name: File.basename(breakpoint.source),
+            path: breakpoint.source,
+          }
         end
 
-        interface.invalidate_handles!
-
-      rescue StandardError => e
-        STDERR.puts "\n! #{e.message} (#{e.class})", *e.backtrace
+        @session.event! 'output', **body
+        return true
       end
 
       def stopped!
+        return if logpoint!
+
         case context.stop_reason
         when :breakpoint
           args = {
             reason: 'breakpoint',
             description: 'Hit breakpoint',
-            text: "Stopped by breakpoint at #{context.frame.file}:#{context.frame.line}",
+            text: "Hit breakpoint at #{context.location}",
           }
 
         when :catchpoint
-          # TODO this is probably not the right message
           args = {
-            reason: 'catchpoint',
+            reason: 'exception',
             description: 'Hit catchpoint',
-            text: "Stopped by catchpoint at #{context.location}: `#{@at_catchpoint}'",
+            text: "Hit catchpoint at #{context.location}",
           }
 
         when :step
@@ -122,20 +121,22 @@ module Byebug
             @pause_requested = false
             args = {
               reason: 'pause',
-              text: "Paused at #{context.frame.file}:#{context.frame.line}"
+              description: 'Paused',
+              text: "Paused at #{context.location}"
             }
           else
             args = {
               reason: 'step',
-              text: "Stepped at #{context.frame.file}:#{context.frame.line}"
+              description: 'Stepped',
+              text: "Stepped at #{context.location}"
             }
           end
 
         else
-          STDERR.puts "Stopped for unknown reason: #{context.stop_reason}"
+          log "Stopped for unknown reason: #{context.stop_reason}"
         end
 
-        interface.event! 'stopped', threadId: context.thnum, **args if args
+        @session.event! 'stopped', threadId: context.thnum, **args if args
 
         process_requests
       end
@@ -153,17 +154,17 @@ module Byebug
       end
 
       # def at_tracing
-      #   interface.puts "Tracing: #{context.full_location}"
+      #   @session.puts "Tracing: #{context.full_location}"
 
       #   # run_auto_cmds(2)
       # end
 
       def at_breakpoint(breakpoint)
-        @at_breakpoint = breakpoint
+        @last_breakpoint = breakpoint
       end
 
       def at_catchpoint(exception)
-        @at_catchpoint = exception
+        @last_exception = exception
       end
     end
   end

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

@@ -0,0 +1,13 @@
+module Byebug::DAP
+  class Command::Attach < Command
+    # "The attach request is sent from the client to the debug adapter to attach to a debuggee that is already running.
+
+    register!
+
+    def execute
+      stopped!
+      @session.start!(:attached)
+      respond!
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Byebug::DAP
+  class Command::BreakpointLocations < Command
+    # "The ‘breakpointLocations’ request returns all possible locations for source breakpoints in a given range.
+
+    register!
+
+    def execute
+      return unless path = can_read_file!(args.source.path)
+      lines = potential_breakpoint_lines(path) { |e|
+        respond! success: false, message: "Failed to resolve breakpoints for #{path}"
+        return
+      }
+
+      unless args.endLine
+        if lines.include?(args.line)
+          respond! body: { breakpoints: [{ line: args.line }] }
+        else
+          respond! body: { breakpoints: [] }
+        end
+        return
+      end
+
+      range = [args.line..args.endLine]
+      lines.filter! { |l| range.include?(l) }
+      respond! body: { breakpoints: lines.map { |l| { line: l } } }
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Byebug::DAP
+  class Command::ConfigurationDone < Command
+    # "This optional request indicates that the client has finished initialization of the debug adapter.
+
+    register!
+
+    def execute
+      respond!
+      @session.configured!
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Byebug::DAP
+  class Command::Continue < ContextualCommand
+    # "The request starts the debuggee to run again.
+
+    register!
+
+    def execute_in_context
+      :stop
+    end
+
+    private
+
+    def forward_to_context(ctx)
+      super
+      respond!
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Byebug::DAP
+  class Command::Disconnect < Command
+    # "The ‘disconnect’ request is sent from the client to the debug adapter in order to stop debugging.
+    # "It asks the debug adapter to disconnect from the debuggee and to terminate the debug adapter.
+    # "If the debuggee has been started with the ‘launch’ request, the ‘disconnect’ request terminates the debuggee.
+    # "If the ‘attach’ request was used to connect to the debuggee, ‘disconnect’ does not terminate the debuggee.
+    # "This behavior can be controlled with the ‘terminateDebuggee’ argument (if supported by the debug adapter).
+
+    register!
+
+    def execute
+      @session.stop!
+      respond!
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Byebug::DAP
+  class Command::Evaluate < Command
+    # "Evaluates the given expression in the context of the top most stack frame.
+    # "The expression has access to any variables and arguments that are in scope.
+
+    include ValueHelpers
+
+    register!
+
+    def execute
+      started!
+
+      respond! body: evaluate
+    end
+
+    private
+
+    def evaluate
+      return prepare_value_response(0, 0, :evaluate) { TOPLEVEL_BINDING.eval(args.expression) } unless args.frameId
+
+      frame, thnum, frnum = resolve_frame_id(args.frameId)
+      return unless frame
+
+      prepare_value_response(thnum, frnum, :evaluate) { frame._binding.eval(args.expression) }
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Byebug::DAP
+  class Command::ExceptionInfo < ContextualCommand
+    # "Retrieves the details of the exception that caused this event to be raised.
+
+    register!
+
+    def execute_in_context
+      unless ex = @processor.last_exception
+        respond! success: false, message: 'Not in a catchpoint context'
+        return
+      end
+
+      class_name = safe(ex, [:class, :name]) { "Unknown" }
+
+      respond! body: {
+        exceptionId: class_name,
+        description: exception_description(ex),
+        breakMode: ::DAP::ExceptionBreakMode::ALWAYS,
+        details: details(ex, '$!'),
+      }
+    end
+
+    private
+
+    def details(ex, eval_name)
+      class_name = safe(ex, [:class, :name]) { nil }
+      type_name = class_name.split('::').last if class_name
+      inner = safe(ex, :cause) { nil }
+
+      {
+        message: safe(ex, :message) { nil },
+        typeName: type_name,
+        fullTypeName: class_name,
+        evaluateName: eval_name,
+        stackTrace: safe(ex, :backtrace) { [] }.join("\n"),
+        innerException: inner.nil? ? [] : [details(inner, "#{eval_name}.#{cause}")],
+      }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Byebug::DAP
+  class Command::Initialize < Command
+    # "The ‘initialize’ request is sent as the first request from the client to the debug adapter
+    # "in order to configure it with client capabilities and to retrieve capabilities from the debug adapter.
+    # "Until the debug adapter has responded to with an ‘initialize’ response, the client must not send any additional requests or events to the debug adapter.
+    # "In addition the debug adapter is not allowed to send any requests or events to the client until it has responded with an ‘initialize’ response.
+    # "The ‘initialize’ request may only be sent once.
+
+    register!
+
+    def execute
+      respond! body: {
+        supportsConfigurationDoneRequest: true,
+        supportsFunctionBreakpoints: true,
+        supportsConditionalBreakpoints: true,
+        supportsHitConditionalBreakpoints: true,
+        supportsLogPoints: true,
+        supportsBreakpointLocationsRequest: true,
+        supportsDelayedStackTraceLoading: true,
+        exceptionBreakpointFilters: Command::SetExceptionBreakpoints::FILTERS,
+        supportsExceptionInfoRequest: true,
+      }
+
+      event! 'initialized'
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Byebug::DAP
+  class Command::Launch < Command
+    # "This launch request is sent from the client to the debug adapter to start the debuggee with or without debugging (if ‘noDebug’ is true).
+
+    register!
+
+    def execute
+      stopped!
+      @session.start!(:launched) unless args.noDebug
+      respond!
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Byebug::DAP
+  class Command::Next < 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_over(1, @context.frame.pos)
+      :stop
+    end
+
+    private
+
+    def forward_to_context(ctx)
+      super
+      respond!
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Byebug::DAP
+  class Command::Pause < ContextualCommand
+    # "The request suspends the debuggee.
+    # "The debug adapter first sends the response and then a ‘stopped’ event (with reason ‘pause’) after the thread has been paused successfully.
+
+    register!
+
+    def execute_in_context
+      @processor.pause_requested = true
+    end
+
+    private
+
+    def forward_to_context(ctx)
+      ctx.interrupt
+      super
+      respond!
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Byebug::DAP
+  class Command::Scopes < Command
+    # "The request returns the variable scopes for a given stackframe ID.
+
+    register!
+
+    def execute
+      started!
+
+      frame, thnum, frnum = resolve_frame_id(args.frameId)
+      return unless frame
+
+      scopes = []
+
+      locals = frame_local_names(frame).sort
+      unless locals.empty?
+        scopes << ::DAP::Scope.new(
+          name: 'Locals',
+          presentationHint: 'locals',
+          variablesReference: @session.save_variables(thnum, frnum, :locals, locals),
+          namedVariables: locals.size,
+          indexedVariables: 0,
+          expensive: false)
+          .validate!
+      end
+
+      globals = global_names.sort
+      unless globals.empty?
+        scopes << ::DAP::Scope.new(
+          name: 'Globals',
+          presentationHint: 'globals',
+          variablesReference: @session.save_variables(thnum, frnum, :globals, globals),
+          namedVariables: globals.size,
+          indexedVariables: 0,
+          expensive: true)
+          .validate!
+      end
+
+      respond! body: ::DAP::ScopesResponseBody.new(scopes: scopes)
+    end
+
+    private
+
+    def frame_local_names(frame)
+      locals = frame.locals
+      locals = locals.keys unless locals == [] # BUG in Byebug?
+      locals << :self if frame._self.to_s != 'main'
+      locals << :$! if frame.pos == 0 && !frame.context.processor.last_exception.nil?
+      locals
+    end
+
+    def global_names
+      global_variables - %i[$IGNORECASE $= $KCODE $-K $binding]
+    end
+  end
+end