byebug-dap 0.1.2 → 0.1.3

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: byebug-dap
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Ethan Reesor
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-09 00:00:00.000000000 Z
+date: 2020-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.1.2
 description: Implements a Debug Adapter Protocol interface for Byebug
-email: ethan.reesor@gmail.com
+email:
 executables:
 - byebug-dap
 extensions: []
@@ -51,15 +51,43 @@ files:
 - README.md
 - bin/byebug-dap
 - lib/byebug/dap.rb
-- lib/byebug/dap/channel.rb
-- lib/byebug/dap/child_spawned_event_body.rb
+- lib/byebug/dap/command.rb
 - lib/byebug/dap/command_processor.rb
-- lib/byebug/dap/controller.rb
-- lib/byebug/dap/handles.rb
-- lib/byebug/dap/interface.rb
-- lib/byebug/dap/invalid_request_argument_error.rb
-- lib/byebug/dap/safe_helpers.rb
+- lib/byebug/dap/commands/attach.rb
+- lib/byebug/dap/commands/breakpoint_locations.rb
+- lib/byebug/dap/commands/configuration_done.rb
+- lib/byebug/dap/commands/continue.rb
+- lib/byebug/dap/commands/disconnect.rb
+- lib/byebug/dap/commands/evaluate.rb
+- lib/byebug/dap/commands/exception_info.rb
+- lib/byebug/dap/commands/initialize.rb
+- lib/byebug/dap/commands/launch.rb
+- lib/byebug/dap/commands/next.rb
+- lib/byebug/dap/commands/pause.rb
+- lib/byebug/dap/commands/scopes.rb
+- lib/byebug/dap/commands/set_breakpoints.rb
+- lib/byebug/dap/commands/set_exception_breakpoints.rb
+- lib/byebug/dap/commands/set_function_breakpoints.rb
+- lib/byebug/dap/commands/source.rb
+- lib/byebug/dap/commands/stack_trace.rb
+- lib/byebug/dap/commands/step_in.rb
+- lib/byebug/dap/commands/step_out.rb
+- lib/byebug/dap/commands/threads.rb
+- lib/byebug/dap/commands/variables.rb
+- lib/byebug/dap/contextual_command.rb
+- lib/byebug/dap/helpers/captured_io.rb
+- lib/byebug/dap/helpers/captured_output.rb
+- lib/byebug/dap/helpers/channel.rb
+- lib/byebug/dap/helpers/child_spawned_event_body.rb
+- lib/byebug/dap/helpers/handles.rb
+- lib/byebug/dap/helpers/invalid_request_argument_error.rb
+- lib/byebug/dap/helpers/safe_helpers.rb
+- lib/byebug/dap/helpers/scalar.rb
+- lib/byebug/dap/helpers/stdio.rb
+- lib/byebug/dap/helpers/value_helpers.rb
 - lib/byebug/dap/server.rb
+- lib/byebug/dap/session.rb
+- lib/byebug/gem.rb
 homepage: https://gitlab.com/firelizzard/byebug-dap
 licenses:
 - Apache-2.0

data/lib/byebug/dap/controller.rb

@@ -1,252 +0,0 @@
-module Byebug
-  module DAP
-    class Controller
-      def initialize(interface, &block)
-        @interface = interface
-        @on_configured = block
-
-        @trace = TracePoint.new(:thread_begin, :thread_end) { |t| process_trace t }
-      end
-
-      def run
-        loop do
-          @request = @interface.receive
-          result = process_command @request
-          return if result == :stop
-        end
-
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
-        STDERR.puts "\nClient disconnected"
-
-      ensure
-        exit if @exit_on_disconnect
-
-        @interface.stop!
-        @trace.disable
-      end
-
-      private
-
-      def process_trace(trace)
-        return unless Byebug.started?
-
-        ctx = Byebug.contexts.find { |c| c.thread == Thread.current }
-
-        case trace.event
-        when :thread_begin
-          @interface.event! 'thread', reason: 'started', threadId: ctx.thnum
-        when :thread_end
-          @interface.event! 'thread', reason: 'exited', threadId: ctx.thnum
-        end
-
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
-        # client disconnected, ignore error
-      end
-
-      def process_command(request)
-        case request.command
-        when 'attach', 'launch'
-          if Byebug.started?
-            respond! success: false, message: "Cannot #{request.command} - debugger is already running"
-            return
-          end
-        when 'pause', 'next', 'stepIn', 'stepOut', 'continue', 'evaluate', 'variables', 'scopes', 'threads', 'stackTrace'
-          unless Byebug.started?
-            respond! success: false, message: "Cannot #{request.command} - debugger is not running"
-            return
-          end
-        end
-
-        case request.command
-        when 'initialize'
-          # "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.
-
-          respond! body: ::DAP::Capabilities.new(
-            supportsConfigurationDoneRequest: true)
-
-          @interface.event! 'initialized'
-          return
-
-        when 'disconnect'
-          # "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).
-
-          respond!
-          return :stop
-
-        when 'attach'
-          # "The attach request is sent from the client to the debug adapter to attach to a debuggee that is already running.
-
-          Byebug.mode = :attached
-          Byebug.start
-          @trace.enable
-
-          respond!
-          return
-
-        when 'launch'
-          # "This launch request is sent from the client to the debug adapter to start the debuggee with or without debugging (if ‘noDebug’ is true).
-
-          unless request.arguments.noDebug
-            Byebug.mode = :launched
-            Byebug.start
-            @trace.enable
-          end
-
-          @exit_on_disconnect = true
-
-          respond!
-          return
-
-        when 'configurationDone'
-          # "This optional request indicates that the client has finished initialization of the debug adapter.
-
-
-          @on_configured&.call
-          respond!
-          return
-
-        when 'pause', 'next', 'stepIn', 'stepOut', 'continue'
-          ctx = @interface.find_thread(request.arguments.threadId)
-          ctx.interrupt if request.command == 'pause'
-
-          ctx.__send__(:processor) << request
-          respond!
-
-        when 'evaluate'
-          # "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.
-
-          respond! body: @interface.evaluate(request.arguments.frameId, request.arguments.expression)
-
-        when 'variables'
-          # "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
-
-          variables = @interface.variables(
-            request.arguments.variablesReference,
-            at: request.arguments.start,
-            count: request.arguments.count,
-            filter: request.arguments.filter)
-
-          respond! body: ::DAP::VariablesResponseBody.new(variables: variables)
-
-        when 'scopes'
-          # "The request returns the variable scopes for a given stackframe ID.
-
-          respond! body: ::DAP::ScopesResponseBody.new(
-            scopes: @interface.scopes(request.arguments.frameId))
-
-        when 'threads'
-          # "The request retrieves a list of all threads.
-
-          respond! body: ::DAP::ThreadsResponseBody.new(threads: @interface.threads)
-
-        when 'stackTrace'
-          # "The request returns a stacktrace from the current execution state.
-
-          frames, stack_size = @interface.frames(
-            request.arguments.threadId,
-            at: request.arguments.startFrame,
-            count: request.arguments.levels)
-
-          respond! body: ::DAP::StackTraceResponseBody.new(
-            stackFrames: frames,
-            totalFrames: stack_size)
-
-        when 'source'
-          # "The request retrieves the source code for a given source reference.
-
-          path = request.arguments.source.path
-          if File.readable?(path)
-            respond! body: ::DAP::SourceResponseBody.new(content: IO.read(path))
-
-          elsif 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
-
-        when 'setBreakpoints'
-          # "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.
-
-          unless File.exist?(request.arguments.source.path)
-            # file doesn't exist, no breakpoints set
-            respond! body: ::DAP::SetBreakpointsResponseBody.new(breakpoints: [])
-            return
-          end
-
-          path = File.realpath(request.arguments.source.path)
-          ::Byebug.breakpoints.each { |bp| ::Byebug::Breakpoint.remove(bp.id) if bp.source == path }
-
-          lines = ::Byebug::Breakpoint.potential_lines(path)
-          verified = []
-          request.arguments.breakpoints.each do |requested|
-            next unless lines.include? requested.line
-
-            bp = ::Byebug::Breakpoint.add(path, requested.line)
-            verified << ::DAP::Breakpoint.new(
-              id: bp.id,
-              verified: true,
-              line: requested.line)
-          end
-
-          respond! body: ::DAP::SetBreakpointsResponseBody.new(breakpoints: verified)
-
-        else
-          respond! success: false, message: 'Invalid command'
-        end
-
-      rescue InvalidRequestArgumentError => e
-        case e.error
-        when :missing_argument
-          respond! success: false, message: "Missing #{e.scope}"
-
-        when :missing_entry
-          respond! success: false, message: "Invalid #{e.scope} #{e.value}"
-
-        when :missing_thread
-          respond! success: false, message: "Cannot locate thread ##{e.value}"
-
-        when :missing_frame
-          respond! success: false, message: "Cannot locate frame ##{e.value}"
-
-        when :invalid_entry
-          respond! success: false, message: "Error resolving #{e.scope}: #{e.value}"
-
-        else
-          respond! success: false, message: "An internal error occured"
-          STDERR.puts "#{e.message} (#{e.class})", *e.backtrace
-        end
-
-      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"
-        STDERR.puts "#{e.message} (#{e.class})", *e.backtrace
-      end
-
-      def respond!(body = {}, success: true, message: 'Success', **values)
-        # TODO make body default to nil?
-        @interface << ::DAP::Response.new(
-          request_seq: @request.seq,
-          command: @request.command,
-          success: success,
-          message: message,
-          body: body,
-          **values)
-      end
-    end
-  end
-end

data/lib/byebug/dap/interface.rb

@@ -1,303 +0,0 @@
-module Byebug
-  module DAP
-    class Interface
-      include SafeHelpers
-
-      @@children = []
-
-      def self.child_spawned(name, pid, socket)
-        child = ChildSpawnedEventBody.new(name: name, pid: pid, socket: socket)
-        @@children << child
-
-        interface = Context.interface
-        interface.event! child if interface.is_a?(Byebug::DAP::Interface)
-
-        return true
-
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
-        return false
-      end
-
-      attr_reader :socket
-
-      def initialize(socket)
-        @socket = socket
-
-        begin
-          @@children.each { |c| event! c }
-        rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
-        end
-      end
-
-      def stop!
-        Byebug.mode = :off
-        Byebug.stop
-        socket.close
-      end
-
-      def <<(message)
-        STDERR.puts "#{Process.pid} > #{message.to_wire}" if Debug.protocol
-        message.validate!
-        socket.write ::DAP::Encoding.encode(message)
-      end
-
-      def event!(event, **values)
-        if (cls = event.class.name.split('::').last) && cls.end_with?('EventBody')
-          body, event = event, cls[0].downcase + cls[1...-9]
-
-        elsif event.is_a?(String) && !values.empty?
-          body = ::DAP.const_get("#{event[0].upcase}#{event[1..]}EventBody").new(values)
-        end
-
-        self << ::DAP::Event.new(event: event, body: body)
-      end
-
-      def receive
-        m = ::DAP::Encoding.decode(socket)
-        STDERR.puts "#{Process.pid} < #{m.to_wire}" if Debug.protocol
-        m
-      end
-
-      def invalidate_handles!
-        frame_ids.clear!
-        variable_refs.clear!
-      end
-
-      def threads
-        Byebug.contexts
-          .filter { |ctx| !ctx.thread.is_a?(DebugThread) }
-          .map { |ctx| ::DAP::Thread.new(
-            id: ctx.thnum,
-            name: ctx.thread.name || "Thread ##{ctx.thnum}")
-            .validate! }
-      end
-
-      def find_thread(id)
-        raise InvalidRequestArgumentError.new(:missing_argument, scope: 'thread ID') unless id
-
-        ctx = Byebug.contexts.find { |c| c.thnum == id }
-        raise InvalidRequestArgumentError.new(:missing_thread, value: id) unless ctx
-
-        ctx
-      end
-
-      def resolve_frame_id(id)
-        entry = frame_ids[id]
-        raise InvalidRequestArgumentError.new(:missing_entry, value: id, scope: 'frame ID') unless entry
-
-        thnum, frnum = entry
-        ctx = Byebug.contexts.find { |c| c.thnum == thnum }
-        raise InvalidRequestArgumentError.new(:missing_thread, value: thnum) unless ctx
-        raise InvalidRequestArgumentError.new(:missing_frame, value: frnum) unless frnum < ctx.stack_size
-
-        return ::Byebug::Frame.new(ctx, frnum), thnum, frnum
-      end
-
-      def frames(thnum, at:, count:)
-        ctx = find_thread(thnum)
-
-        first = at || 0
-        if !count
-          last = ctx.stack_size
-        else
-          last = first + count
-          if last > ctx.stack_size
-            last = ctx.stack_size
-          end
-        end
-
-        frames = (first...last).map do |i|
-          frame = ::Byebug::Frame.new(ctx, i)
-          ::DAP::StackFrame.new(
-            id: frame_ids << [ctx.thnum, i],
-            name: frame_name(frame),
-            source: ::DAP::Source.new(
-              name: File.basename(frame.file),
-              path: File.expand_path(frame.file)),
-            line: frame.line,
-            column: 0) # TODO real column
-            .validate!
-        end
-
-        return frames, ctx.stack_size
-      end
-
-      def resolve_variable_reference(varRef)
-        raise InvalidRequestArgumentError.new(:missing_argument, scope: 'variables reference') unless varRef
-
-        entry = variable_refs[varRef]
-        raise InvalidRequestArgumentError.new(:missing_entry, value: ref, scope: 'variables reference') unless entry
-
-        entry
-      end
-
-      def scopes(frameId)
-        raise InvalidRequestArgumentError.new(:missing_argument, scope: 'frame ID') unless frameId
-
-        frame, thnum, frnum = resolve_frame_id(frameId)
-        return unless frame
-
-        scopes = []
-
-        locals = frame_local_names(frame).sort
-        unless locals.empty?
-          scopes << ::DAP::Scope.new(
-            name: 'Locals',
-            presentationHint: 'locals',
-            variablesReference: variable_refs << [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: variable_refs << [thnum, frnum, :globals, globals],
-            namedVariables: globals.size,
-            indexedVariables: 0,
-            expensive: true)
-            .validate!
-        end
-
-        scopes
-      end
-
-      def variables(varRef, at:, count:, filter: nil)
-        thnum, frnum, kind, *entry = resolve_variable_reference(varRef)
-
-        case kind
-        when :locals, :globals
-          ctx = find_thread(thnum)
-          raise InvalidRequestArgumentError.new(:missing_frame, value: frnum) unless frnum < ctx.stack_size
-
-          frame = ::Byebug::Frame.new(ctx, frnum)
-        end
-
-        case kind
-        when :locals
-          named, indexed = entry[0], []
-          get = ->(key) {
-            return frame._self if key == :self
-            values ||= frame.locals
-            values[key]
-          }
-
-        when :globals
-          named, indexed = entry[0], []
-          get = ->(key) { frame._binding.eval(key.to_s) }
-
-        when :variable, :evalate
-          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
-
-        case filter
-        when 'named'
-          indexed = []
-        when 'indexed'
-          named = []
-        end
-
-        vars = named.map { |k| [k, get] } + indexed.map { |k| [k, index] }
-
-        first = at || 0
-        last = count ? first + count : vars.size
-        last = vars.size unless last < vars.size
-
-        vars[first...last].map { |var, get| prepare_value_response(thnum, frnum, :variable, name: var) { get.call(var) } }
-      end
-
-      def evaluate(frameId, expression)
-        return prepare_value_response(0, 0, :evaluate) { TOPLEVEL_BINDING.eval(expression) } unless frameId
-
-        frame, thnum, frnum = resolve_frame_id(frameId)
-        return unless frame
-
-        prepare_value_response(thnum, frnum, :evaluate) { frame._binding.eval(expression) }
-      end
-
-      private
-
-      def frame_name(frame)
-        frame.deco_call
-      rescue
-        frame.deco_block + frame.deco_class + frame.deco_method + "(?)"
-      end
-
-      def describe_thread(context)
-        if context.thread.name
-          "##{context.thnum} (#{context.thread.name})"
-        else
-          "##{context.thnum}"
-        end
-      end
-
-      def prepare_value_response(thnum, frnum, kind, name: nil, &block)
-        err = nil
-        if thnum == 0
-          raw = safe(block, :call) { |e| err = e; nil }
-        else
-          processor = find_thread(thnum).__send__(:processor)
-          raw = safe(-> { processor.execute(&block) }, :call) { |e| err = e; nil }
-        end
-
-        if err.nil?
-          value, type, named, indexed = prepare_value(raw) { next "*Error in evaluation*", nil, [], [] }
-        else
-          type, named, indexed = nil, [], []
-          if err.is_a?(CommandProcessor::TimeoutError)
-            value = "*Thread #{describe_thread err.context} unresponsive*"
-          else
-            value = "*Error in evaluation*"
-          end
-        end
-
-        case kind
-        when :variable
-          klazz = ::DAP::Variable
-          args = { name: safe(name, :to_s) { safe(name, :inspect) { '???' } }, value: value, type: type }
-        when :evaluate
-          klazz = ::DAP::EvaluateResponseBody
-          args = { result: value, type: type }
-        end
-
-        if named.empty? && indexed.empty?
-          args[:variablesReference] = 0
-        else
-          args[:variablesReference] = variable_refs << [thnum, frnum, kind, raw, named, indexed]
-          args[:namedVariables] = named.size
-          args[:indexedVariables] = indexed.size
-        end
-
-        klazz.new(args).validate!
-      end
-
-      def frame_ids
-        @frame_ids ||= Handles.new
-      end
-
-      def variable_refs
-        @variable_refs ||= Handles.new
-      end
-
-      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
-      end
-
-      def global_names
-        global_variables - %i[$IGNORECASE $= $KCODE $-K $binding]
-      end
-    end
-  end
-end