reflex-terminal 0.1.0

data/lib/reflex/terminal_view.rb

@@ -0,0 +1,268 @@
+require 'xot/util'
+require 'reflex/view'
+require 'reflex/font'
+require 'reflex/color'
+require 'reflex/bell_event'
+require 'reflex/terminal'
+
+
+module Reflex
+
+
+  class TerminalView < View
+
+    DEFAULT_FONT_SIZE     = 14
+
+    DEFAULT_FONT_NAME     =
+      if    Xot.osx?   then 'Menlo'
+      elsif Xot.win32? then 'Consolas'
+      else                  'DejaVu Sans Mono'
+      end
+
+    CURSOR_BLINK_INTERVAL = 0.5
+
+    def initialize(
+      *args,
+      terminal:  nil, # attach this instead of spawning one
+      command:   nil, # passed to Terminal#spawn ($SHELL if nil)
+      envs:      {},  # child's env, a nil value removes one
+      font:      nil, # a Font, a font name, or [name, size]
+      font_size: DEFAULT_FONT_SIZE,
+      **kwargs, &block)
+
+      super(*args, **kwargs, &block)
+      @terminal, @command, @envs = terminal, command, envs
+      @renderer                  = ReflexTerminal::Renderer.new
+      @cursor_blink              = true
+      @prev_bells                = terminal&.bells || 0
+      @font_size                 = font_size
+      self.font                  = font || DEFAULT_FONT_NAME
+    end
+
+    attr_reader :terminal
+
+    def font=(font)
+      unless font.is_a? Font
+        name, size = [font].flatten
+        font       = Font.new name, size || @font_size
+      end
+      @renderer.font = font
+      @font_size     = font.size
+      resize_terminal
+      redraw
+    end
+
+    def font()
+      @renderer.font
+    end
+
+    def font_size=(size)
+      self.font = [font.name, size]
+    end
+
+    def font_size()
+      font.size
+    end
+
+    def on_attach(e)
+      unless @terminal
+        @terminal = Terminal.new
+        @terminal.spawn(@envs, *[@command].compact)
+      end
+      resize_terminal
+      focus
+    end
+
+    def on_detach(e)
+      stop_cursor_blink
+    end
+
+    def on_activate(e)
+      update_cursor_blink
+    end
+
+    def on_deactivate(e)
+      update_cursor_blink
+    end
+
+    def on_focus(e)
+      update_cursor_blink
+    end
+
+    def on_update(e)
+      t = @terminal || return
+      if t.update || @renderer.glyph_count == 0
+        @renderer.bake_glyphs t
+        redraw
+      end
+      if t.bells > @prev_bells
+        bells, @prev_bells = t.bells - @prev_bells, t.bells
+        on_bell BellEvent.new(bells)
+      end
+    end
+
+    def on_draw(e)
+      t = @terminal || return
+
+      @renderer.draw e.painter, t, e.bounds
+      draw_cursor e.painter, t
+    end
+
+    def on_key_down(e)
+      t = @terminal || return
+
+      # typing changes what a selection covers, so it is dropped. A modifier
+      # arrives here on its own, and one held with command is a shortcut for
+      # the application rather than something typed
+      typed = e.chars && (e.modifiers & %i[command win]).empty?
+      t.deselect    if typed && t.selection?
+      t.scroll_to 0 if t.scroll != 0
+      t.write_key e
+      start_cursor_blink
+    end
+
+    def on_key_up(e)
+      @terminal&.write_key e
+    end
+
+    def on_pointer_down(e)
+      focus
+      t = @terminal || return
+
+      # the child process gets the mouse once it asks for it, unless shift
+      # says this drag belongs to the user: the way a terminal lets text be
+      # selected inside an application that tracks the mouse itself
+      @selecting = e.left? && (!t.mouse_tracking? || e.modifiers.include?(:shift))
+      return t.write_pointer(e) unless @selecting
+
+      x, y = to_cell e.x, e.y
+      case e.click_count
+      when 1 then t.deselect
+      when 2 then t.select_word x, y
+      else        t.select_line y
+      end
+    end
+
+    def on_pointer_up(e)
+      t = @terminal || return
+      t.write_pointer e unless @selecting
+      @selecting = false
+    end
+
+    def on_pointer_move(e)
+      t = @terminal || return
+      return t.write_pointer(e) unless @selecting
+      return unless e.drag? && e.click_count == 1
+
+      down     = e.down || return
+      from, to = to_cell(down.x, down.y), to_cell(e.x, e.y)
+      if from == to
+        t.deselect if t.selection?
+      else
+        t.select(*from, *to)
+      end
+    end
+
+    def on_wheel(e)
+      t = @terminal || return
+
+      if t.mouse_tracking?
+        t.write_wheel e
+      else
+        rows = (e.dy / @renderer.cell_height).round
+        return if rows == 0
+        t.scroll_by rows
+        redraw
+      end
+    end
+
+    def on_resize(e)
+      resize_terminal
+    end
+
+    def on_bell(e)
+      # Called with a BellEvent when the terminal received one or more BEL
+      # characters (0x07). What a bell means is left to the application: a
+      # sound, a flash of the window, a badge, or nothing at all.
+    end
+
+    private
+
+    def blinking?()
+      window&.active? && focus?
+    end
+
+    def update_cursor_blink()
+      if blinking?
+        start_cursor_blink
+      else
+        stop_cursor_blink
+        redraw
+      end
+    end
+
+    def start_cursor_blink()
+      @cursor_blink = true
+      stop_cursor_blink
+      @cursor_blinker = interval CURSOR_BLINK_INTERVAL do
+        @cursor_blink = !@cursor_blink
+        redraw
+      end
+      redraw
+    end
+
+    def stop_cursor_blink()
+      @cursor_blinker&.stop
+      @cursor_blinker = nil
+    end
+
+    def draw_cursor(painter, terminal)
+      x, y, style, visible = terminal.cursor
+      return unless visible
+
+      # ghostty never reports BLOCK_HOLLOW itself -- there is no DECSCUSR for
+      # it -- so showing one while the terminal is not taking input is the
+      # view's own decision, and it does not blink
+      hollow = !blinking?
+      return unless hollow || @cursor_blink
+
+      cw, ch = @renderer.cell_width, @renderer.cell_height
+      color  = terminal.cursor_color || terminal.foreground_color || Color.new(1, 1, 1)
+
+      painter.push fill: color, stroke: nil do |p|
+        case hollow ? Terminal::CURSOR_BLOCK_HOLLOW : style
+        when Terminal::CURSOR_BAR       then p.rect x * cw, y * ch, 2, ch
+        when Terminal::CURSOR_UNDERLINE then p.rect x * cw, (y + 1) * ch - 2, cw, 2
+        when Terminal::CURSOR_BLOCK_HOLLOW
+          p.fill   nil
+          p.stroke color
+          p.rect x * cw + 0.5, y * ch + 0.5, cw - 1, ch - 1
+        else
+          p.fill color.dup.tap {|c| c.alpha = 0.5}
+          p.rect x * cw, y * ch, cw, ch
+        end
+      end
+    end
+
+    def to_cell(x, y)
+      # Clamped to the screen so that a drag leaving the view keeps selecting
+      # up to the edge, rather than asking for a cell the terminal will refuse.
+      cw, ch = @renderer.cell_width, @renderer.cell_height
+      [(x / cw).floor.clamp(0, @terminal.columns - 1),
+       (y / ch).floor.clamp(0, @terminal.rows    - 1)]
+    end
+
+    def resize_terminal()
+      return unless @terminal && width > 0 && height > 0
+      cw, ch = @renderer.cell_width, @renderer.cell_height
+      @terminal.resize(
+        (width  / cw).floor.clamp(1..),
+        (height / ch).floor.clamp(1..),
+          cell_width: cw.round,     cell_height: ch,
+        screen_width: width.to_i, screen_height: height.to_i)
+    end
+
+  end# TerminalView
+
+
+end# Reflex

data/lib/reflex-terminal/ext.rb

@@ -0,0 +1,2 @@
+require 'reflex/ext'
+require 'reflex_terminal_ext'

data/lib/reflex-terminal/extension.rb

@@ -0,0 +1,41 @@
+module ReflexTerminal
+
+
+  module Extension
+
+    module_function
+
+    def name(downcase = false)
+      super().split('::')[..-2].join.then {|s|
+        downcase ? s.gsub(/([a-z])([A-Z])/) {"#{$1}-#{$2}"}.downcase : s
+      }
+    end
+
+    def version()
+      File.read(root_dir 'VERSION')[/[\d\.]+/]
+    end
+
+    def root_dir(path = '')
+      File.expand_path "../../#{path}", __dir__
+    end
+
+    def inc_dir()
+      root_dir 'include'
+    end
+
+    def lib_dir()
+      root_dir 'lib'
+    end
+
+    def ext_dir()
+      root_dir 'ext'
+    end
+
+    def lib_name()
+      "#{name true}.dll" if /mswin|ming|cygwin/.match? RUBY_PLATFORM
+    end
+
+  end# Extension
+
+
+end# ReflexTerminal

data/lib/reflex-terminal.rb

@@ -0,0 +1,7 @@
+require 'reflex'
+
+require 'reflex-terminal/extension'
+
+require 'reflex/bell_event'
+require 'reflex/terminal'
+require 'reflex/terminal_view'

data/reflex-terminal.gemspec

@@ -0,0 +1,39 @@
+# -*- mode: ruby -*-
+
+
+require_relative 'lib/reflex-terminal/extension'
+
+
+Gem::Specification.new do |s|
+  glob = -> *patterns do
+    patterns.map {|pat| Dir.glob(pat).to_a}.flatten
+  end
+
+  ext   = ReflexTerminal::Extension
+  name  = ext.name true
+  rdocs = glob.call *%w[README .doc/ext/**/*.cpp]
+
+  s.name        = name
+  s.version     = ext.version
+  s.license     = 'MIT'
+  s.summary     = 'A terminal emulator view for Reflex.'
+  s.description = 'Provides Reflex::Terminal, a headless terminal emulator model built on libghostty-vt, and Reflex::TerminalView, a View that renders it in the Reflex GUI toolkit.'
+  s.authors     = %w[xordog]
+  s.email       = 'xordog@gmail.com'
+  s.homepage    = "https://github.com/xord/reflex-terminal"
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 3.0.0'
+
+  s.add_dependency 'xot',       '~> 0.4.0'
+  s.add_dependency 'rucy',      '~> 0.4.0'
+  s.add_dependency 'rays',      '~> 0.4.0'
+  s.add_dependency 'reflexion', '~> 0.6.0'
+
+  s.files            = `git ls-files`.split $/
+  s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}
+  s.test_files       = s.files.grep %r{^(test|spec|features)/}
+  s.extra_rdoc_files = rdocs.to_a
+
+  s.extensions << 'Rakefile'
+end

data/src/pty.cpp

@@ -0,0 +1,236 @@
+#if defined(OSX) || defined(LINUX)
+
+
+#include "terminal.h"
+
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#ifdef OSX
+	#include <util.h>
+#else
+	#include <pty.h>
+#endif
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <vector>
+#include <reflex/exception.h>
+
+
+namespace Reflex
+{
+
+
+	struct PTY::Data
+	{
+
+		int fd = -1, pid = -1;
+
+	};// PTY::Data
+
+
+	static struct winsize
+	to_winsize (int columns, int rows, int cell_width, int cell_height)
+	{
+		struct winsize size = {};
+		size.ws_col         = (unsigned short) columns;
+		size.ws_row         = (unsigned short) rows;
+		size.ws_xpixel      = (unsigned short) (columns * cell_width);
+		size.ws_ypixel      = (unsigned short) (rows    * cell_height);
+		return size;
+	}
+
+
+	PTY::PTY ()
+	{
+	}
+
+	PTY::~PTY ()
+	{
+		close();
+	}
+
+	void
+	PTY::spawn (
+		const StringList& args, const Terminal::EnvMap& envs,
+		int columns, int rows, int cell_width, int cell_height,
+		bool login)
+	{
+		if (args.empty() || args[0].empty())
+			argument_error(__FILE__, __LINE__, "args is empty");
+		if (is_open())
+			invalid_state_error(__FILE__, __LINE__, "already spawned");
+
+		String argv0 = args[0];
+		if (login)
+		{
+			// shells read their login profiles when argv[0] starts with
+			// a '-', so pass the base name prefixed with it (/bin/zsh
+			// becomes -zsh); the path itself still goes to execvp()
+			size_t pos = argv0.rfind('/');
+			argv0      = "-" + (pos == String::npos ? argv0 : argv0.substr(pos + 1));
+		}
+
+		std::vector<const char*> argv;
+		argv.emplace_back(argv0.c_str());
+		for (size_t i = 1; i < args.size(); ++i)
+			argv.emplace_back(args[i].c_str());
+		argv.push_back(NULL);
+
+		struct winsize size = to_winsize(columns, rows, cell_width, cell_height);
+
+		// built here rather than in the child: allocating between fork()
+		// and exec() is not async-signal-safe
+		Terminal::EnvMap child_envs = Terminal_make_child_envs(envs);
+
+		int master  = -1;
+		pid_t child = forkpty(&master, NULL, NULL, &size);
+		if (child < 0)
+			system_error(__FILE__, __LINE__, "forkpty() failed");
+
+		if (child == 0)
+		{
+			// child process: exec the command
+			for (const auto& it : child_envs)
+			{
+				if (it.second)
+					setenv(it.first.c_str(), it.second->c_str(), 1);
+				else
+					unsetenv(it.first.c_str());
+			}
+
+			// exec the real path; argv[0] may be the login shell name
+			execvp(args[0].c_str(), (char* const*) &argv[0]);
+			_exit(127);// exec failed
+		}
+
+		int flags = fcntl(master, F_GETFL, 0);
+		if (flags < 0 || fcntl(master, F_SETFL, flags | O_NONBLOCK) < 0)
+		{
+			::close(master);
+			kill(child, SIGKILL);
+			waitpid(child, NULL, 0);
+			system_error(__FILE__, __LINE__, "failed to set O_NONBLOCK");
+		}
+
+		self->fd  = master;
+		self->pid = child;
+	}
+
+	size_t
+	PTY::read (char* buffer, size_t size)
+	{
+		// nonblocking: returns 0 when nothing is available, which a caller
+		// cannot tell apart from the child having exited -- is_child_alive()
+		// answers that
+
+		if (!is_open()) return 0;
+
+		ssize_t n = ::read(self->fd, buffer, size);
+		if (n > 0) return (size_t) n;
+
+		if (n == 0 || (errno != EAGAIN && errno != EINTR))
+			close();// EOF or EIO: the child has exited
+		return 0;
+	}
+
+	bool
+	PTY::wait_readable (int timeout_msec) const
+	{
+		if (!is_open()) return false;
+
+		fd_set fds;
+		FD_ZERO(&fds);
+		FD_SET(self->fd, &fds);
+		struct timeval timeout = {0, timeout_msec * 1000};
+		return select(self->fd + 1, &fds, NULL, NULL, &timeout) > 0;
+	}
+
+	void
+	PTY::write (const char* bytes, size_t size)
+	{
+		if (!is_open() || !bytes || size == 0) return;
+
+		size_t offset = 0;
+		while (offset < size)
+		{
+			ssize_t n = ::write(self->fd, bytes + offset, size - offset);
+			if (n > 0)
+				offset += (size_t) n;
+			else if (errno == EINTR)
+				continue;
+			else if (errno == EAGAIN)
+			{
+				// the pty buffer is full; wait briefly for the child to drain it
+				fd_set fds;
+				FD_ZERO(&fds);
+				FD_SET(self->fd, &fds);
+				struct timeval timeout = {0, 100 * 1000};// 100ms
+				if (select(self->fd + 1, NULL, &fds, NULL, &timeout) <= 0)
+					break;// give up to avoid blocking the UI thread forever
+			}
+			else
+			{
+				close();
+				break;
+			}
+		}
+	}
+
+	void
+	PTY::set_size (int columns, int rows, int cell_width, int cell_height)
+	{
+		if (!is_open()) return;
+
+		struct winsize size = to_winsize(columns, rows, cell_width, cell_height);
+		ioctl(self->fd, TIOCSWINSZ, &size);// sends SIGWINCH to the child
+	}
+
+	void
+	PTY::close ()
+	{
+		if (self->fd >= 0)
+		{
+			::close(self->fd);
+			self->fd = -1;
+		}
+		if (self->pid >= 0)
+		{
+			waitpid(self->pid, NULL, WNOHANG);// reap if already exited
+			self->pid = -1;
+		}
+	}
+
+	bool
+	PTY::is_open () const
+	{
+		return self->fd >= 0;
+	}
+
+	bool
+	PTY::is_child_alive () const
+	{
+		if (self->pid < 0) return false;
+
+		return waitpid(self->pid, NULL, WNOHANG) == 0;
+	}
+
+	PTY::operator bool () const
+	{
+		return is_open();
+	}
+
+	bool
+	PTY::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex
+
+
+#endif// OSX || LINUX