summaryrefslogtreecommitdiff
path: root/src/tui/tui.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/tui/tui.zig')
-rw-r--r--src/tui/tui.zig377
1 files changed, 138 insertions, 239 deletions
diff --git a/src/tui/tui.zig b/src/tui/tui.zig
index aaf958dc..0389b12c 100644
--- a/src/tui/tui.zig
+++ b/src/tui/tui.zig
@@ -341,42 +341,74 @@ fn inputFollows(tty: anytype, io: std.Io, ms: u32) !bool {
return false;
}
-test "terminal input preserves fragmented keys queries paste and text after EOF" {
- const gpa = std.testing.allocator;
- const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa });
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
- vx.queries_done.store(false, .unordered);
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
- var feed: Feed = .{};
- const Reader = struct {
- parts: []const []const u8,
- next: usize = 0,
- fn getWinsize(_: *@This()) !vaxis.Winsize {
- return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
- }
- pub fn inputFollows(self: *@This(), _: u32) bool {
- return self.next < self.parts.len;
- }
- fn read(self: *@This(), buf: []u8) !usize {
- if (self.next == self.parts.len) return 0;
- const part = self.parts[self.next];
- self.next += 1;
+/// What a test of a terminal's input needs: vaxis (its capabilities, its
+/// parser's allocator), the loop's queue and a feed, set up in place (vaxis
+/// keeps the environment's address) and torn down in the order vaxis needs.
+const TestInput = struct {
+ env: std.process.Environ.Map,
+ vx: vaxis.Vaxis,
+ out: std.Io.Writer.Allocating,
+ loop: Loop,
+ feed: Feed,
+
+ fn init(t: *TestInput) !void {
+ const gpa = std.testing.allocator;
+ t.env = try std.testing.environ.createMap(gpa);
+ errdefer t.env.deinit();
+ t.vx = try vaxis.init(std.testing.io, gpa, &t.env, .{ .system_clipboard_allocator = gpa });
+ t.out = .init(gpa);
+ t.loop = .init(std.testing.io, undefined, &t.vx);
+ t.feed = .{};
+ }
+
+ fn deinit(t: *TestInput) void {
+ t.vx.deinit(std.testing.allocator, &t.out.writer);
+ t.out.deinit();
+ t.env.deinit();
+ }
+};
+
+/// A terminal that hands over `parts`, a read each (an empty one passed
+/// over), and says more follows (within `gap_ms`) while some are left.
+const TestReader = struct {
+ parts: []const []const u8,
+ next: usize = 0,
+ gap_ms: u32 = 0,
+ asked: bool = false,
+
+ fn getWinsize(_: *TestReader) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+
+ pub fn inputFollows(r: *TestReader, ms: u32) bool {
+ r.asked = true;
+ return r.next < r.parts.len and r.gap_ms <= ms;
+ }
+
+ fn read(r: *TestReader, buf: []u8) !usize {
+ while (r.next < r.parts.len) {
+ const part = r.parts[r.next];
+ r.next += 1;
+ if (part.len == 0) continue;
@memcpy(buf[0..part.len], part);
return part.len;
}
- };
- var reader: Reader = .{ .parts = &.{
+ return 0;
+ }
+};
+
+test "terminal input preserves fragmented keys queries paste and text after EOF" {
+ const gpa = std.testing.allocator;
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
+ t.vx.queries_done.store(false, .unordered);
+ var reader: TestReader = .{ .parts = &.{
"plain \x1b[?62;", "4c\x1b[", "A\x1b[200", "~caf\xc3", "\xa9 \xe7", "\x95",
"\x8c \xf0\x9f", "\x98\x80", "\x1b[201", "~\x1b]52;c;Y2", "xpcA==\x07tail", "\x1b",
} };
- try readInput(&loop, &reader, &vx, &feed);
- try std.testing.expect(vx.queries_done.load(.unordered));
+ try readInput(&t.loop, &reader, &t.vx, &t.feed);
+ try std.testing.expect(t.vx.queries_done.load(.unordered));
var text: std.ArrayList(u8) = .empty;
defer text.deinit(gpa);
var resized = false;
@@ -385,7 +417,7 @@ test "terminal input preserves fragmented keys queries paste and text after EOF"
var pasted = false;
var clipboard = false;
var escape = false;
- while (try loop.tryEvent()) |event| switch (event) {
+ while (try t.loop.tryEvent()) |event| switch (event) {
.winsize => |size| {
try std.testing.expect(!resized);
resized = true;
@@ -418,7 +450,7 @@ test "terminal input preserves fragmented keys queries paste and text after EOF"
clipboard = true;
},
// The device attributes' wake (a capability answer).
- .nop => try std.testing.expect(vx.queries_done.load(.unordered)),
+ .nop => try std.testing.expect(t.vx.queries_done.load(.unordered)),
else => return error.UnexpectedInputEvent,
};
try std.testing.expectEqualStrings("plain café 界 😀tail", text.items);
@@ -427,35 +459,11 @@ test "terminal input preserves fragmented keys queries paste and text after EOF"
test "terminal replies and malformed sequences never become typed text" {
const gpa = std.testing.allocator;
- const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa });
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
- vx.queries_done.store(false, .unordered);
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
- var feed: Feed = .{};
- const Reader = struct {
- parts: []const []const u8,
- next: usize = 0,
- fn getWinsize(_: *@This()) !vaxis.Winsize {
- return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
- }
- pub fn inputFollows(self: *@This(), _: u32) bool {
- return self.next < self.parts.len;
- }
- fn read(self: *@This(), buf: []u8) !usize {
- if (self.next == self.parts.len) return 0;
- const part = self.parts[self.next];
- self.next += 1;
- @memcpy(buf[0..part.len], part);
- return part.len;
- }
- };
- var reader: Reader = .{
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
+ t.vx.queries_done.store(false, .unordered);
+ var reader: TestReader = .{
.parts = &.{
// The startup width queries' answers where the terminal has no
// explicit width: both used to arrive as a bare F3, typed as text.
@@ -480,14 +488,14 @@ test "terminal replies and malformed sequences never become typed text" {
"c",
},
};
- try readInput(&loop, &reader, &vx, &feed);
- try std.testing.expect(vx.queries_done.load(.unordered));
- try std.testing.expect(vx.caps.kitty_graphics);
+ try readInput(&t.loop, &reader, &t.vx, &t.feed);
+ try std.testing.expect(t.vx.queries_done.load(.unordered));
+ try std.testing.expect(t.vx.caps.kitty_graphics);
var text: std.ArrayList(u8) = .empty;
defer text.deinit(gpa);
var alt_up = false;
var clicked = false;
- while (try loop.tryEvent()) |event| switch (event) {
+ while (try t.loop.tryEvent()) |event| switch (event) {
.winsize => {},
.key_press => |key| {
if (key.codepoint == vaxis.Key.up and key.mods.alt) {
@@ -509,40 +517,14 @@ test "terminal replies and malformed sequences never become typed text" {
test "terminal input split at every byte with a gap reads as it does whole" {
const gpa = std.testing.allocator;
- const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa });
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
- var feed: Feed = .{};
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
// Two reads with `gap_ms` between them, as an ssh link delivers a
- // sequence cut across two packets.
- const Reader = struct {
- parts: [2][]const u8,
- gap_ms: u32,
- next: usize = 0,
- fn getWinsize(_: *@This()) !vaxis.Winsize {
- return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
- }
- pub fn inputFollows(self: *@This(), ms: u32) bool {
- return self.next < self.parts.len and self.gap_ms <= ms;
- }
- fn read(self: *@This(), buf: []u8) !usize {
- while (self.next < self.parts.len) {
- const part = self.parts[self.next];
- self.next += 1;
- if (part.len == 0) continue;
- @memcpy(buf[0..part.len], part);
- return part.len;
- }
- return 0;
- }
+ // sequence cut across two packets (TestReader).
+ const Events = struct {
/// What the loop was handed, one line per event.
- fn events(l: *Loop, out: *std.ArrayList(u8)) !void {
+ fn of(l: *Loop, out: *std.ArrayList(u8)) !void {
out.clearRetainingCapacity();
while (try l.tryEvent()) |event| switch (event) {
.winsize => {},
@@ -579,122 +561,71 @@ test "terminal input split at every byte with a gap reads as it does whole" {
var split: std.ArrayList(u8) = .empty;
defer split.deinit(gpa);
for (cases) |case| {
- vx.caps.kitty_keyboard = case.kitty;
+ t.vx.caps.kitty_keyboard = case.kitty;
const all = try std.mem.concat(gpa, u8, &.{ "x", case.bytes, "y" });
defer gpa.free(all);
- var one: Reader = .{ .parts = .{ all, "" }, .gap_ms = 0 };
- try readInput(&loop, &one, &vx, &feed);
- try Reader.events(&loop, &whole);
+ const whole_parts = [_][]const u8{ all, "" };
+ var one: TestReader = .{ .parts = &whole_parts };
+ try readInput(&t.loop, &one, &t.vx, &t.feed);
+ try Events.of(&t.loop, &whole);
for (1..all.len) |cut| {
// A cut just after an ESC is the one that has to wait, and a
// legacy terminal's Escape waits only 50 ms: 40 ms there. A cut
// anywhere else is carried however long the gap.
const after_esc = all[cut - 1] == 0x1b;
- var two: Reader = .{ .parts = .{ all[0..cut], all[cut..] }, .gap_ms = if (after_esc and !case.kitty) 40 else 60 };
- try readInput(&loop, &two, &vx, &feed);
- try Reader.events(&loop, &split);
+ const halves = [_][]const u8{ all[0..cut], all[cut..] };
+ var two: TestReader = .{ .parts = &halves, .gap_ms = if (after_esc and !case.kitty) 40 else 60 };
+ try readInput(&t.loop, &two, &t.vx, &t.feed);
+ try Events.of(&t.loop, &split);
std.testing.expectEqualStrings(whole.items, split.items) catch |err| {
std.debug.print("case {f} cut at {d}\n", .{ std.ascii.hexEscape(case.bytes, .lower), cut });
return err;
};
}
}
- vx.caps.kitty_keyboard = false;
+ t.vx.caps.kitty_keyboard = false;
}
test "an ESC read by itself is the Escape key at once" {
- const gpa = std.testing.allocator;
- const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{});
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
- var feed: Feed = .{};
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
// More always follows at once: a reader that waited on the ESC would
// take `j` for the rest of its sequence (Alt-j).
- const Reader = struct {
- parts: []const []const u8,
- next: usize = 0,
- asked: bool = false,
- fn getWinsize(_: *@This()) !vaxis.Winsize {
- return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
- }
- pub fn inputFollows(self: *@This(), _: u32) bool {
- self.asked = true;
- return self.next < self.parts.len;
- }
- fn read(self: *@This(), buf: []u8) !usize {
- if (self.next == self.parts.len) return 0;
- const part = self.parts[self.next];
- self.next += 1;
- @memcpy(buf[0..part.len], part);
- return part.len;
- }
- };
for ([_]bool{ false, true }) |kitty| {
- vx.caps.kitty_keyboard = kitty;
- var reader: Reader = .{ .parts = &.{ "\x1b", "j" } };
- try readInput(&loop, &reader, &vx, &feed);
+ t.vx.caps.kitty_keyboard = kitty;
+ var reader: TestReader = .{ .parts = &.{ "\x1b", "j" } };
+ try readInput(&t.loop, &reader, &t.vx, &t.feed);
try std.testing.expect(!reader.asked);
- try std.testing.expectEqual(.winsize, std.meta.activeTag((try loop.tryEvent()).?));
- const escape = (try loop.tryEvent()).?.key_press;
+ try std.testing.expectEqual(.winsize, std.meta.activeTag((try t.loop.tryEvent()).?));
+ const escape = (try t.loop.tryEvent()).?.key_press;
try std.testing.expectEqual(vaxis.Key.escape, escape.codepoint);
try std.testing.expect(!escape.mods.alt);
- const j = (try loop.tryEvent()).?.key_press;
+ const j = (try t.loop.tryEvent()).?.key_press;
try std.testing.expectEqual(@as(u21, 'j'), j.codepoint);
try std.testing.expect(!j.mods.alt);
- try std.testing.expect(try loop.tryEvent() == null);
+ try std.testing.expect(try t.loop.tryEvent() == null);
}
- vx.caps.kitty_keyboard = false;
+ t.vx.caps.kitty_keyboard = false;
}
test "a frame's answer is taken wherever the reads cut it, and never typed" {
const gpa = std.testing.allocator;
- const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{});
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
- var feed: Feed = .{};
- const Reader = struct {
- parts: [2][]const u8,
- next: usize = 0,
- fn getWinsize(_: *@This()) !vaxis.Winsize {
- return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
- }
- pub fn inputFollows(self: *@This(), _: u32) bool {
- return self.next < self.parts.len;
- }
- fn read(self: *@This(), buf: []u8) !usize {
- while (self.next < self.parts.len) {
- const part = self.parts[self.next];
- self.next += 1;
- if (part.len == 0) continue;
- @memcpy(buf[0..part.len], part);
- return part.len;
- }
- return 0;
- }
- };
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
const all = "x" ++ FrameAck.answer ++ "y";
- defer feed.ack.waiting.store(false, .release);
+ defer t.feed.ack.waiting.store(false, .release);
for (0..all.len) |cut| {
- feed.ack.waiting.store(true, .release);
- var reader: Reader = .{ .parts = .{ all[0..cut], all[cut..] } };
- try readInput(&loop, &reader, &vx, &feed);
- try std.testing.expect(!feed.ack.waiting.load(.acquire));
+ t.feed.ack.waiting.store(true, .release);
+ const halves = [_][]const u8{ all[0..cut], all[cut..] };
+ var reader: TestReader = .{ .parts = &halves };
+ try readInput(&t.loop, &reader, &t.vx, &t.feed);
+ try std.testing.expect(!t.feed.ack.waiting.load(.acquire));
var typed: std.ArrayList(u8) = .empty;
defer typed.deinit(gpa);
var woke = false;
- while (try loop.tryEvent()) |event| switch (event) {
+ while (try t.loop.tryEvent()) |event| switch (event) {
.winsize => {},
.nop => woke = true,
.key_press => |key| try typed.appendSlice(gpa, key.text orelse return error.UnexpectedInputKey),
@@ -708,16 +639,16 @@ test "a frame's answer is taken wherever the reads cut it, and never typed" {
}
// An Escape pressed just before an answer, in the same read, is the
// Escape key, not Alt on the answer.
- feed.ack.waiting.store(true, .release);
- var glued: Reader = .{ .parts = .{ "\x1b" ++ FrameAck.answer, "j" } };
- try readInput(&loop, &glued, &vx, &feed);
- try std.testing.expectEqual(.winsize, std.meta.activeTag((try loop.tryEvent()).?));
- try std.testing.expectEqual(.nop, std.meta.activeTag((try loop.tryEvent()).?));
- const escape = (try loop.tryEvent()).?.key_press;
+ t.feed.ack.waiting.store(true, .release);
+ var glued: TestReader = .{ .parts = &.{ "\x1b" ++ FrameAck.answer, "j" } };
+ try readInput(&t.loop, &glued, &t.vx, &t.feed);
+ try std.testing.expectEqual(.winsize, std.meta.activeTag((try t.loop.tryEvent()).?));
+ try std.testing.expectEqual(.nop, std.meta.activeTag((try t.loop.tryEvent()).?));
+ const escape = (try t.loop.tryEvent()).?.key_press;
try std.testing.expectEqual(vaxis.Key.escape, escape.codepoint);
try std.testing.expect(!escape.mods.alt);
- try std.testing.expectEqual(@as(u21, 'j'), (try loop.tryEvent()).?.key_press.codepoint);
- try std.testing.expect(try loop.tryEvent() == null);
+ try std.testing.expectEqual(@as(u21, 'j'), (try t.loop.tryEvent()).?.key_press.codepoint);
+ try std.testing.expect(try t.loop.tryEvent() == null);
}
test "a terminal that never answers a frame stops being asked after one timeout" {
@@ -740,14 +671,10 @@ test "a terminal that never answers a frame stops being asked after one timeout"
}
test "terminal input cancellation joins blocked reads and queued EOF" {
- const gpa = std.testing.allocator;
const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{});
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
const Reader = struct {
file: std.Io.File,
eof: bool,
@@ -781,10 +708,9 @@ test "terminal input cancellation joins blocked reads and queued EOF" {
defer _ = libc.close(fds[0]);
defer _ = libc.close(fds[1]);
var reader: Reader = .{ .file = .{ .handle = fds[0], .flags = .{ .nonblocking = false } }, .eof = eof };
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
+ var loop: Loop = .init(io, undefined, &t.vx);
var feed: Feed = .{};
- var thread: ?std.Io.Future(void) = try io.concurrent(Reader.run, .{ &loop, &reader, &vx, &feed });
+ var thread: ?std.Io.Future(void) = try io.concurrent(Reader.run, .{ &loop, &reader, &t.vx, &feed });
defer stopInput(io, &thread);
try std.testing.expectEqual(.winsize, std.meta.activeTag(try loop.nextEvent()));
try reader.entered.wait(io);
@@ -3399,35 +3325,11 @@ fn pasteBytes(key: vaxis.Key) []const u8 {
test "a terminal pane gets function keys as their sequences and lone modifiers not at all" {
const gpa = std.testing.allocator;
- const io = std.testing.io;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(io, gpa, &env, .{});
- var output: std.Io.Writer.Allocating = .init(gpa);
- defer output.deinit();
- defer vx.deinit(gpa, &output.writer);
- vx.queries_done.store(false, .unordered);
- var tty: vaxis.Tty = undefined;
- var loop: Loop = .init(io, &tty, &vx);
- var feed: Feed = .{};
- const Reader = struct {
- parts: []const []const u8,
- next: usize = 0,
- fn getWinsize(_: *@This()) !vaxis.Winsize {
- return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
- }
- pub fn inputFollows(self: *@This(), _: u32) bool {
- return self.next < self.parts.len;
- }
- fn read(self: *@This(), buf: []u8) !usize {
- if (self.next == self.parts.len) return 0;
- const part = self.parts[self.next];
- self.next += 1;
- @memcpy(buf[0..part.len], part);
- return part.len;
- }
- };
- var reader: Reader = .{
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
+ t.vx.queries_done.store(false, .unordered);
+ var reader: TestReader = .{
.parts = &.{
// The startup width queries' answers from a terminal without
// explicit width (foot, ghostty, tmux): two F3s, typed at the prompt.
@@ -3442,12 +3344,12 @@ test "a terminal pane gets function keys as their sequences and lone modifiers n
"\x1b[104;;104u",
},
};
- try readInput(&loop, &reader, &vx, &feed);
+ try readInput(&t.loop, &reader, &t.vx, &t.feed);
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
core.panes[0].?.body.mode = .tty;
while (core.nextEffect()) |_| {}
- while (try loop.tryEvent()) |event| switch (event) {
+ while (try t.loop.tryEvent()) |event| switch (event) {
.key_press => |key| core.update(vaxis_input.keyEvent(key)),
else => {},
};
@@ -3618,13 +3520,10 @@ fn paintCells(win: vaxis.Window, cells: []const pardes.Cell, cols: u16, rows: u1
test "a fade sends the text it dims, not the blanks beside it" {
const gpa = std.testing.allocator;
- var env = try std.testing.environ.createMap(gpa);
- defer env.deinit();
- var vx = try vaxis.init(std.testing.io, gpa, &env, .{});
- var out: std.Io.Writer.Allocating = .init(gpa);
- defer out.deinit();
- defer vx.deinit(gpa, &out.writer);
- try vx.resize(gpa, &out.writer, .{ .rows = 1, .cols = 32, .x_pixel = 0, .y_pixel = 0 });
+ var t: TestInput = undefined;
+ try t.init();
+ defer t.deinit();
+ try t.vx.resize(gpa, &t.out.writer, .{ .rows = 1, .cols = 32, .x_pixel = 0, .y_pixel = 0 });
// `a`, a gap, `b`, a two-cell gap, `c`, a gap, an underlined blank
// (which shows its ink) and one more blank.
var cells: [32]pardes.Cell = @splat(.{ .default = false });
@@ -3636,10 +3535,10 @@ test "a fade sends the text it dims, not the blanks beside it" {
defer for (sent) |bytes| gpa.free(bytes);
for ([_][3]u8{ .{ 200, 200, 200 }, .{ 90, 90, 90 } }, 0..) |ink, frame| {
for (&cells) |*cell| cell.style.fg = .{ .rgb = ink };
- out.clearRetainingCapacity();
- paintCells(vx.window(), &cells, 32, 1);
- try vx.render(&out.writer);
- sent[frame] = try out.toOwnedSlice();
+ t.out.clearRetainingCapacity();
+ paintCells(t.vx.window(), &cells, 32, 1);
+ try t.vx.render(&t.out.writer);
+ sent[frame] = try t.out.toOwnedSlice();
}
// Against a cleared screen every cell goes. After the fade the letters
// go and the underlined blank; every plain blank is jumped.