readapt 1.4.4 → 2.0.0

data/ext/readapt/stack.c

@@ -1,86 +1,86 @@
-#include <stdlib.h>
-#include "stack.h"
-
-#define STACK_CAPACITY 20
-
-/**
- * Allocate a stack. The `elem_size` is the expected size of each element,
- * e.g., `sizeof(some_struct)`. The optional `free_func` argument is a pointer
- * to a function that will be called when an element is popped off the stack.
- */
-readapt_stack_t *stack_alloc(size_t elem_size, void (*free_func)(void *))
-{
-    readapt_stack_t *s = malloc(sizeof(readapt_stack_t));
-    s->elem_size = elem_size;
-    s->free_func = free_func;
-    s->size = 0;
-    s->capacity = 0;
-    return s;
-}
-
-/**
- * Add an element to the end of the stack
- */
-void stack_push(readapt_stack_t *stack, void *element)
-{
-    if (stack->size == stack->capacity)
-    {
-        if (stack->capacity == 0)
-        {
-            stack->capacity = STACK_CAPACITY;
-            stack->elements = malloc(stack->elem_size * stack->capacity);
-        }
-        else
-        {
-            stack->capacity += STACK_CAPACITY;
-            stack->elements = realloc(stack->elements, stack->elem_size * stack->capacity);
-        }
-    }
-    stack->elements[stack->size] = element;
-    stack->size++;
-}
-
-/**
- * Get a pointer to the last element in the stack.
- */
-void *stack_peek(readapt_stack_t *stack)
-{
-    return stack->size == 0 ? NULL : stack->elements[stack->size - 1];
-}
-
-/**
- * Pop the last element off the stack and pass it to free_func.
- */
-void stack_pop(readapt_stack_t *stack)
-{
-    void *e;
-
-    if (stack->size > 0)
-    {
-        e = stack->elements[stack->size - 1];
-        if (stack->free_func)
-        {
-            stack->free_func(e);
-        }
-        // stack->elements[stack->size - 1] = NULL;
-        stack->size--;
-    }
-}
-
-/**
- * Free the stack from memory. If it still contains any elements, pass them to
- * free_func.
- */
-void stack_free(readapt_stack_t *stack)
-{
-    int i;
-
-    if (stack->free_func)
-    {
-        for (i = 0; i < stack->size; i++)
-        {
-            stack->free_func(stack->elements[i]);
-        }
-    }
-    free(stack);
-}
+#include <stdlib.h>
+#include "stack.h"
+
+#define STACK_CAPACITY 20
+
+/**
+ * Allocate a stack. The `elem_size` is the expected size of each element,
+ * e.g., `sizeof(some_struct)`. The optional `free_func` argument is a pointer
+ * to a function that will be called when an element is popped off the stack.
+ */
+readapt_stack_t *stack_alloc(size_t elem_size, void (*free_func)(void *))
+{
+    readapt_stack_t *s = malloc(sizeof(readapt_stack_t));
+    s->elem_size = elem_size;
+    s->free_func = free_func;
+    s->size = 0;
+    s->capacity = 0;
+    return s;
+}
+
+/**
+ * Add an element to the end of the stack
+ */
+void stack_push(readapt_stack_t *stack, void *element)
+{
+    if (stack->size == stack->capacity)
+    {
+        if (stack->capacity == 0)
+        {
+            stack->capacity = STACK_CAPACITY;
+            stack->elements = malloc(stack->elem_size * stack->capacity);
+        }
+        else
+        {
+            stack->capacity += STACK_CAPACITY;
+            stack->elements = realloc(stack->elements, stack->elem_size * stack->capacity);
+        }
+    }
+    stack->elements[stack->size] = element;
+    stack->size++;
+}
+
+/**
+ * Get a pointer to the last element in the stack.
+ */
+void *stack_peek(readapt_stack_t *stack)
+{
+    return stack->size == 0 ? NULL : stack->elements[stack->size - 1];
+}
+
+/**
+ * Pop the last element off the stack and pass it to free_func.
+ */
+void stack_pop(readapt_stack_t *stack)
+{
+    void *e;
+
+    if (stack->size > 0)
+    {
+        e = stack->elements[stack->size - 1];
+        if (stack->free_func)
+        {
+            stack->free_func(e);
+        }
+        // stack->elements[stack->size - 1] = NULL;
+        stack->size--;
+    }
+}
+
+/**
+ * Free the stack from memory. If it still contains any elements, pass them to
+ * free_func.
+ */
+void stack_free(readapt_stack_t *stack)
+{
+    int i;
+
+    if (stack->free_func)
+    {
+        for (i = 0; i < stack->size; i++)
+        {
+            stack->free_func(stack->elements[i]);
+        }
+    }
+    free(stack);
+}

data/ext/readapt/stack.h

@@ -1,20 +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
+#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

@@ -190,7 +190,7 @@ void initialize_threads(VALUE m_Readapt)
 {
 	next_id = 1;
 
-	c_Thread = rb_define_class_under(m_Readapt, "Thread", rb_cData);
+	c_Thread = rb_define_class_under(m_Readapt, "Thread", rb_cObject);
 	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);

data/lib/readapt/adapter.rb

@@ -1,98 +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 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
+# 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

data/lib/readapt/breakpoint.rb

@@ -1,21 +1,21 @@
-module Readapt
-  class Breakpoint
-    attr_reader :source
-    attr_reader :line
-    attr_reader :condition
-    attr_reader :hit_condition
-    attr_writer :hit_cursor
-
-    def initialize source, line, condition, hit_condition
-      @source = source
-      @line = line
-      @condition = condition
-      @hit_condition = hit_condition
-    end
-
-    # @return [Integer]
-    def hit_cursor
-      @hit_cursor ||= 0
-    end
-  end
-end
+module Readapt
+  class Breakpoint
+    attr_reader :source
+    attr_reader :line
+    attr_reader :condition
+    attr_reader :hit_condition
+    attr_writer :hit_cursor
+
+    def initialize source, line, condition, hit_condition
+      @source = source
+      @line = line
+      @condition = condition
+      @hit_condition = hit_condition
+    end
+
+    # @return [Integer]
+    def hit_cursor
+      @hit_cursor ||= 0
+    end
+  end
+end

data/lib/readapt/data_reader.rb

@@ -1,62 +1,62 @@
-module Readapt
-  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
+module Readapt
+  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