byebug-dap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3396f670f640d236adac1e58a6dd95af568925af57e9215262a0c10cd870d8df
+  data.tar.gz: 516cc5caca246d9a2764c1cc7ec72b5e1ed2ce27bfcca04a9c7ce1413ce720c3
+SHA512:
+  metadata.gz: cc4611e07bc8c7738335c1a27340849ddb59a0728ce880926e99753d5168cd1f03f8e6197ba375fe074d852eaa502fb824e2555f39c76195ca301e9b4100926b
+  data.tar.gz: c6af798756bb6d6ab71089f365b5cc869dd1c0fde932960f1b450c198439c4bb7be0ff385a22ebc9bcc486ff5465ee937bba9836ef367857c88dd9d8f0660d15

data/AUTHORS

@@ -0,0 +1,7 @@
+# This is the list of ruby-dap authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder.  To see the full list
+# of contributors, see the revision history in source control.
+
+Ethan Reesor

data/LICENSE

@@ -0,0 +1,201 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/bin/byebug-dap

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'byebug/dap'
+
+USAGE = <<-EOS
+Usage: byebug-dap [options] <--stdio|--unix dap.socket|--listen 12345> <program>
+EOS
+
+def next_arg
+  arg = ARGV.pop
+  return arg if arg
+
+  STDERR.puts USAGE
+  exit!
+end
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = USAGE
+
+  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 }
+  opts.on("-w", "--[no-]wait", "Wait for attach or launch command before running program") { |v| options[:wait] = v }
+  opts.on("-f", "--[no-]force", "When listening on a unix socket, delete the socket if it exists") { |v| options[:force] = v }
+  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 }
+end.parse!
+
+program = next_arg
+if program == '-'
+  program = next_arg
+  options[:stdio] = true
+end
+
+if options[:stdio]
+  host, port = :stdio, nil
+
+elsif options[:listen]
+  host, port = options[:listen].split(':')
+  host, port = 'localhost', host unless port
+
+elsif options[:unix]
+  host, port = :unix, options[:unix]
+
+  if File.exist?(port)
+    if options[:force]
+      File.delete(port)
+    else
+      puts "#{port} already exists"
+      exit!
+    end
+  end
+
+else
+  STDERR.puts USAGE, "One of --stdio, --listen, or --unix is required"
+  exit!
+end
+
+begin
+  STDERR.puts "Starting DAP"
+  STDERR.flush
+
+  if options[:wait]
+    Byebug.start_dap(host, port) { require File.realpath(program) }
+  else
+    Byebug.start_dap(host, port)
+    require File.realpath(program)
+  end
+
+ensure
+  File.delete(port) if File.exist?(port) if host == :unix
+end

data/lib/byebug/dap.rb

@@ -0,0 +1,33 @@
+require 'dap'
+require 'byebug'
+require 'byebug/core'
+require 'byebug/remote'
+
+require_relative 'dap/channel'
+require_relative 'dap/handles'
+require_relative 'dap/invalid_request_argument_error'
+require_relative 'dap/safe_helpers'
+
+require_relative 'dap/server'
+require_relative 'dap/command_processor'
+require_relative 'dap/controller'
+require_relative 'dap/interface'
+
+module Byebug
+  module DAP
+    module Debug
+      class << self
+        @protocol = false
+        @evaluate = false
+
+        attr_accessor :protocol, :evaluate
+      end
+    end
+  end
+
+  class << self
+    def start_dap(host, port = 0, &block)
+      DAP::Server.new(&block).start(host, port)
+    end
+  end
+end

data/lib/byebug/dap/channel.rb

@@ -0,0 +1,64 @@
+module Byebug
+  module DAP
+    class Channel
+      def initialize
+        @mu = Mutex.new
+        @cond = ConditionVariable.new
+        @closed = false
+        @have = false
+      end
+
+      def close
+        @mu.synchronize {
+          @closed = true
+          @cond.broadcast
+        }
+      end
+
+      def pop
+        synchronize_loop {
+          return if @closed
+
+          if @have
+            @cond.signal
+            @have = false
+            return @value
+          end
+
+          @cond.wait(@mu)
+        }
+      end
+
+      def push(message, timeout: nil)
+        deadline = timeout + Time.now.to_f unless timeout.nil?
+
+        synchronize_loop {
+          raise RuntimeError, "Send on closed channel" if @closed
+
+          unless @have
+            @cond.signal
+            @have = true
+            @value = message
+            return
+          end
+
+          if timeout.nil?
+            @cond.wait(@mu)
+
+          else
+            remaining = deadline - Time.now.to_f
+            return yield if remaining < 0
+
+            @cond.wait(@mu, remaining)
+          end
+        }
+      end
+
+      private
+
+      def synchronize_loop
+        @mu.synchronize { loop { yield } }
+      end
+    end
+  end
+end

data/lib/byebug/dap/command_processor.rb

@@ -0,0 +1,172 @@
+module Byebug
+  module DAP
+    class CommandProcessor
+      extend Forwardable
+      include SafeHelpers
+
+      class TimeoutError < StandardError
+        attr_reader :context
+
+        def initialize(context)
+          @context = context
+        end
+      end
+
+      attr_reader :context, :interface
+
+      def initialize(context, interface)
+        @context = context
+        @interface = interface
+        @requests = Channel.new
+        @exec_mu = Mutex.new
+        @exec_ch = Channel.new
+      end
+
+      def <<(message)
+        @requests.push(message, timeout: 1) { raise TimeoutError.new(context) }
+      end
+
+      def execute(&block)
+        raise "Block required" unless block_given?
+
+        r, err = nil, nil
+        @exec_mu.synchronize {
+          self << block
+          r, err = @exec_ch.pop
+        }
+
+        if err
+          raise err
+        else
+          r
+        end
+      end
+
+      def process_requests
+        loop do
+          request = @requests.pop
+          break unless request
+
+          if request.is_a?(Proc)
+            err = nil
+            r = safe(request, :call) { |e| err = e; nil }
+            @exec_ch.push [r, err]
+            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.
+
+            @pause_requested = true
+
+          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.
+
+            context.step_over(1, context.frame.pos)
+            break
+
+          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.
+
+            context.step_into(1, context.frame.pos)
+            break
+
+          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.
+
+            context.step_out(context.frame.pos + 1, false)
+            context.frame = 0
+            break
+          end
+        end
+
+        interface.invalidate_handles!
+
+      rescue StandardError => e
+        STDERR.puts "\n! #{e.message} (#{e.class})", *e.backtrace
+      end
+
+      def stopped!
+        case context.stop_reason
+        when :breakpoint
+          number = Byebug.breakpoints.index(@at_breakpoint) + 1
+
+          args = {
+            reason: 'breakpoint',
+            description: 'Hit breakpoint',
+            text: "Stopped by breakpoint #{number} at #{context.frame.file}:#{context.frame.line}",
+          }
+
+        when :catchpoint
+          # TODO this is probably not the right message
+          args = {
+            reason: 'catchpoint',
+            description: 'Hit catchpoint',
+            text: "Stopped by catchpoint at #{context.location}: `#{@at_catchpoint}'",
+          }
+
+        when :step
+          if @pause_requested
+            @pause_requested = false
+            args = {
+              reason: 'pause',
+              text: "Paused at #{context.frame.file}:#{context.frame.line}"
+            }
+          else
+            args = {
+              reason: 'step',
+              text: "Stepped at #{context.frame.file}:#{context.frame.line}"
+            }
+          end
+
+        else
+          STDERR.puts "Stopped for unknown reason: #{context.stop_reason}"
+        end
+
+        interface.event! 'stopped', threadId: context.thnum, **args if args
+
+        process_requests
+      end
+
+      alias at_line stopped!
+      alias at_end stopped!
+
+      def at_end
+        stopped!
+      end
+
+      def at_return(return_value)
+        @at_return = return_value
+        stopped!
+      end
+
+      # def at_tracing
+      #   interface.puts "Tracing: #{context.full_location}"
+
+      #   # run_auto_cmds(2)
+      # end
+
+      def at_breakpoint(breakpoint)
+        @at_breakpoint = breakpoint
+      end
+
+      def at_catchpoint(exception)
+        @at_catchpoint = exception
+      end
+    end
+  end
+end

data/lib/byebug/dap/controller.rb

@@ -0,0 +1,241 @@
+module Byebug
+  module DAP
+    class Controller
+      class DisconnectError < StandardError; end
+
+      def initialize(interface, signal_start = nil)
+        @interface = interface
+        @signal_start = signal_start
+
+        @trace = TracePoint.new(:thread_begin, :thread_end) { |t| process_trace t }
+      end
+
+      def run
+        @trace.enable
+
+        loop do
+          @request = @interface.receive
+          process_command @request
+
+        rescue InvalidRequestArgumentError => e
+          handle_error e
+
+        rescue CommandProcessor::TimeoutError => e
+          respond! success: false, message: "Debugger on thread ##{e.context.thnum} is not responding"
+        end
+
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED, DisconnectError
+        STDERR.puts "\nClient disconnected"
+
+      rescue StandardError => e
+        STDERR.puts "\n! #{e.message} (#{e.class})", *e.backtrace
+
+      ensure
+        Byebug.mode = :off
+        Byebug.stop
+        @interface.socket.close
+      end
+
+      private
+
+      def process_trace(trace)
+        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
+      end
+
+      def running!
+        raise InvalidRequestArgumentError.new(:not_running, nil) unless Byebug.started?
+      end
+
+      def process_command(request)
+        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!
+          raise DisconnectError
+
+        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
+
+          @signal_start.call(:attach) if @signal_start
+
+          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
+          end
+
+          @signal_start.call(:launch) if @signal_start
+
+          respond!
+          return
+
+        when 'configurationDone'
+          # "This optional request indicates that the client has finished initialization of the debug adapter.
+
+          respond!
+          return
+        end
+
+        running!
+
+        case request.command
+        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.
+
+          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
+      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
+
+      def handle_error(ex)
+        case ex.error
+        when :not_running
+          respond! success: false, message: "Debugger is not running"
+
+        when :missing_argument
+          respond! success: false, message: "Missing #{ex.scope}"
+
+        when :missing_entry
+          respond! success: false, message: "Invalid #{ex.scope} #{ex.value}"
+
+        when :missing_thread
+          respond! success: false, message: "Cannot locate thread ##{ex.value}"
+
+        when :missing_frame
+          respond! success: false, message: "Cannot locate frame ##{ex.value}"
+
+        when :invalid_entry
+          respond! success: false, message: "Error resolving #{ex.scope}: #{ex.value}"
+
+        else
+          raise "Unknown internal error: #{err}"
+        end
+      end
+    end
+  end
+end

data/lib/byebug/dap/handles.rb

@@ -0,0 +1,31 @@
+module Byebug
+  module DAP
+    class Handles
+      def initialize
+        @mu = Mutex.new
+        @entries = []
+      end
+
+      def clear!
+        sync { @entries = []; nil }
+      end
+
+      def [](id)
+        sync { @entries[id-1] }
+      end
+
+      def <<(entry)
+        sync do
+          @entries << entry
+          @entries.size
+        end
+      end
+
+      private
+
+      def sync
+        @mu.synchronize { yield }
+      end
+    end
+  end
+end

data/lib/byebug/dap/interface.rb

@@ -0,0 +1,265 @@
+module Byebug
+  module DAP
+    class Interface
+      include SafeHelpers
+
+      attr_reader :socket
+
+      def initialize(socket)
+        @socket = socket
+      end
+
+      def <<(message)
+        STDERR.puts "> #{message.to_wire}" if Debug.protocol
+        message.validate!
+        socket.write ::DAP::Encoding.encode(message)
+      end
+
+      def event!(event, **values)
+        body = ::DAP.const_get("#{event[0].upcase}#{event[1..]}EventBody").new(values) unless values.empty?
+        self << ::DAP::Event.new(event: event, body: body)
+      end
+
+      def receive
+        m = ::DAP::Encoding.decode(socket)
+        STDERR.puts "< #{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.deco_call,
+            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 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

data/lib/byebug/dap/invalid_request_argument_error.rb

@@ -0,0 +1,13 @@
+module Byebug
+  module DAP
+    class InvalidRequestArgumentError < StandardError
+      attr_accessor :error, :value, :scope
+
+      def initialize(error, value: nil, scope: nil)
+        @error = error
+        @value = value
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/byebug/dap/safe_helpers.rb

@@ -0,0 +1,55 @@
+module Byebug
+  module DAP
+    module SafeHelpers
+      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
+
+      def safe(target, method, *args, &block)
+        if target.respond_to?(method)
+          target.__send__(method, *args)
+        else
+          yield
+        end
+      rescue StandardError => e
+        STDERR.puts "\n! #{e.message} (#{e.class})", *e.backtrace if Debug.evaluate
+        block.parameters.empty? ? yield : yield(e)
+      end
+
+      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
+    end
+  end
+end

data/lib/byebug/dap/server.rb

@@ -0,0 +1,93 @@
+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(&block)
+        @started = false
+        if block_given?
+          @on_start = block
+          @mu = Mutex.new
+          @cond = ConditionVariable.new
+        end
+      end
+
+      def start(host, port = 0)
+        case host
+        when :stdio
+          start_stdio
+        when :unix
+          start_unix port
+        else
+          start_tcp host, port
+        end
+      end
+
+      def start_tcp(host, port)
+        return if @started
+        @started = true
+
+        launch TCPServer.new(host, port)
+      end
+
+      def start_unix(socket)
+        return if @started
+        @started = true
+
+        launch UNIXServer.new(socket)
+      end
+
+      def start_stdio
+        return if @started
+        @started = true
+
+        launch STDIO.new
+      end
+
+      private
+
+      def launch(server)
+        DebugThread.new do
+          if server.respond_to?(:accept)
+            while session = server.accept
+              debug session
+            end
+          else
+            debug server
+          end
+        end
+
+        return unless defined?(@on_start)
+
+        @mu.synchronize { @cond.wait(@mu) }
+
+        @on_start.call
+      end
+
+      def debug(session)
+        Context.interface = Byebug::DAP::Interface.new(session)
+        Context.processor = Byebug::DAP::CommandProcessor
+
+        signal_start = ->(_) { @mu.synchronize { @cond.signal } } if defined?(@on_start)
+        Byebug::DAP::Controller.new(Context.interface, signal_start).run
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: byebug-dap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ethan Reesor
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+- !ruby/object:Gem::Dependency
+  name: ruby-dap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Implements a Debug Adapter Protocol interface for Byebug
+email: ethan.reesor@gmail.com
+executables:
+- byebug-dap
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- LICENSE
+- bin/byebug-dap
+- lib/byebug/dap.rb
+- lib/byebug/dap/channel.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/server.rb
+homepage: https://gitlab.com/firelizzard/byebug-dap
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Debug Adapter Protocol for Byebug
+test_files: []