readapt 0.7.1 → 1.1.1

data/ext/readapt/stack.h

@@ -0,0 +1,20 @@
+#ifndef STACK_H_
+#define STACK_H_
+
+#include "stddef.h"
+
+typedef struct readapt_stack_struct {
+    int size;
+    size_t elem_size;
+    void (*free_func)(void *);
+    int capacity;
+    void **elements;
+} readapt_stack_t;
+
+readapt_stack_t *stack_alloc(size_t elem_size, void(*free_func)(void*));
+void stack_push(readapt_stack_t *stack, void *element);
+void *stack_peek(readapt_stack_t *stack);
+void stack_pop(readapt_stack_t *stack);
+void stack_free(readapt_stack_t *stack);
+
+#endif

data/ext/readapt/threads.c

@@ -1,15 +1,24 @@
 #include "ruby.h"
 #include "ruby/debug.h"
 #include "threads.h"
+#include "frame.h"
+#include "inspector.h"
 
+static VALUE c_Thread;
 static VALUE threads;
+static VALUE ids;
+static int next_id;
 
-void thread_reference_free(void* data)
+static void thread_reference_free(void* data)
 {
-	free(data);
+	thread_reference_t* thr;
+
+	thr = data;
+	stack_free(thr->frames);
+	free(thr);
 }
 
-size_t thread_reference_size(const void* data)
+static size_t thread_reference_size(const void* data)
 {
 	return sizeof(thread_reference_t);
 }
@@ -25,20 +34,16 @@ static const rb_data_type_t thread_reference_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-void initialize_threads()
-{
-	threads = rb_hash_new();
-	rb_global_variable(&threads);
-}
-
-VALUE thread_reference_new(VALUE thr)
+static 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;
+	VALUE obj = TypedData_Make_Struct(c_Thread, thread_reference_t, &thread_reference_type, data);
+	data->id = next_id;
 	data->cursor = 0;
+	data->depth = 0;
 	data->control = rb_intern("continue");
+	data->frames = stack_alloc(sizeof(frame_t), frame_free);
+	next_id++;
 	return obj;
 }
 
@@ -61,22 +66,25 @@ VALUE thread_reference(VALUE thr)
 
 VALUE thread_reference_id(VALUE id)
 {
-	return rb_hash_aref(threads, id);
+	return rb_hash_aref(ids, id);
 }
 
 VALUE thread_add_reference(VALUE thr)
 {
 	VALUE ref;
+	thread_reference_t *ptr;
 
 	ref = thread_reference_new(thr);
+	ptr = thread_reference_pointer(ref);
 	rb_hash_aset(threads, rb_obj_id(thr), ref);
+	rb_hash_aset(ids, INT2NUM(ptr->id), ref);
 	return ref;
 }
 
 VALUE thread_delete_reference(VALUE thr)
 {
-	rb_hash_delete(threads, thr);
-	return Qnil;
+	// TODO: Do we need to delete from ids here?
+	return rb_hash_delete(threads, rb_obj_id(thr));
 }
 
 void thread_pause()
@@ -95,7 +103,93 @@ void thread_pause()
 	}
 }
 
-void thread_reset()
+void thread_clear()
 {
 	rb_funcall(threads, rb_intern("clear"), 0);
+	rb_funcall(ids, rb_intern("clear"), 0);
+}
+
+static VALUE thread_allocate_s(VALUE self)
+{
+	thread_reference_t *data = malloc(sizeof(thread_reference_t));
+	data->control = rb_intern("continue");
+	data->depth = 0;
+	data->cursor = 0;
+	data->frames = stack_alloc(sizeof(frame_t), frame_free);
+	data->id = 0;
+	return TypedData_Wrap_Struct(self, &thread_reference_type, data);
+}
+
+static VALUE thread_all_s(VALUE self)
+{
+	return rb_funcall(threads, rb_intern("values"), 0);
+}
+
+static VALUE thread_find_s(VALUE self, VALUE id)
+{
+	return thread_reference_id(id);
+}
+
+static VALUE thread_include_s(VALUE self, VALUE id)
+{
+	return rb_funcall(ids, rb_intern("include?"), 1, id);
+}
+
+static VALUE thread_id_m(VALUE self)
+{
+	thread_reference_t *data = thread_reference_pointer(self);
+	return LONG2NUM(data->id);
+}
+
+static VALUE frames_m(VALUE self)
+{
+	thread_reference_t *data;
+	VALUE ary;
+	VALUE frm;
+	int i;
+	frame_t *fd;
+
+	ary = rb_ary_new();
+	data = thread_reference_pointer(self);
+	for (i = data->frames->size - 1; i >= 0; i--)
+	{
+		fd = data->frames->elements[i];
+		// TODO This condition should probably not be necessary.
+		if (fd->binding != Qnil)
+		{
+			frm = frame_new_from_data(fd);
+			rb_ary_push(ary, frm);
+		}
+	}
+
+	return ary;
+}
+
+void thread_reference_build_frames(thread_reference_t *ptr)
+{
+	inspector_inspect(ptr);
+}
+
+void thread_reference_clear_frames(thread_reference_t *ptr)
+{
+	stack_free(ptr->frames);
+	ptr->frames = stack_alloc(sizeof(frame_t), frame_free);
+}
+
+void initialize_threads(VALUE m_Readapt)
+{
+	next_id = 1;
+
+	c_Thread = rb_define_class_under(m_Readapt, "Thread", rb_cData);
+	rb_define_alloc_func(c_Thread, thread_allocate_s);
+	rb_define_method(c_Thread, "id", thread_id_m, 0);
+	rb_define_method(c_Thread, "frames", frames_m, 0);
+	rb_define_singleton_method(c_Thread, "all", thread_all_s, 0);
+	rb_define_singleton_method(c_Thread, "find", thread_find_s, 1);
+	rb_define_singleton_method(c_Thread, "include?", thread_include_s, 1);
+
+	threads = rb_hash_new();
+	rb_global_variable(&threads);
+	ids = rb_hash_new();
+	rb_global_variable(&ids);
 }

data/ext/readapt/threads.h

@@ -1,21 +1,28 @@
 #ifndef THREADS_H_
 #define THREADS_H_
 
+#include "ruby.h"
+#include "frame.h"
+#include "stack.h"
+
 typedef struct thread_reference_struct {
-	long id;
-	int depth;
+	int id;
 	int cursor;
+	int depth;
 	ID control;
+	readapt_stack_t *frames;
 } thread_reference_t;
 
-void initialize_threads();
+void initialize_threads(VALUE);
 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_reference_build_frames(thread_reference_t *);
+void thread_reference_clear_frames(thread_reference_t *);
 void thread_pause();
-void thread_reset();
+void thread_clear();
 
 #endif

data/lib/readapt.rb

@@ -1,19 +1,21 @@
-require 'backport'
-
-require 'readapt/version'
-require 'readapt/breakpoint'
-require 'readapt/location'
-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
-end
+require 'backport'
+
+require 'readapt/version'
+require 'readapt/readapt'
+require 'readapt/references'
+require 'readapt/breakpoint'
+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/data_reader'
+require 'readapt/server'
+require 'readapt/adapter'
+require 'readapt/input'
+require 'readapt/output'
+require 'readapt/error'
+require 'readapt/shell'

data/lib/readapt/adapter.rb

@@ -1,138 +1,98 @@
-# 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
+# frozen_string_literal: true
+
+require 'json'
+
+module Readapt
+  module Adapter
+    # @!parse include Backport::Adapter
+
+    @@debugger = nil
+
+    def self.host debugger
+      @@debugger = debugger
+    end
+
+    def self.procid= pid
+      @@procid = pid
+    end
+
+    def procid
+      @@procid
+    end
+
+    def open_message
+      @@open_message ||= "<readapt-#{procid}>"
+    end
+
+    def close_message
+      @@close_message ||= "</readapt-#{procid}>"
+    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 = "#{open_message}Content-Length: #{json.bytesize}\r\n\r\n#{json}#{close_message}"
+      write envelope
+      write "#{open_message}__TERMINATE__#{close_message}" if event == 'terminated'
+    end
+
+    private
+
+    # @param data [Hash]
+    # @return [void]
+    def process data
+      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 "#{open_message}#{envelope}#{close_message}"
+        if data['command'] == 'disconnect'
+          @@debugger.disconnect
+          # @todo It does not appear necessary to close the adapter after
+          #   disconnecting the debugger.
+          # close
+        end
+        return unless data['command'] == 'initialize'
+        json = {
+          type: 'event',
+          event: 'initialized'
+        }.to_json
+        envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+        write "#{open_message}#{envelope}#{close_message}"
+      end
+    rescue RuntimeError => e
+      STDERR.puts "[#{e.class}] #{e.message}"
+      STDERR.puts e.backtrace.join
+    end
+  end
+end