readapt 0.3.1

data/ext/readapt/monitor.h

@@ -0,0 +1 @@
+void initialize_monitor(VALUE);

data/ext/readapt/readapt.c

@@ -0,0 +1,12 @@
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "monitor.h"
+
+static VALUE m_Readapt;
+
+void Init_readapt()
+{
+	m_Readapt = rb_define_module("Readapt");
+
+	initialize_monitor(m_Readapt);
+}

data/ext/readapt/threads.c

@@ -0,0 +1,101 @@
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "threads.h"
+
+static VALUE threads;
+
+void thread_reference_free(void* data)
+{
+	free(data);
+}
+
+size_t thread_reference_size(const void* data)
+{
+	return sizeof(thread_reference_t);
+}
+
+static const rb_data_type_t thread_reference_type = {
+	.wrap_struct_name = "thread_reference",
+	.function = {
+		.dmark = NULL,
+		.dfree = thread_reference_free,
+		.dsize = thread_reference_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+void initialize_threads()
+{
+	threads = rb_hash_new();
+	rb_global_variable(&threads);
+}
+
+VALUE thread_reference_new(VALUE thr)
+{
+	thread_reference_t *data = malloc(sizeof(thread_reference_t));
+	VALUE obj = TypedData_Make_Struct(rb_cData, thread_reference_t, &thread_reference_type, data);
+	data->id = NUM2LONG(rb_funcall(thr, rb_intern("object_id"), 0));
+	data->depth = 0;
+	data->cursor = 0;
+	data->control = rb_intern("continue");
+	return obj;
+}
+
+thread_reference_t *thread_reference_pointer(VALUE ref)
+{
+	thread_reference_t *ptr;
+    TypedData_Get_Struct(ref, thread_reference_t, &thread_reference_type, ptr);
+    return ptr;
+}
+
+VALUE thread_current_reference()
+{
+	return thread_reference(rb_thread_current());
+}
+
+VALUE thread_reference(VALUE thr)
+{
+	return rb_hash_aref(threads, rb_obj_id(thr));
+}
+
+VALUE thread_reference_id(VALUE id)
+{
+	return rb_hash_aref(threads, id);
+}
+
+VALUE thread_add_reference(VALUE thr)
+{
+	VALUE ref;
+
+	ref = thread_reference_new(thr);
+	rb_hash_aset(threads, rb_obj_id(thr), ref);
+	return ref;
+}
+
+VALUE thread_delete_reference(VALUE thr)
+{
+	rb_hash_delete(threads, thr);
+	return Qnil;
+}
+
+void thread_pause()
+{
+	VALUE refs, r;
+	thread_reference_t *ptr;
+	long len, i;
+
+	refs = rb_funcall(threads, rb_intern("values"), 0);
+	len = rb_array_len(refs);
+	for (i = 0; i < len; i++)
+	{
+		r = rb_ary_entry(refs, i);
+		ptr = thread_reference_pointer(r);
+		ptr->control = rb_intern("pause");
+	}
+}
+
+void thread_reset()
+{
+	rb_funcall(threads, rb_intern("clear"), 0);
+}

data/ext/readapt/threads.h

@@ -0,0 +1,18 @@
+typedef struct thread_reference_struct {
+	long id;
+	int depth;
+	int cursor;
+	VALUE prev_file;
+	int prev_line;
+	ID control;
+} thread_reference_t;
+
+void initialize_threads();
+VALUE thread_current_reference();
+VALUE thread_reference(VALUE);
+VALUE thread_reference_id(VALUE);
+VALUE thread_add_reference(VALUE);
+VALUE thread_delete_reference(VALUE);
+thread_reference_t *thread_reference_pointer(VALUE);
+void thread_pause();
+void thread_reset();

data/lib/readapt.rb

@@ -0,0 +1,34 @@
+require 'backport'
+
+require "readapt/version"
+require 'readapt/location'
+require 'readapt/breakpoint'
+require 'readapt/breakpoints'
+require 'readapt/thread'
+require 'readapt/frame'
+require 'readapt/monitor'
+require 'readapt/snapshot'
+require 'readapt/finder'
+require 'readapt/debugger'
+require 'readapt/message'
+require 'readapt/variable'
+require 'readapt/adapter'
+require 'readapt/readapt'
+require 'readapt/shell'
+
+module Readapt
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+Readapt.module_exec do
+  if (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    define_singleton_method :normalize_path do |path|
+      path[0].upcase + path[1..-1].gsub('\\', '/')
+    end
+  else
+    define_singleton_method :normalize_path do |path|
+      path
+    end
+  end
+end

data/lib/readapt/adapter.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Readapt
+  module Adapter
+    # @!parse include Backport::Adapter
+
+    @@debugger = nil
+
+    def self.host debugger
+      @@debugger = debugger
+    end
+
+    def format result
+      write_line result.to_protocol.to_json
+    end
+
+    def opening
+      @@debugger.add_observer self
+      @data_reader = DataReader.new
+      @data_reader.set_message_handler do |message|
+        process message
+      end
+    end
+
+    def closing
+      @@debugger.delete_observer(self)
+    end
+
+    def receiving data
+      @data_reader.receive data
+    end
+
+    def update event, data
+      obj = {
+        type: 'event',
+        event: event
+      }
+      obj[:body] = data unless data.nil?
+      json = obj.to_json
+      envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+      write envelope
+    end
+
+    private
+
+    # @param data [Hash]
+    # @return [void]
+    def process data
+      # @todo Better solution than nil frames
+      message = Message.process(data, @@debugger)
+      if data['seq']
+        json = {
+          type: 'response',
+          request_seq: data['seq'],
+          success: true,
+          command: data['command'],
+          body: message.body
+        }.to_json
+        envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+        write envelope
+        close if data['command'] == 'disconnect'
+        return unless data['command'] == 'initialize'
+        json = {
+          type: 'event',
+          event: 'initialized'
+        }.to_json
+        envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+        write envelope
+      end
+    rescue Exception => e
+      STDERR.puts e.message
+      STDERR.puts e.backtrace
+    end
+  end
+
+  class DataReader
+    def initialize
+      @in_header = true
+      @content_length = 0
+      @buffer = String.new
+    end
+
+    # Declare a block to be executed for each message received from the
+    # client.
+    #
+    # @yieldparam [Hash] The message received from the client
+    def set_message_handler &block
+      @message_handler = block
+    end
+
+    # Process raw data received from the client. The data will be parsed
+    # into messages based on the JSON-RPC protocol. Each message will be
+    # passed to the block declared via set_message_handler. Incomplete data
+    # will be buffered and subsequent data will be appended to the buffer.
+    #
+    # @param data [String]
+    def receive data
+      data.each_char do |char|
+        @buffer.concat char
+        if @in_header
+          prepare_to_parse_message if @buffer.end_with?("\r\n\r\n")
+        else
+          parse_message_from_buffer if @buffer.bytesize == @content_length
+        end
+      end
+    end
+
+    private
+
+    def prepare_to_parse_message
+      @in_header = false
+      @buffer.each_line do |line|
+        parts = line.split(':').map(&:strip)
+        if parts[0] == 'Content-Length'
+          @content_length = parts[1].to_i
+          break
+        end
+      end
+      @buffer.clear
+    end
+
+    def parse_message_from_buffer
+      begin
+        msg = JSON.parse(@buffer)
+        @message_handler.call msg unless @message_handler.nil?
+      rescue JSON::ParserError => e
+        Solargraph::Logging.logger.warn "Failed to parse request: #{e.message}"
+        Solargraph::Logging.logger.debug "Buffer: #{@buffer}"
+      ensure
+        @buffer.clear
+        @in_header = true
+        @content_length = 0
+      end
+    end
+  end
+end

data/lib/readapt/breakpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Readapt
+  class Breakpoint < Location
+    attr_reader :verified
+
+    def initialize file, line, verified = true
+      super(file, line)
+      @verified = verified
+    end
+
+    def enabled?
+      @verified
+    end
+  end
+end

data/lib/readapt/breakpoints.rb

@@ -0,0 +1,58 @@
+require 'observer'
+
+module Readapt
+  class Breakpoints
+    include Observable
+
+    def initialize
+      @sources = {}
+      @concatting = false
+    end
+
+    # @return [Array<String>]
+    def sources
+      @sources.keys
+    end
+
+    # @param breakpoint [Breakpoint]
+    # @return [void]
+    def add breakpoint
+      @sources[breakpoint.file] ||= []
+      @sources[breakpoint.file].push breakpoint
+      changed
+      notify_observers unless @concatting
+    end
+
+    # @param breakpoints [Array<Breakpoint>]
+    # @return [void]
+    def concat breakpoints
+      @concatting = true
+      breakpoints.each { |bp| add bp }
+      @concatting = false
+      notify_observers
+    end
+
+    # @param file [String]
+    # @return [void]
+    def clear file
+      @sources.delete file
+      changed
+      notify_observers
+    end
+
+    # @param file [String]
+    # @return [Array<Breakpoint>]
+    def for file
+      @sources[file] || []
+    end
+
+    # @return [Array<Breakpoint>]
+    def all
+      @sources.values.flatten
+    end
+
+    def empty?
+      @sources.empty?
+    end
+  end
+end

data/lib/readapt/debugger.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'backport'
+require 'observer'
+require 'set'
+
+module Readapt
+  class Debugger
+    include Observable
+    include Finder
+
+    attr_reader :monitor
+
+    attr_reader :file
+
+    def initialize machine = Machine.new
+      @stack = []
+      @threads = {}
+      @frames = {}
+      @running = false
+      @attached = false
+      @request = nil
+      @config = {}
+      @original_argv = ARGV.clone
+      @machine = machine
+    end
+
+    def config arguments, request
+      @file = Readapt.normalize_path(find(arguments['program']))
+      @config = arguments
+      @request = request
+    rescue LoadError => e
+      STDERR.puts e.message
+    end
+
+    # @return [Readapt::Thread]
+    def thread id
+      @threads[id] || Thread::NULL_THREAD
+    end
+
+    def threads
+      @threads.values
+    end
+
+    def frame id
+      @frames[id] || Frame::NULL_FRAME
+    end
+
+    def launched?
+      @request == :launch
+    end
+
+    def attached?
+      @request == :attach
+    end
+
+    def start
+      ::Thread.new do
+        run { load @file }
+      end
+    end
+
+    def run
+      # raise RuntimeError, 'Debugger is already running' if @running
+      set_program_args
+      @running = true
+      send_event('process', {
+        name: @file
+      })
+      Monitor.start do |snapshot|
+        debug snapshot
+      end
+      yield if block_given?
+    rescue StandardError => e
+      STDERR.puts e.message
+      STDERR.puts e.backtrace.join("\n")
+    rescue SystemExit
+      # Ignore
+    ensure
+      Monitor.stop
+      @running = false
+      set_original_args
+      changed
+      send_event 'terminated', nil
+    end
+
+    def output data, category = :console
+      send_event('output', {
+        output: data,
+        category: category
+      })
+    end
+
+    def disconnect
+      shutdown if launched?
+      @request = nil
+    end
+
+    def self.run &block
+      new.run &block
+    end
+
+    private
+
+    # @param [Snapshot]
+    # return [void]
+    def debug snapshot
+      if (snapshot.event == :thread_begin)
+        thr = Thread.new(snapshot.thread_id)
+        thr.control = :continue
+        @threads[snapshot.thread_id] = thr
+        send_event('thread', {
+          reason: 'started',
+          threadId: snapshot.thread_id
+        }, true)
+        snapshot.control = :continue
+      elsif (snapshot.event == :thread_end)
+        thr = thread(snapshot.thread_id)
+        thr.control = :continue
+        @threads.delete snapshot.thread_id
+        send_event('thread', {
+          reason: 'exited',
+          threadId: snapshot.thread_id
+        })
+        snapshot.control = :continue
+      elsif snapshot.event == :initialize
+        if snapshot.file != @file
+          snapshot.control = :wait
+        else
+          snapshot.control = :ready
+        end
+      elsif snapshot.event == :entry
+        snapshot.control = :continue
+      else
+        changed
+        thread = self.thread(snapshot.thread_id)
+        thread.control = :pause
+        frame = Frame.new(Location.new(snapshot.file, snapshot.line), snapshot.binding_id)
+        thread.frames.push frame
+        @frames[frame.local_id] = frame
+        send_event('stopped', {
+          reason: snapshot.event,
+          threadId: ::Thread.current.object_id
+        })
+        sleep 0.01 until thread.control != :pause || !@threads.key?(thread.id)
+        @frames.delete frame.local_id
+        thread.frames.delete frame
+        snapshot.control = thread.control
+      end
+    end
+
+    def set_program_args
+      ARGV.clear
+      ARGV.replace(@config['programArgs'] || [])
+    end
+
+    def set_original_args
+      ARGV.clear
+      ARGV.replace @original_argv
+    end
+
+    def shutdown
+      @machine.stop
+      exit
+    end
+
+    def send_event event, data, wait = false
+      changed
+      notify_observers event, data
+      sleep 0.01 if wait
+    end
+  end
+end