reflex-terminal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7279668d5fe73e778c224a568ae79b829c138117f4d1458d73278451847a7f5
+  data.tar.gz: 157ebc265844d375f75b258f87890ce561e93a5c2225b64800e6063f02d53d1e
+SHA512:
+  metadata.gz: f3ebfbc2b62e3b3d2d2194d9c278518a2bb2966b34e6f6e8a8bf48ae44f862a520e75742746107db912847989bf09355c805c4799836c73f87739d0f19c99471
+  data.tar.gz: a402b3b23959dc21c314a2d39ddda704363f0740a9603ed1ee5cfeb8e590ae6ce77ec9c44cf4edc4e0f7033d4ab428cb67a3b5fef3f1719f20edc2348b5757b7

data/.doc/ext/reflex-terminal/native.cpp

@@ -0,0 +1,19 @@
+#include "defs.h"
+
+
+void Init_reflex_terminal ();
+void Init_reflex_terminal_renderer ();
+
+
+extern "C" void
+Init_reflex_terminal_ext ()
+{
+	RUCY_TRY
+
+	Rucy::init();
+
+	Init_reflex_terminal();
+	Init_reflex_terminal_renderer();
+
+	RUCY_CATCH
+}

data/.doc/ext/reflex-terminal/renderer.cpp

@@ -0,0 +1,110 @@
+#include "reflex-terminal/ruby/renderer.h"
+
+
+#include <rays/ruby/bounds.h>
+#include <rays/ruby/font.h>
+#include <rays/ruby/painter.h>
+#include <reflex-terminal/ruby/terminal.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_TERMINAL_EXPORT, ReflexTerminal::Renderer)
+
+#define THIS  to<ReflexTerminal::Renderer*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(ReflexTerminal::Renderer, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<ReflexTerminal::Renderer>(klass);
+}
+
+static
+VALUE set_font(VALUE self, VALUE font)
+{
+	CHECK;
+	THIS->set_font(to<Rays::Font&>(font));
+	return font;
+}
+
+static
+VALUE get_font(VALUE self)
+{
+	CHECK;
+	return value(THIS->font());
+}
+
+static
+VALUE get_cell_width(VALUE self)
+{
+	CHECK;
+	return value(THIS->cell_width());
+}
+
+static
+VALUE get_cell_height(VALUE self)
+{
+	CHECK;
+	return value(THIS->cell_height());
+}
+
+static
+VALUE bake_glyphs(VALUE self, VALUE terminal)
+{
+	CHECK;
+	THIS->bake_glyphs(to<Reflex::Terminal&>(terminal));
+	return self;
+}
+
+static
+VALUE get_glyph_count(VALUE self)
+{
+	CHECK;
+	return value(THIS->glyph_count());
+}
+
+static
+VALUE draw(VALUE self, VALUE painter, VALUE terminal, VALUE bounds)
+{
+	CHECK;
+	THIS->draw(
+		to<Rays::Painter*>(painter),
+		to<Reflex::Terminal&>(terminal),
+		to<Rays::Bounds>(bounds));
+	return self;
+}
+
+
+static Class cRenderer;
+
+void
+Init_reflex_terminal_renderer ()
+{
+	Module mReflexTerminal = rb_define_module("ReflexTerminal");
+
+	cRenderer = rb_define_class_under(mReflexTerminal, "Renderer", rb_cObject);
+	rb_define_alloc_func(cRenderer, alloc);
+	rb_define_method(cRenderer, "font=", RUBY_METHOD_FUNC(set_font), 1);
+	rb_define_method(cRenderer, "font", RUBY_METHOD_FUNC(get_font), 0);
+	rb_define_method(cRenderer, "cell_width", RUBY_METHOD_FUNC(get_cell_width), 0);
+	rb_define_method(cRenderer, "cell_height", RUBY_METHOD_FUNC(get_cell_height), 0);
+	rb_define_method(cRenderer, "bake_glyphs", RUBY_METHOD_FUNC(bake_glyphs), 1);
+	rb_define_method(cRenderer, "glyph_count", RUBY_METHOD_FUNC(get_glyph_count), 0);
+	rb_define_method(cRenderer, "draw", RUBY_METHOD_FUNC(draw), 3);
+}
+
+
+namespace ReflexTerminal
+{
+
+
+	Class
+	renderer_class ()
+	{
+		return cRenderer;
+	}
+
+
+}// ReflexTerminal

data/.doc/ext/reflex-terminal/terminal.cpp

@@ -0,0 +1,530 @@
+#include "reflex-terminal/ruby/terminal.h"
+
+
+#include <xot/exception.h>
+#include <rays/ruby/color.h>
+#include <reflex/ruby/event.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_TERMINAL_EXPORT, Reflex::Terminal)
+
+RUCY_DEFINE_CONVERT_TO(REFLEX_TERMINAL_EXPORT, Reflex::Terminal::OptionAsAlt)
+
+#define THIS  to<Reflex::Terminal*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Reflex::Terminal, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Terminal>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE columns, VALUE rows, VALUE scrollback)
+{
+	RUCY_CHECK_OBJ(Reflex::Terminal, self);
+
+	*THIS = Reflex::Terminal(to<int>(columns), to<int>(rows), to<size_t>(scrollback));
+	return self;
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	Xot::invalid_state_error(__FILE__, __LINE__, "can not duplicate Terminal");
+}
+
+static
+VALUE update(VALUE self)
+{
+	CHECK;
+	return value(THIS->update());
+}
+
+static
+VALUE reset(VALUE self)
+{
+	CHECK;
+	THIS->reset();
+	return self;
+}
+
+static
+VALUE resize(VALUE self, VALUE columns, VALUE rows, VALUE cell_width, VALUE cell_height, VALUE screen_width, VALUE screen_height)
+{
+	CHECK;
+	THIS->resize(
+		to<int>(columns),      to<int>(rows),
+		to<int>(cell_width),   to<int>(cell_height),
+		to<int>(screen_width), to<int>(screen_height));
+	return self;
+}
+
+static
+VALUE feed(VALUE self, VALUE bytes)
+{
+	CHECK;
+	if (!bytes.is_s())
+		Rucy::type_error(__FILE__, __LINE__, "bytes must be a String");
+
+	// feed() takes a raw byte stream, so avoid to<const char*>/c_str()
+	// (StringValueCStr rejects NUL bytes) and Value#size (character
+	// count, not the byte length)
+	RubyValue str = bytes.value();
+	THIS->feed(RSTRING_PTR(str), RSTRING_LEN(str));
+	return self;
+}
+
+static
+VALUE read_pending_input(VALUE self)
+{
+	CHECK;
+	// a raw byte stream for the child process
+	Reflex::String input = THIS->read_pending_input();
+	return value(input.data(), input.size(), rb_ascii8bit_encoding());
+}
+
+static
+VALUE spawn(VALUE self, VALUE args, VALUE envs)
+{
+	CHECK;
+
+	Reflex::StringList list;
+	for (size_t i = 0, size = args.size(); i < size; ++i)
+		list.emplace_back(args[i].c_str());
+
+	Reflex::Terminal::EnvMap map;
+	Value names = envs.call("keys");
+	for (size_t i = 0, size = names.size(); i < size; ++i)
+	{
+		Value name  = names[i];
+		Value value = envs.get(name);
+		if (value)
+			map[name.c_str()] = value.c_str();
+		else
+			map[name.c_str()] = std::nullopt;// nil removes the variable
+	}
+
+	THIS->spawn(list, map);
+	return self;
+}
+
+static
+VALUE close(VALUE self)
+{
+	CHECK;
+	THIS->close();
+	return self;
+}
+
+static
+VALUE write(VALUE self, VALUE bytes)
+{
+	CHECK;
+	if (!bytes.is_s())
+		Rucy::type_error(__FILE__, __LINE__, "bytes must be a String");
+
+	// write() takes a raw byte stream (see feed)
+	RubyValue str = bytes.value();
+	THIS->write(RSTRING_PTR(str), RSTRING_LEN(str));
+	return self;
+}
+
+static
+VALUE write_key(VALUE self, VALUE event)
+{
+	CHECK;
+	THIS->write_key(to<Reflex::KeyEvent&>(event));
+	return self;
+}
+
+static
+VALUE write_pointer(VALUE self, VALUE event)
+{
+	CHECK;
+	THIS->write_pointer(to<Reflex::PointerEvent&>(event));
+	return self;
+}
+
+static
+VALUE write_wheel(VALUE self, VALUE event)
+{
+	CHECK;
+	THIS->write_wheel(to<Reflex::WheelEvent&>(event));
+	return self;
+}
+
+static
+VALUE paste(VALUE self, VALUE text)
+{
+	CHECK;
+	if (!text.is_s())
+		Rucy::type_error(__FILE__, __LINE__, "text must be a String");
+
+	RubyValue str = text.value();
+	THIS->paste(RSTRING_PTR(str), RSTRING_LEN(str));
+	return self;
+}
+
+static
+VALUE is_alive(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_alive());
+}
+
+static
+VALUE is_mouse_tracking(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_mouse_tracking());
+}
+
+static
+VALUE select(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
+{
+	CHECK;
+	THIS->select(to<int>(x1), to<int>(y1), to<int>(x2), to<int>(y2));
+	return self;
+}
+
+static
+VALUE select_rect(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
+{
+	CHECK;
+	THIS->select_rect(to<int>(x1), to<int>(y1), to<int>(x2), to<int>(y2));
+	return self;
+}
+
+static
+VALUE select_word(VALUE self, VALUE x, VALUE y)
+{
+	CHECK;
+	THIS->select_word(to<int>(x), to<int>(y));
+	return self;
+}
+
+static
+VALUE select_line(VALUE self, VALUE y)
+{
+	CHECK;
+	THIS->select_line(to<int>(y));
+	return self;
+}
+
+static
+VALUE deselect(VALUE self)
+{
+	CHECK;
+	THIS->deselect();
+	return self;
+}
+
+static
+VALUE has_selection(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_selection());
+}
+
+static
+VALUE get_selected_text(VALUE self)
+{
+	CHECK;
+	Reflex::String text = THIS->selected_text();
+	return value(text.c_str(), text.size(), rb_utf8_encoding());
+}
+
+static
+VALUE scroll_to(VALUE self, VALUE row)
+{
+	CHECK;
+	THIS->scroll_to(to<int>(row));
+	return self;
+}
+
+static
+VALUE scroll_by(VALUE self, VALUE rows)
+{
+	CHECK;
+	THIS->scroll_by(to<int>(rows));
+	return self;
+}
+
+static
+VALUE get_scroll(VALUE self)
+{
+	CHECK;
+	return value(THIS->scroll());
+}
+
+static
+VALUE each_line(VALUE self)
+{
+	CHECK;
+
+	for (const auto& line : THIS->lines())
+		yield(value(line.c_str(), line.size(), rb_utf8_encoding()));
+	return self;
+}
+
+static
+VALUE each_span(VALUE self)
+{
+	CHECK;
+
+	const auto& rows = THIS->spans();
+	for (size_t y = 0; y < rows.size(); ++y)
+	{
+		for (const auto& span : rows[y])
+		{
+			yield(
+				value(span.x), value((int) y), value(span.width),
+				value(span.text.c_str(), span.text.size(), rb_utf8_encoding()),
+				span.fg == Reflex::Terminal::Span::COLOR_NONE ? nil() : value(span.fg),
+				span.bg == Reflex::Terminal::Span::COLOR_NONE ? nil() : value(span.bg),
+				value(span.attribs));
+		}
+	}
+	return self;
+}
+
+static
+VALUE set_option_as_alt(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_option_as_alt(to<Reflex::Terminal::OptionAsAlt>(state));
+	return state;
+}
+
+static
+VALUE get_option_as_alt(VALUE self)
+{
+	CHECK;
+	return value((int) THIS->option_as_alt());
+}
+
+static
+VALUE get_columns(VALUE self)
+{
+	CHECK;
+	return value(THIS->columns());
+}
+
+static
+VALUE get_rows(VALUE self)
+{
+	CHECK;
+	return value(THIS->rows());
+}
+
+static
+VALUE get_cursor(VALUE self)
+{
+	CHECK;
+
+	Reflex::Terminal::Cursor cursor = THIS->cursor();
+	Value values[] = {
+		value(cursor.x),
+		value(cursor.y),
+		value((int) cursor.style),
+		value(cursor.visible)
+	};
+	return array(values, 4);
+}
+
+static Reflex::Terminal::ColorIndex
+to_color_index (Value index)
+{
+	int i = to<int>(index);
+	if (i < Reflex::Terminal::COLOR_FOREGROUND || Reflex::Terminal::COLOR_PALETTE_LAST < i)
+		Rucy::argument_error(__FILE__, __LINE__, "invalid color index: %d", i);
+
+	return (Reflex::Terminal::ColorIndex) i;
+}
+
+static
+VALUE set_default_color(VALUE self, VALUE index, VALUE color)
+{
+	CHECK;
+	THIS->set_default_color(to_color_index(index), to<Rays::Color>(color));
+}
+
+static
+VALUE clear_default_color(VALUE self, VALUE index)
+{
+	CHECK;
+	THIS->clear_default_color(to_color_index(index));
+}
+
+static
+VALUE get_default_color(VALUE self, VALUE index)
+{
+	CHECK;
+
+	Rays::Color color;
+	if (THIS->get_default_color(to_color_index(index), &color))
+		return value(color);
+}
+
+static
+VALUE get_color(VALUE self, VALUE index)
+{
+	CHECK;
+
+	Rays::Color color;
+	if (THIS->get_color(to_color_index(index), &color))
+		return value(color);
+}
+
+static
+VALUE get_title(VALUE self)
+{
+	CHECK;
+	return value(THIS->title(), rb_utf8_encoding());
+}
+
+static
+VALUE get_history_rows(VALUE self)
+{
+	CHECK;
+	return value(THIS->history_rows());
+}
+
+static
+VALUE get_history_lines(VALUE self, VALUE offset, VALUE size)
+{
+	CHECK;
+
+	Value result = array(NULL, 0);// a std::vector<Value> would be invisible to the gc
+	for (const auto& line : THIS->get_history_lines(to<int>(offset), to<int>(size)))
+		result.push(value(line.c_str(), line.size(), rb_utf8_encoding()));
+	return result;
+}
+
+static
+VALUE get_bells(VALUE self)
+{
+	CHECK;
+	return value(THIS->bells());
+}
+
+
+static Class cTerminal;
+
+void
+Init_reflex_terminal ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cTerminal = rb_define_class_under(mReflex, "Terminal", rb_cObject);
+	rb_define_alloc_func(cTerminal, alloc);
+	cTerminal.define_private_method("initialize!",     initialize);
+	rb_define_private_method(cTerminal, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cTerminal, "update", RUBY_METHOD_FUNC(update), 0);
+	rb_define_method(cTerminal, "reset", RUBY_METHOD_FUNC(reset), 0);
+	cTerminal.define_method("resize!",            resize);
+	rb_define_method(cTerminal, "feed", RUBY_METHOD_FUNC(feed), 1);
+	rb_define_method(cTerminal, "read_pending_input", RUBY_METHOD_FUNC(read_pending_input), 0);
+	cTerminal.define_method("spawn!",             spawn);
+	rb_define_method(cTerminal, "close", RUBY_METHOD_FUNC(close), 0);
+	rb_define_method(cTerminal, "write", RUBY_METHOD_FUNC(write), 1);
+	rb_define_method(cTerminal, "write_key", RUBY_METHOD_FUNC(write_key), 1);
+	rb_define_method(cTerminal, "write_pointer", RUBY_METHOD_FUNC(write_pointer), 1);
+	rb_define_method(cTerminal, "write_wheel", RUBY_METHOD_FUNC(write_wheel), 1);
+	rb_define_method(cTerminal, "paste", RUBY_METHOD_FUNC(paste), 1);
+	cTerminal.define_method("alive?",          is_alive);
+	cTerminal.define_method("mouse_tracking?", is_mouse_tracking);
+	rb_define_method(cTerminal, "select", RUBY_METHOD_FUNC(select), 4);
+	rb_define_method(cTerminal, "select_rect", RUBY_METHOD_FUNC(select_rect), 4);
+	rb_define_method(cTerminal, "select_word", RUBY_METHOD_FUNC(select_word), 2);
+	rb_define_method(cTerminal, "select_line", RUBY_METHOD_FUNC(select_line), 1);
+	rb_define_method(cTerminal, "deselect", RUBY_METHOD_FUNC(deselect), 0);
+	cTerminal.define_method(  "selection?",    has_selection);
+	rb_define_method(cTerminal, "selected_text", RUBY_METHOD_FUNC(get_selected_text), 0);
+	rb_define_method(cTerminal, "scroll_to", RUBY_METHOD_FUNC(scroll_to), 1);
+	rb_define_method(cTerminal, "scroll_by", RUBY_METHOD_FUNC(scroll_by), 1);
+	rb_define_method(cTerminal, "scroll", RUBY_METHOD_FUNC(get_scroll), 0);
+	cTerminal.define_private_method("each_line!", each_line);
+	cTerminal.define_private_method("each_span!", each_span);
+	rb_define_method(cTerminal, "option_as_alt=", RUBY_METHOD_FUNC(set_option_as_alt), 1);
+	rb_define_method(cTerminal, "option_as_alt", RUBY_METHOD_FUNC(get_option_as_alt), 0);
+	rb_define_method(cTerminal, "columns", RUBY_METHOD_FUNC(get_columns), 0);
+	rb_define_method(cTerminal, "rows", RUBY_METHOD_FUNC(get_rows), 0);
+	rb_define_method(cTerminal, "cursor", RUBY_METHOD_FUNC(get_cursor), 0);
+	cTerminal.define_private_method(  "set_default_color!",   set_default_color);
+	cTerminal.define_private_method("clear_default_color!", clear_default_color);
+	cTerminal.define_private_method(  "get_default_color!",   get_default_color);
+	cTerminal.define_private_method(          "get_color!",           get_color);
+	rb_define_method(cTerminal, "title", RUBY_METHOD_FUNC(get_title), 0);
+	rb_define_method(cTerminal, "history_rows", RUBY_METHOD_FUNC(get_history_rows), 0);
+	cTerminal.define_private_method("get_history_lines!", get_history_lines);
+	rb_define_method(cTerminal, "bells", RUBY_METHOD_FUNC(get_bells), 0);
+
+	cTerminal.define_const("BOLD",            Reflex::Terminal::Span::BOLD);
+	cTerminal.define_const("ITALIC",          Reflex::Terminal::Span::ITALIC);
+	cTerminal.define_const("FAINT",           Reflex::Terminal::Span::FAINT);
+	cTerminal.define_const("BLINK",           Reflex::Terminal::Span::BLINK);
+	cTerminal.define_const("INVISIBLE",       Reflex::Terminal::Span::INVISIBLE);
+	cTerminal.define_const("STRIKETHROUGH",   Reflex::Terminal::Span::STRIKETHROUGH);
+	cTerminal.define_const("OVERLINE",        Reflex::Terminal::Span::OVERLINE);
+	cTerminal.define_const("INVERSE",         Reflex::Terminal::Span::INVERSE);
+	cTerminal.define_const("SELECTED",        Reflex::Terminal::Span::SELECTED);
+	cTerminal.define_const("UNDERLINE_SHIFT", Reflex::Terminal::Span::UNDERLINE_SHIFT);
+	cTerminal.define_const("UNDERLINE_MASK",  Reflex::Terminal::Span::UNDERLINE_MASK);
+
+	cTerminal.define_const("CURSOR_BAR",          Reflex::Terminal::Cursor::BAR);
+	cTerminal.define_const("CURSOR_BLOCK",        Reflex::Terminal::Cursor::BLOCK);
+	cTerminal.define_const("CURSOR_UNDERLINE",    Reflex::Terminal::Cursor::UNDERLINE);
+	cTerminal.define_const("CURSOR_BLOCK_HOLLOW", Reflex::Terminal::Cursor::BLOCK_HOLLOW);
+
+	cTerminal.define_const("COLOR_FOREGROUND",    Reflex::Terminal::COLOR_FOREGROUND);
+	cTerminal.define_const("COLOR_BACKGROUND",    Reflex::Terminal::COLOR_BACKGROUND);
+	cTerminal.define_const("COLOR_CURSOR",        Reflex::Terminal::COLOR_CURSOR);
+	cTerminal.define_const("COLOR_PALETTE_FIRST", Reflex::Terminal::COLOR_PALETTE_FIRST);
+	cTerminal.define_const("COLOR_PALETTE_LAST",  Reflex::Terminal::COLOR_PALETTE_LAST);
+
+	cTerminal.define_const("OPTION_AS_ALT_OFF",   Reflex::Terminal::OPTION_AS_ALT_OFF);
+	cTerminal.define_const("OPTION_AS_ALT_ON",    Reflex::Terminal::OPTION_AS_ALT_ON);
+	cTerminal.define_const("OPTION_AS_ALT_LEFT",  Reflex::Terminal::OPTION_AS_ALT_LEFT);
+	cTerminal.define_const("OPTION_AS_ALT_RIGHT", Reflex::Terminal::OPTION_AS_ALT_RIGHT);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> REFLEX_TERMINAL_EXPORT Reflex::Terminal::OptionAsAlt
+	value_to<Reflex::Terminal::OptionAsAlt> (
+		int argc, const Value* argv, bool convert)
+	{
+		if (argc <= 0 || !argv)
+			argument_error(__FILE__, __LINE__);
+
+		int state = value_to<int>(*argv, convert);
+		if (state < 0 || Reflex::Terminal::OPTION_AS_ALT_MAX <= state)
+			argument_error(__FILE__, __LINE__, "invalid option_as_alt state");
+
+		return (Reflex::Terminal::OptionAsAlt) state;
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	terminal_class ()
+	{
+		return cTerminal;
+	}
+
+
+}// Reflex

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,12 @@
+## Pull Requests Not Accepted 🚫
+
+Thank you for your interest in contributing!
+However, this repository does not accept pull requests directly.
+
+### Where to Contribute?
+
+Please submit your changes to the [xord/all](https://github.com/xord/all) monorepo, which serves as the primary repository for all our main libraries.
+
+For more details, please refer to our [contribution guidelines](../CONTRIBUTING.md).
+
+Thanks for your understanding! 🙌