bubbletea 0.0.1 → 0.1.0

data/ext/bubbletea/program.c

@@ -0,0 +1,251 @@
+#include "extension.h"
+
+static void program_free(void *pointer) {
+  bubbletea_program_t *program = (bubbletea_program_t *)pointer;
+
+  if (program->handle != 0) {
+    tea_free_program(program->handle);
+  }
+
+  xfree(program);
+}
+
+static size_t program_memsize(const void *pointer) {
+  return sizeof(bubbletea_program_t);
+}
+
+const rb_data_type_t program_type = {
+  .wrap_struct_name = "Bubbletea::Program",
+  .function = {
+    .dmark = NULL,
+    .dfree = program_free,
+    .dsize = program_memsize,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE program_alloc(VALUE klass) {
+  bubbletea_program_t *program = ALLOC(bubbletea_program_t);
+  program->handle = tea_new_program();
+  return TypedData_Wrap_Struct(klass, &program_type, program);
+}
+
+static VALUE program_initialize(VALUE self) {
+  GET_PROGRAM(self, program);
+
+  tea_terminal_init(program->handle);
+
+  return self;
+}
+
+/* Terminal control methods */
+
+static VALUE program_enter_raw_mode(VALUE self) {
+  GET_PROGRAM(self, program);
+  return tea_terminal_enter_raw_mode(program->handle) == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE program_exit_raw_mode(VALUE self) {
+  GET_PROGRAM(self, program);
+  return tea_terminal_exit_raw_mode(program->handle) == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE program_enter_alt_screen(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_enter_alt_screen(program->handle);
+  return Qnil;
+}
+
+static VALUE program_exit_alt_screen(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_exit_alt_screen(program->handle);
+  return Qnil;
+}
+
+static VALUE program_hide_cursor(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_hide_cursor(program->handle);
+  return Qnil;
+}
+
+static VALUE program_show_cursor(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_show_cursor(program->handle);
+  return Qnil;
+}
+
+static VALUE program_enable_mouse_cell_motion(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_enable_mouse_cell_motion(program->handle);
+  return Qnil;
+}
+
+static VALUE program_enable_mouse_all_motion(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_enable_mouse_all_motion(program->handle);
+  return Qnil;
+}
+
+static VALUE program_disable_mouse(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_disable_mouse(program->handle);
+  return Qnil;
+}
+
+static VALUE program_enable_bracketed_paste(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_enable_bracketed_paste(program->handle);
+  return Qnil;
+}
+
+static VALUE program_disable_bracketed_paste(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_disable_bracketed_paste(program->handle);
+  return Qnil;
+}
+
+static VALUE program_enable_report_focus(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_enable_report_focus(program->handle);
+  return Qnil;
+}
+
+static VALUE program_disable_report_focus(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_terminal_disable_report_focus(program->handle);
+  return Qnil;
+}
+
+static VALUE program_terminal_size(VALUE self) {
+  GET_PROGRAM(self, program);
+  int width, height;
+
+  if (tea_terminal_get_size(program->handle, &width, &height) == 0) {
+    return rb_ary_new_from_args(2, INT2NUM(width), INT2NUM(height));
+  }
+
+  return Qnil;
+}
+
+/* Input methods */
+
+static VALUE program_start_input_reader(VALUE self) {
+  GET_PROGRAM(self, program);
+  return tea_input_start_reader(program->handle) == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE program_stop_input_reader(VALUE self) {
+  GET_PROGRAM(self, program);
+  tea_input_stop_reader(program->handle);
+  return Qnil;
+}
+
+static VALUE program_read_raw_input(VALUE self, VALUE timeout_ms) {
+  GET_PROGRAM(self, program);
+
+  char buffer[256];
+  int bytes_read = tea_input_read_raw(program->handle, buffer, sizeof(buffer), NUM2INT(timeout_ms));
+
+  if (bytes_read > 0) {
+    return rb_str_new(buffer, bytes_read);
+  } else if (bytes_read == 0) {
+    return Qnil; // Timeout
+  } else {
+    return Qnil; // Error
+  }
+}
+
+static VALUE program_poll_event(VALUE self, VALUE timeout_ms) {
+  GET_PROGRAM(self, program);
+
+  char buffer[256];
+  int bytes_read = tea_input_read_raw(program->handle, buffer, sizeof(buffer), NUM2INT(timeout_ms));
+
+  if (bytes_read <= 0) {
+    return Qnil; // Timeout or error
+  }
+
+  int consumed;
+  char *json = tea_parse_input_with_consumed(buffer, bytes_read, &consumed);
+
+  if (json == NULL || json[0] == '\0') {
+    tea_free(json);
+    return Qnil;
+  }
+
+  VALUE rb_json = rb_utf8_str_new_cstr(json);
+  tea_free(json);
+
+  VALUE rb_json_module = rb_const_get(rb_cObject, rb_intern("JSON"));
+  VALUE rb_hash = rb_funcall(rb_json_module, rb_intern("parse"), 1, rb_json);
+
+  return rb_hash;
+}
+
+/* Renderer methods */
+
+static VALUE program_create_renderer(VALUE self) {
+  GET_PROGRAM(self, program);
+  unsigned long long renderer_id = tea_renderer_new(program->handle);
+  return ULL2NUM(renderer_id);
+}
+
+static VALUE program_render(VALUE self, VALUE renderer_id, VALUE view) {
+  Check_Type(view, T_STRING);
+  tea_renderer_render(NUM2ULL(renderer_id), StringValueCStr(view));
+  return Qnil;
+}
+
+static VALUE program_renderer_set_size(VALUE self, VALUE renderer_id, VALUE width, VALUE height) {
+  tea_renderer_set_size(NUM2ULL(renderer_id), NUM2INT(width), NUM2INT(height));
+  return Qnil;
+}
+
+static VALUE program_renderer_set_alt_screen(VALUE self, VALUE renderer_id, VALUE enabled) {
+  tea_renderer_set_alt_screen(NUM2ULL(renderer_id), RTEST(enabled) ? 1 : 0);
+  return Qnil;
+}
+
+static VALUE program_renderer_clear(VALUE self, VALUE renderer_id) {
+  tea_renderer_clear(NUM2ULL(renderer_id));
+  return Qnil;
+}
+
+static VALUE program_string_width(VALUE self, VALUE str) {
+  Check_Type(str, T_STRING);
+  return INT2NUM(tea_string_width(StringValueCStr(str)));
+}
+
+void Init_bubbletea_program(void) {
+  cProgram = rb_define_class_under(mBubbletea, "Program", rb_cObject);
+
+  rb_define_alloc_func(cProgram, program_alloc);
+  rb_define_method(cProgram, "initialize", program_initialize, 0);
+
+  rb_define_method(cProgram, "enter_raw_mode", program_enter_raw_mode, 0);
+  rb_define_method(cProgram, "exit_raw_mode", program_exit_raw_mode, 0);
+  rb_define_method(cProgram, "enter_alt_screen", program_enter_alt_screen, 0);
+  rb_define_method(cProgram, "exit_alt_screen", program_exit_alt_screen, 0);
+  rb_define_method(cProgram, "hide_cursor", program_hide_cursor, 0);
+  rb_define_method(cProgram, "show_cursor", program_show_cursor, 0);
+  rb_define_method(cProgram, "enable_mouse_cell_motion", program_enable_mouse_cell_motion, 0);
+  rb_define_method(cProgram, "enable_mouse_all_motion", program_enable_mouse_all_motion, 0);
+  rb_define_method(cProgram, "disable_mouse", program_disable_mouse, 0);
+  rb_define_method(cProgram, "enable_bracketed_paste", program_enable_bracketed_paste, 0);
+  rb_define_method(cProgram, "disable_bracketed_paste", program_disable_bracketed_paste, 0);
+  rb_define_method(cProgram, "enable_report_focus", program_enable_report_focus, 0);
+  rb_define_method(cProgram, "disable_report_focus", program_disable_report_focus, 0);
+  rb_define_method(cProgram, "terminal_size", program_terminal_size, 0);
+
+  rb_define_method(cProgram, "start_input_reader", program_start_input_reader, 0);
+  rb_define_method(cProgram, "stop_input_reader", program_stop_input_reader, 0);
+  rb_define_method(cProgram, "read_raw_input", program_read_raw_input, 1);
+  rb_define_method(cProgram, "poll_event", program_poll_event, 1);
+
+  rb_define_method(cProgram, "create_renderer", program_create_renderer, 0);
+  rb_define_method(cProgram, "render", program_render, 2);
+  rb_define_method(cProgram, "renderer_set_size", program_renderer_set_size, 3);
+  rb_define_method(cProgram, "renderer_set_alt_screen", program_renderer_set_alt_screen, 2);
+  rb_define_method(cProgram, "renderer_clear", program_renderer_clear, 1);
+  rb_define_method(cProgram, "string_width", program_string_width, 1);
+}

data/go/bubbletea.go

@@ -0,0 +1,98 @@
+package main
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+import (
+	"runtime/debug"
+	"sync"
+	"unsafe"
+)
+
+var (
+	nextID   uint64 = 1
+	nextIDMu sync.Mutex
+)
+
+func getNextID() uint64 {
+	nextIDMu.Lock()
+	defer nextIDMu.Unlock()
+	id := nextID
+	nextID++
+	return id
+}
+
+var (
+	programs   = make(map[uint64]*ProgramState)
+	programsMu sync.RWMutex
+)
+
+type ProgramState struct {
+	terminal *Terminal
+	input    *InputReader
+	width    int
+	height   int
+}
+
+func getProgram(id uint64) *ProgramState {
+	programsMu.RLock()
+	defer programsMu.RUnlock()
+	return programs[id]
+}
+
+//export tea_free
+func tea_free(pointer *C.char) {
+	C.free(unsafe.Pointer(pointer))
+}
+
+//export tea_new_program
+func tea_new_program() C.ulonglong {
+	state := &ProgramState{}
+
+	programsMu.Lock()
+	id := getNextID()
+	programs[id] = state
+	programsMu.Unlock()
+
+	return C.ulonglong(id)
+}
+
+//export tea_free_program
+func tea_free_program(id C.ulonglong) {
+	programsMu.Lock()
+	defer programsMu.Unlock()
+
+	state := programs[uint64(id)]
+	if state != nil {
+		if state.input != nil {
+			state.input.Stop()
+		}
+
+		if state.terminal != nil {
+			state.terminal.Restore()
+		}
+	}
+
+	delete(programs, uint64(id))
+}
+
+//export tea_upstream_version
+func tea_upstream_version() *C.char {
+	info, ok := debug.ReadBuildInfo()
+
+	if !ok {
+		return C.CString("unknown")
+	}
+
+	for _, dep := range info.Deps {
+		if dep.Path == "github.com/charmbracelet/x/ansi" {
+			return C.CString(dep.Version)
+		}
+	}
+
+	return C.CString("unknown")
+}
+
+func main() {}

data/go/go.mod

@@ -0,0 +1,16 @@
+module github.com/marcoroth/bubbletea-ruby/go
+
+go 1.23.0
+
+require (
+	github.com/charmbracelet/x/ansi v0.8.0
+	github.com/charmbracelet/x/term v0.2.1
+	github.com/muesli/cancelreader v0.2.2
+)
+
+require (
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+)

data/go/go.sum

@@ -0,0 +1,15 @@
+github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
+github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

data/go/input.go

@@ -0,0 +1,158 @@
+package main
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+import (
+	"context"
+	"os"
+	"sync"
+	"time"
+	"unsafe"
+	"github.com/muesli/cancelreader"
+)
+
+type InputReader struct {
+	cancelReader cancelreader.CancelReader
+	ctx          context.Context
+	cancel       context.CancelFunc
+	events       chan []byte
+	mu           sync.Mutex
+	running      bool
+}
+
+func NewInputReader() (*InputReader, error) {
+	reader, err := cancelreader.NewReader(os.Stdin)
+
+	if err != nil {
+		return nil, err
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	return &InputReader{
+		cancelReader: reader,
+		ctx:          ctx,
+		cancel:       cancel,
+		events:       make(chan []byte, 100),
+	}, nil
+}
+
+func (reader *InputReader) Start() {
+	reader.mu.Lock()
+
+	if reader.running {
+		reader.mu.Unlock()
+		return
+	}
+
+	reader.running = true
+	reader.mu.Unlock()
+
+	go reader.readLoop()
+}
+
+func (reader *InputReader) Stop() {
+	reader.mu.Lock()
+	defer reader.mu.Unlock()
+
+	if !reader.running {
+		return
+	}
+
+	reader.running = false
+	reader.cancel()
+	reader.cancelReader.Cancel()
+	reader.cancelReader.Close()
+}
+
+func (reader *InputReader) readLoop() {
+	var buf [256]byte
+
+	for {
+		select {
+		case <-reader.ctx.Done():
+			return
+		default:
+		}
+
+		n, err := reader.cancelReader.Read(buf[:])
+		if err != nil {
+			return
+		}
+
+		if n > 0 {
+			data := make([]byte, n)
+			copy(data, buf[:n])
+
+			select {
+			case reader.events <- data:
+			case <-reader.ctx.Done():
+				return
+			}
+		}
+	}
+}
+
+//export tea_input_start_reader
+func tea_input_start_reader(programID C.ulonglong) C.int {
+	state := getProgram(uint64(programID))
+	if state == nil {
+		return -1
+	}
+
+	if state.input != nil {
+		return 0
+	}
+
+	reader, err := NewInputReader()
+	if err != nil {
+		return -1
+	}
+
+	state.input = reader
+	reader.Start()
+
+	return 0
+}
+
+//export tea_input_stop_reader
+func tea_input_stop_reader(programID C.ulonglong) {
+	state := getProgram(uint64(programID))
+	if state == nil || state.input == nil {
+		return
+	}
+
+	state.input.Stop()
+	state.input = nil
+}
+
+//export tea_input_read_raw
+func tea_input_read_raw(programID C.ulonglong, buffer *C.char, bufferSize C.int, timeoutMs C.int) C.int {
+	state := getProgram(uint64(programID))
+
+	if state == nil || state.input == nil {
+		return -1
+	}
+
+	timeout := time.Duration(timeoutMs) * time.Millisecond
+
+	select {
+	case data := <-state.input.events:
+		copyLength := len(data)
+
+		if copyLength > int(bufferSize) {
+			copyLength = int(bufferSize)
+		}
+
+		cBuffer := (*[1 << 20]byte)(unsafe.Pointer(buffer))[:copyLength:copyLength]
+		copy(cBuffer, data[:copyLength])
+
+		return C.int(copyLength)
+
+	case <-time.After(timeout):
+		return 0
+	}
+}