byebug-dap 0.1.2 → 0.1.3

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

@@ -0,0 +1,17 @@
+module Byebug
+  module DAP
+    module SafeHelpers
+      def safe(target, method, *args, &block)
+        if method.is_a?(Array) && args.empty?
+          method.each { |m| target = target.__send__(m) }
+          target
+        else
+          target.__send__(method, *args)
+        end
+      rescue StandardError => e
+        log "\n! #{e.message} (#{e.class})", *e.backtrace if Debug.evaluate
+        block.parameters.empty? ? yield : yield(e)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Byebug::DAP
+  module Scalar
+    def ===(value)
+      case value
+      when nil, true, false
+        return true
+      when ::String, ::Symbol, ::Numeric
+        return true
+      when ::Time, ::Range
+        true
+      end
+
+      return true if defined?(::Date) && ::Date === value
+      return true if defined?(::DateTime) && ::DateTime === value
+
+      false
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Byebug::DAP
+  class STDIO
+    extend Forwardable
+
+    def initialize
+      @in = STDIN.dup
+      @out = STDOUT.dup
+      @in.sync = true
+      @out.sync = true
+    end
+
+    def close; @in.close; @out.close; end
+    def flush; @in.flush; @out.flush; end
+    def fsync; @in.fsync; @out.fsync; end
+    def closed?; @in.closed? || @out.closed?; end
+
+    def_delegators :@in, :close_read, :bytes, :chars, :codepoints, :each, :each_byte, :each_char, :each_codepoint, :each_line, :getbyte, :getc, :gets, :lines, :pread, :print, :printf, :read, :read_nonblock, :readbyte, :readchar, :readline, :readlines, :readpartial, :sysread, :ungetbyte, :ungetc
+    def_delegators :@out, :<<, :close_write, :putc, :puts, :pwrite, :syswrite, :write, :write_nonblock
+    public :<<, :bytes, :chars, :close_read, :close_write, :codepoints, :each, :each_byte, :each_char, :each_codepoint, :each_line, :getbyte, :getc, :gets, :lines, :pread, :print, :printf, :putc, :puts, :pwrite, :read, :read_nonblock, :readbyte, :readchar, :readline, :readlines, :readpartial, :sysread, :syswrite, :ungetbyte, :ungetc, :write, :write_nonblock
+  end
+end

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

@@ -0,0 +1,60 @@
+module Byebug::DAP
+  module ValueHelpers
+    def prepare_value(val)
+      str = safe(val, :inspect) { safe(val, :to_s) { return yield } }
+      cls = safe(val, :class) { nil }
+      typ = safe(cls, :name) { safe(cls, :to_s) { nil } }
+
+      scalar = safe(-> { Scalar === val }, :call) { true }
+      return str, typ, [], [] if scalar
+
+      named = safe(val, :instance_variables) { [] }
+      named += safe(val, :class_variables) { [] }
+      # named += safe(val, :constants) { [] }
+
+      indexed = safe(-> {
+        return (0...val.size).to_a if val.is_a?(Array)
+        return val.keys if val.respond_to?(:keys) && val.respond_to?(:[])
+        []
+      }, :call) { [] }
+
+      return str, typ, named, indexed
+    end
+
+    def prepare_value_response(thnum, frnum, kind, name: nil, &block)
+      err = nil
+      raw = execute_on_thread(thnum, block) { |e| err = e; nil }
+
+      if err.nil?
+        value, type, named, indexed = prepare_value(raw) { |e| next exception_description(e), nil, [], [] }
+      else
+        type, named, indexed = nil, [], []
+        if err.is_a?(CommandProcessor::TimeoutError)
+          name = err.context.thread.name
+          value = "*Thread ##{err.context.thnum} #{name ? '(' + name + ')' : ''} unresponsive*"
+        else
+          value = exception_description(err)
+        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] = @session.save_variables(thnum, frnum, kind, raw, named, indexed)
+        args[:namedVariables] = named.size
+        args[:indexedVariables] = indexed.size
+      end
+
+      klazz.new(args).validate!
+    end
+  end
+end

data/lib/byebug/dap/server.rb

@@ -1,30 +1,13 @@
 module Byebug
   module DAP
     class Server
-      class STDIO
-        extend Forwardable
-
-        def initialize
-          @in = STDIN
-          @out = STDOUT
-          STDIN.sync = true
-          STDOUT.sync = true
-        end
-
-        def close; @in.close; @out.close; end
-        def flush; @in.flush; @out.flush; end
-        def fsync; @in.fsync; @out.fsync; end
-
-        def_delegators :@in, :close_read, :bytes, :chars, :codepoints, :each, :each_byte, :each_char, :each_codepoint, :each_line, :getbyte, :getc, :gets, :lines, :pread, :print, :printf, :read, :read_nonblock, :readbyte, :readchar, :readline, :readlines, :readpartial, :sysread, :ungetbyte, :ungetc
-        def_delegators :@out, :<<, :close_write, :putc, :puts, :pwrite, :syswrite, :write, :write_nonblock
-        public :<<, :bytes, :chars, :close_read, :close_write, :codepoints, :each, :each_byte, :each_char, :each_codepoint, :each_line, :getbyte, :getc, :gets, :lines, :pread, :print, :printf, :putc, :puts, :pwrite, :read, :read_nonblock, :readbyte, :readchar, :readline, :readlines, :readpartial, :sysread, :syswrite, :ungetbyte, :ungetc, :write, :write_nonblock
-      end
-
-      def initialize
+      def initialize(capture: true, forward: true)
         @started = false
         @mu = Mutex.new
         @cond = ConditionVariable.new
         @configured = false
+        @capture = capture
+        @forward = forward
       end
 
       def start(host, port = 0)
@@ -42,21 +25,26 @@ module Byebug
         return if @started
         @started = true
 
-        launch TCPServer.new(host, port)
+        @ios = CapturedIO.new(@forward, @forward) if @capture
+        launch_accept TCPServer.new(host, port)
       end
 
       def start_unix(socket)
         return if @started
         @started = true
 
-        launch UNIXServer.new(socket)
+        @ios = CapturedIO.new(@forward, @forward) if @capture
+        launch_accept UNIXServer.new(socket)
       end
 
       def start_stdio
         return if @started
         @started = true
 
-        launch STDIO.new
+        stream = STDIO.new
+        STDIN.close
+        @ios = CapturedIO.new(false, @forward) if @capture
+        launch stream
       end
 
       def wait_for_client
@@ -71,30 +59,58 @@ module Byebug
 
       private
 
-      def launch(server)
+      def log
+        if @ios
+          @ios.log
+        elsif defined?(LOG)
+          LOG
+        else
+          STDERR
+        end
+      end
+
+      def launch(stream)
         DebugThread.new do
-          if server.respond_to?(:accept)
-            while session = server.accept
-              debug session
-            end
-          else
-            debug server
-          end
+          debug stream
+
+        ensure
+          @ios&.restore
         end
 
         self
       end
 
-      def debug(session)
-        Context.interface = Byebug::DAP::Interface.new(session)
-        Context.processor = Byebug::DAP::CommandProcessor
+      def launch_accept(server)
+        DebugThread.new do
+          while socket = server.accept
+            debug socket
+          end
+
+        ensure
+          @ios&.restore
+        end
+
+        self
+      end
 
-        Byebug::DAP::Controller.new(Context.interface) do
+      def debug(connection)
+        session = Byebug::DAP::Session.new(connection, @ios) do
           @mu.synchronize do
             @configured = true
             @cond.broadcast
           end
-        end.run
+        end
+
+        session.execute
+
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+        log.puts "Client disconnected"
+
+      rescue StandardError => e
+        log.puts "#{e.message} (#{e.class})", *e.backtrace
+
+      ensure
+        session.stop!
       end
     end
   end

data/lib/byebug/dap/session.rb

@@ -0,0 +1,176 @@
+module Byebug
+  module DAP
+    class Session
+      include SafeHelpers
+
+      @@children = []
+
+      def self.child_spawned(name, pid, socket)
+        child = ChildSpawnedEventBody.new(name: name, pid: pid, socket: socket)
+        @@children << child
+
+        session = Context.interface
+        session.event! child if session.is_a?(Byebug::DAP::Session)
+
+        return true
+
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+        return false
+      end
+
+      def initialize(connection, ios, &block)
+        @connection = connection
+        @ios = ios
+        @on_configured = block
+        @pid = Process.pid
+        @log_points = {}
+        @frame_ids = Handles.new
+        @variable_refs = Handles.new
+        @trace = TracePoint.new(:thread_begin, :thread_end) { |t| process_trace t }
+
+        notify_of_children
+      end
+
+      def log(*args)
+        logger =
+          if @ios
+            @ios.log
+          elsif defined?(LOG)
+            LOG
+          else
+            STDERR
+          end
+        logger.puts(*args)
+      end
+
+      def execute
+        Context.interface = self
+        Context.processor = Byebug::DAP::CommandProcessor
+
+        Command.execute(self, receive) until @connection.closed?
+
+        Context.interface = LocalInterface.new
+      end
+
+      def invalidate_handles!
+        @frame_ids.clear!
+        @variable_refs.clear!
+      end
+
+      def start!(mode)
+        @trace.enable
+        Byebug.mode = mode
+        Byebug.start
+        @exit_on_stop = true if mode == :launched
+      end
+
+      def configured!
+        return unless @on_configured
+
+        callback, @on_configured = @on_configured, callback
+        callback.call
+      end
+
+      def stop!
+        exit if @exit_on_stop && @pid == Process.pid
+
+        Byebug.mode = :off
+        Byebug.stop
+        @trace.disable
+        @connection.close
+      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
+
+        send ::DAP::Event.new(event: event, body: body)
+      end
+
+      def respond!(request, body = nil, success: true, message: 'Success', **values)
+        send ::DAP::Response.new(
+          request_seq: request.seq,
+          command: request.command,
+          success: success,
+          message: message,
+          body: body,
+          **values)
+      end
+
+      def save_variables(*args)
+        @variable_refs << args
+      end
+
+      def restore_variables(ref)
+        @variable_refs[ref]
+      end
+
+      def save_frame(*args)
+        @frame_ids << args
+      end
+
+      def restore_frame(id)
+        @frame_ids[id]
+      end
+
+      def get_log_point(breakpoint)
+        @log_points[breakpoint.id]
+      end
+
+      def set_log_point(breakpoint, expr)
+        if expr.nil? || expr.empty?
+          @log_points.delete(breakpoint.id)
+        else
+          @log_points[breakpoint.id] = expr
+        end
+      end
+
+      def clear_breakpoints(*breakpoints)
+        breakpoints.each do |breakpoint|
+          Byebug.breakpoints.delete(breakpoint)
+          @log_points.delete(breakpoint.id)
+        end
+      end
+
+      private
+
+      def notify_of_children
+        @@children.each { |c| event! c }
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+        # client is closed
+      end
+
+      def send(message)
+        log "#{Process.pid} > #{message.to_wire}" if Debug.protocol
+        message.validate!
+        @connection.write ::DAP::Encoding.encode(message)
+      end
+
+      def receive
+        m = ::DAP::Encoding.decode(@connection)
+        log "#{Process.pid} < #{m.to_wire}" if Debug.protocol
+        m
+      end
+
+      def process_trace(trace)
+        return unless Byebug.started?
+
+        ctx = Byebug.contexts.find { |c| c.thread == Thread.current }
+
+        case trace.event
+        when :thread_begin
+          event! 'thread', reason: 'started', threadId: ctx.thnum
+        when :thread_end
+          event! 'thread', reason: 'exited', threadId: ctx.thnum
+        end
+
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+        # client disconnected, ignore error
+      end
+    end
+  end
+end

data/lib/byebug/gem.rb

@@ -0,0 +1,11 @@
+module Byebug
+  module DAP
+    NAME = 'byebug-dap'
+    VERSION = '0.1.3'
+    SUMMARY = 'Debug Adapter Protocol for Byebug'
+    DESCRIPTION = 'Implements a Debug Adapter Protocol interface for Byebug'
+    AUTHORS = ['Ethan Reesor']
+    WEBSITE = 'https://gitlab.com/firelizzard/byebug-dap'
+    LICENSE = 'Apache-2.0'
+  end
+end