readapt 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c67633f1de57cb29613083f2e241ad6ca9c3f86b0d273fbd1e78e86d7a804b37
+  data.tar.gz: 0c3994366532e303edc51afd01642a3417c8247ef5af5d9cd16942b385de41c3
+SHA512:
+  metadata.gz: 9cd6fa0b2a4a3f17e9bc8ef2e44fc8b553667ece8eff3313c8be1dc582a55436f4a909ed33fcd4b01d73e0a2f77b6f3a99dca9c94f66260e8b57193cb01f9276
+  data.tar.gz: bdbda94a34fb6c36cc8ad867ca5def4ea950d03066ef07b6b2e7b44819ea77e13382594ecf909464850cb99aa2d76933e1d37a932a12e48da904c65a13180995

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.so
+/.vscode/
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,13 @@
+---
+sudo: false
+language: ruby
+rvm:
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+before_script:
+- bundle install
+- rake compile
+script: rspec

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# 0.3.1 - August 10. 2019
+- Require Ruby >= 2.2
+
+# 0.3.0 - August 9. 2019
+- Synchronized events
+- Handle multiple paused threads
+- Isolate the Backport machine
+
+# 0.2.0 - August 7, 2019
+- Find external programs
+- Improved stdout/stderr redirects
+- Individual thread control
+
+# 0.1.0 - August 5, 2019
+- First release

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in readapt.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Fred Snyder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Readapt
+
+A Ruby debugger that supports the [Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/specification).
+
+*This gem is currently in early development*.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'readapt'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install readapt
+
+## Usage
+
+Run `readapt serve` to start the server. The default client connection is host 127.0.0.1, port 1234.
+
+## Integrations
+
+Readapt is available for Visual Studio Code in the [Ruby Debug extension](https://marketplace.visualstudio.com/items?itemName=castwide.ruby-debug).

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+require 'readapt/version'
+require 'tmpdir'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+# Compile tasks
+Rake::ExtensionTask.new "readapt" do |ext|
+  ext.lib_dir = "lib/readapt"
+end
+
+namespace :install do
+  desc 'Install on Windows'
+  task :win do
+    Dir.mktmpdir do |tmp|
+      gemfile = File.join(tmp, 'readapt.gem')
+      system("gem build readapt.gemspec -o #{gemfile}") &&
+        system("gem install #{gemfile}")
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "readapt"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/readapt

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "readapt"
+
+Readapt::Shell.start(ARGV)

data/ext/readapt/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "readapt/readapt"

data/ext/readapt/monitor.c

@@ -0,0 +1,332 @@
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "threads.h"
+
+static VALUE m_Monitor;
+static VALUE c_Snapshot;
+
+static VALUE tpLine;
+static VALUE tpCall;
+static VALUE tpReturn;
+static VALUE tpThreadBegin;
+static VALUE tpThreadEnd;
+static VALUE debugProc;
+static VALUE breakpoints;
+static int knownBreakpoints;
+static int firstLineEvent = 0;
+
+static int match_line(VALUE next_file, int next_line, thread_reference_t *ptr)
+{
+	if (rb_str_equal(next_file, ptr->prev_file) && next_line == ptr->prev_line) {
+		return 1;
+	}
+	return 0;
+}
+
+static int match_breakpoint(VALUE file, int line)
+{
+	VALUE bps, b;
+	long len, i;
+
+	bps = rb_funcall(breakpoints, rb_intern("for"), 1, file);
+	len = rb_array_len(bps);
+	for (i = 0; i < len; i++)
+	{
+		b = rb_ary_entry(bps, i);
+		if (NUM2INT(rb_funcall(b, rb_intern("line"), 0)) == line)
+		{
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static int match_step(thread_reference_t *ptr)
+{
+	if (ptr->control == rb_intern("continue"))
+	{
+		return 0;
+	}
+	else if (ptr->control == rb_intern("next") && ptr->cursor >= ptr->depth)
+	{
+		return 1;
+	}
+	else if (ptr->control == rb_intern("step_in") && ptr->cursor < ptr->depth)
+	{
+		return 1;
+	}
+	else if (ptr->control == rb_intern("step_out") && ptr->cursor > ptr->depth)
+	{
+		return 1;
+	}
+	return 0;
+}
+
+static ID
+monitor_debug(VALUE file, int line, VALUE tracepoint, thread_reference_t *ptr, ID event)
+{
+	VALUE bind, bid, snapshot, result;
+
+	bind = rb_funcall(tracepoint, rb_intern("binding"), 0);
+	bid = rb_funcall(bind, rb_intern("object_id"), 0);
+	snapshot = rb_funcall(c_Snapshot, rb_intern("new"), 7,
+		LONG2NUM(ptr->id),
+		bid,
+		file,
+		INT2NUM(line),
+		Qnil,
+		ID2SYM(event),
+		INT2NUM(ptr->depth)
+	);
+	rb_io_flush(rb_stdout);
+	rb_io_flush(rb_stderr);
+	rb_funcall(debugProc, rb_intern("call"), 1, snapshot);
+	result = SYM2ID(rb_funcall(snapshot, rb_intern("control"), 0));
+	if (event != rb_intern("initialize"))
+	{
+		ptr->cursor = ptr->depth;
+		ptr->control = result;
+	}
+	ptr->prev_file = file;
+	ptr->prev_line = line;
+	return result;
+}
+
+static void
+process_line_event(VALUE tracepoint, void *data)
+{
+	VALUE ref, tp_file;
+	int tp_line;
+	thread_reference_t *ptr;
+	rb_trace_arg_t *tp;
+	int threadPaused;
+	ID dapEvent, result;
+
+	ref = thread_current_reference();
+	if (!RB_NIL_P(ref))
+	{
+		ptr = thread_reference_pointer(ref);
+		if (ptr->depth > 0 /*|| !firstLineEvent*/)
+		{
+			threadPaused = (ptr->control == rb_intern("pause"));
+			if (!firstLineEvent || threadPaused || knownBreakpoints || ptr->control != rb_intern("continue"))
+			{
+				tp = rb_tracearg_from_tracepoint(tracepoint);
+				tp_file = rb_tracearg_path(tp);
+				tp_line = NUM2INT(rb_tracearg_lineno(tp));
+
+				dapEvent = NULL;
+				if (!firstLineEvent)
+				{
+					dapEvent = rb_intern("initialize");
+				}
+				else if (threadPaused)
+				{
+					dapEvent = rb_intern("pause");
+				}
+				else if (match_step(ptr))
+				{
+					dapEvent = rb_intern("step");
+				}
+				else if (match_breakpoint(tp_file, tp_line))
+				{
+					dapEvent = rb_intern("breakpoint");
+				}
+				else if (ptr->control == rb_intern("entry"))
+				{
+					dapEvent = rb_intern("entry");
+				}
+				if (dapEvent)
+				{
+					result = monitor_debug(tp_file, tp_line, tracepoint, ptr, dapEvent);
+					if (dapEvent == rb_intern("initialize") && result == rb_intern("ready"))
+					{
+						firstLineEvent = 1;
+						ptr->control = rb_intern("entry");
+						process_line_event(tracepoint, data);
+					}
+				}
+			}
+			else
+			{
+				ptr->prev_file = Qnil;
+				ptr->prev_line = Qnil;
+			}
+		}
+	}
+}
+
+static void
+process_call_event(VALUE tracepoint, void *data)
+{
+	VALUE ref;
+	thread_reference_t *ptr;
+
+	ref = thread_current_reference();
+	if (!RB_NIL_P(ref))
+	{
+		ptr = thread_reference_pointer(ref);
+		ptr->depth++;
+	}
+}
+
+static void
+process_return_event(VALUE tracepoint, void *data)
+{
+	VALUE ref;
+	thread_reference_t *ptr;
+	
+	ref = thread_current_reference();
+	if (!RB_NIL_P(ref))
+	{
+		ptr = thread_reference_pointer(ref);
+		ptr->depth--;
+	}
+}
+
+static void
+process_thread_begin_event(VALUE tracepoint, void *data)
+{
+	VALUE list, here, prev, ref;
+	thread_reference_t *ptr;
+
+	list = rb_funcall(rb_cThread, rb_intern("list"), 0);
+	here = rb_ary_pop(list);
+	if (!RB_NIL_P(here))
+	{
+		prev = rb_ary_pop(list);
+		{
+			if (!RB_NIL_P(prev))
+			{
+				ref = thread_reference(prev);
+				if (!RB_NIL_P(ref))
+				{
+					ref = thread_add_reference(here);
+					ptr = thread_reference_pointer(ref);
+					monitor_debug(
+						rb_funcall(tracepoint, rb_intern("path"), 0),
+						NUM2INT(rb_funcall(tracepoint, rb_intern("lineno"), 0)),
+						tracepoint,
+						ptr,
+						rb_intern("thread_begin")
+					);
+				}
+			}
+		}
+	}
+}
+
+static void
+process_thread_end_event(VALUE tracepoint, void *data)
+{
+	VALUE thr, ref;
+	thread_reference_t *ptr;
+
+	thr = rb_thread_current();
+	ref = thread_reference(thr);
+	if (!RB_NIL_P(ref))
+	{
+		ptr = thread_reference_pointer(ref);
+		monitor_debug(ptr->prev_file, ptr->prev_line, tracepoint, ptr, rb_intern("thread_end"));
+		thread_delete_reference(thr);
+	}
+}
+
+static VALUE
+monitor_enable_s(VALUE self)
+{
+	VALUE previous, ref;
+	thread_reference_t *ptr;
+
+	if (rb_block_given_p()) {
+		debugProc = rb_block_proc();
+		rb_global_variable(&debugProc);
+	} else {
+		rb_raise(rb_eArgError, "must be called with a block");
+	}
+
+	firstLineEvent = 0;
+
+	ref = thread_add_reference(rb_thread_current());
+	ptr = thread_reference_pointer(ref);
+	monitor_debug(
+		Qnil,
+		0,
+		Qnil,
+		ptr,
+		rb_intern("thread_begin")
+	);
+
+	previous = rb_tracepoint_enabled_p(tpLine);
+	rb_tracepoint_enable(tpLine);
+	rb_tracepoint_enable(tpCall);
+	rb_tracepoint_enable(tpReturn);
+	rb_tracepoint_enable(tpThreadBegin);
+	rb_tracepoint_enable(tpThreadEnd);
+	return previous;
+}
+
+static VALUE
+monitor_disable_s(VALUE self)
+{
+	VALUE previous;
+
+	previous = rb_tracepoint_enabled_p(tpLine);
+	rb_tracepoint_disable(tpLine);
+	rb_tracepoint_disable(tpCall);
+	rb_tracepoint_disable(tpReturn);
+	rb_tracepoint_disable(tpThreadBegin);
+	rb_tracepoint_disable(tpThreadEnd);
+	
+	return previous;
+}
+
+static VALUE
+monitor_pause_s(VALUE self, VALUE id)
+{
+	VALUE ref;
+	thread_reference_t *ptr;
+
+	ref = thread_reference_id(id);
+	if (!RB_NIL_P(ref))
+	{
+		ptr = thread_reference_pointer(ref);
+		ptr->control = rb_intern("pause");
+	}
+}
+
+static VALUE
+monitor_know_breakpoints_s(VALUE self)
+{
+	knownBreakpoints = (rb_funcall(breakpoints, rb_intern("empty?"), 0) == Qfalse) ? 1 : 0;
+	return Qnil;
+}
+
+void initialize_monitor(VALUE m_Readapt)
+{
+	m_Monitor = rb_define_module_under(m_Readapt, "Monitor");
+	c_Snapshot = rb_define_class_under(m_Readapt, "Snapshot", rb_cObject);
+
+	initialize_threads();
+
+	rb_define_singleton_method(m_Monitor, "start", monitor_enable_s, 0);
+	rb_define_singleton_method(m_Monitor, "stop", monitor_disable_s, 0);
+	rb_define_singleton_method(m_Monitor, "know_breakpoints", monitor_know_breakpoints_s, 0);
+	rb_define_singleton_method(m_Monitor, "pause", monitor_pause_s, 1);
+
+	tpLine = rb_tracepoint_new(Qnil, RUBY_EVENT_LINE, process_line_event, NULL);
+	tpCall = rb_tracepoint_new(Qnil, RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS, process_call_event, NULL);
+	tpReturn = rb_tracepoint_new(Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_END, process_return_event, NULL);
+	tpThreadBegin = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_BEGIN, process_thread_begin_event, NULL);
+	tpThreadEnd = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_END, process_thread_end_event, NULL);
+	debugProc = Qnil;
+	breakpoints = rb_funcall(m_Monitor, rb_intern("breakpoints"), 0);
+	knownBreakpoints = 0;
+
+	// Avoid garbage collection
+	rb_global_variable(&tpLine);
+	rb_global_variable(&tpCall);
+	rb_global_variable(&tpReturn);
+	rb_global_variable(&tpThreadBegin);
+	rb_global_variable(&tpThreadEnd);
+}