summaryrefslogtreecommitdiff
path: root/test/panes.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /test/panes.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'test/panes.zig')
-rw-r--r--test/panes.zig2185
1 files changed, 1449 insertions, 736 deletions
diff --git a/test/panes.zig b/test/panes.zig
index d3c29856..e2cd85dc 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -2,6 +2,7 @@ const std = @import("std");
const pardes = @import("pardes");
const panes = pardes.panes;
const layout = pardes.layout;
+const animation = pardes.animation;
const Pardes = pardes.Pardes;
const Pane = pardes.Pane;
const Key = pardes.Key;
@@ -12,18 +13,23 @@ const image = pardes.image;
const syntax = pardes.syntax;
const filesystem = pardes.filesystem;
+fn setTag(pane: *Pane, text: []const u8) !void {
+ if (pane.tag.own) |own| pane.gpa.free(own);
+ pane.tag.own = try pane.gpa.dupe(u8, text);
+}
+
const TagLayerTests = struct {
- const Kind = @FieldType(pardes.TagLayer, "kind");
- fn findLayer(p: *Pardes, kind: Kind, id: usize) !*pardes.TagLayer {
+ const Kind = @FieldType(pardes.Layer, "kind");
+ fn findLayer(p: *Pardes, kind: Kind, id: usize) !*pardes.Layer {
for (&p.surface.tag_layers) |*layer| {
- if (layer.cols > 0 and layer.kind == kind and layer.id == id) return layer;
+ if (layer.rows > 0 and layer.kind == kind and layer.id == id) return layer;
}
return error.MissingTagLayer;
}
- fn mouse(layer: *const pardes.TagLayer, x: f32, kind: pardes.Mouse.Kind) pardes.Mouse {
+ fn mouse(layer: *const pardes.Layer, x: f32, kind: pardes.Mouse.Kind) pardes.Mouse {
const y = (@as(f32, @floatFromInt(layer.viewport.y)) + 0.5) * 20;
- return .{ .button = .left, .kind = kind, .col = @intFromFloat(x / 10), .row = @intFromFloat(y / 20), .tag_hit = layer.hitAt(x, y, 10, 20, 5, 10) };
+ return .{ .button = .left, .kind = kind, .col = @intFromFloat(x / 10), .row = @intFromFloat(y / 20), .tag_hit = layer.tagHit(x, y, 10, 20, 5, 10) };
}
test "compact tag layers render and edit Unicode text beyond body column capacity" {
@@ -36,15 +42,12 @@ const TagLayerTests = struct {
p.row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 5, .tagline_h = 10 };
p.gpa.free(pane.file.?.path);
pane.file.?.path = try p.gpa.dupe(u8, "/x");
- const tail = " " ++ "a" ** 38 ++ "\t界 END";
- @memcpy(pane.tag_tail[0..tail.len], tail);
- pane.tag_tail_len = tail.len;
- pane.tag_init = true;
+ try setTag(pane, " " ++ &@as([38]u8, @splat('a')) ++ "\t界 END");
var frame = std.heap.ArenaAllocator.init(p.gpa);
defer frame.deinit();
_ = try p.render(frame.allocator());
const layer = try findLayer(p, .pane, 0);
- const text = try p.tagText(frame.allocator(), pane);
+ const text = try pardes.tagline.tagText(p, frame.allocator(), pane);
const at = std.mem.indexOf(u8, text, "END").?;
const col = panes.File.displayWidth(text[0..at]);
try std.testing.expect(col > p.rects[0].w);
@@ -55,20 +58,20 @@ const TagLayerTests = struct {
var stale = mouse(layer, x, .press);
stale.tag_hit.?.serial +%= 1;
p.update(.{ .mouse = stale });
- try std.testing.expect(!pane.tag_edit);
+ try std.testing.expect(pane.focus == .body);
p.update(.{ .mouse = mouse(layer, x, .press) });
p.update(.{ .mouse = mouse(layer, x, .release) });
- try std.testing.expect(pane.tag_edit);
- try std.testing.expectEqual(@as(u16, @intCast(at)), pane.tag_col);
+ try std.testing.expect(pane.focus == .tag);
+ try std.testing.expectEqual(at, @as(usize, @intCast(pane.tag.cur_col)));
p.update(.{ .key = .{ .cp = 'X', .text = "X" } });
_ = try p.render(frame.allocator());
- const edited = try p.tagText(frame.allocator(), pane);
+ const edited = try pardes.tagline.tagText(p, frame.allocator(), pane);
try std.testing.expect(std.mem.endsWith(u8, edited, "界 XEND"));
try std.testing.expectEqual(@as(u16, 0), pane.tag_scroll);
try std.testing.expectEqualStrings("body\n", pane.file.?.content);
p.update(.{ .key = .{ .cp = Key.escape } });
const rect = p.rects[0];
- const track: layout.Track = .{
+ const track: animation.Track = .{
.serial = pane.serial,
.pane = 0,
.effect = .zoom,
@@ -83,6 +86,8 @@ const TagLayerTests = struct {
const source_y = @as(f32, @floatFromInt(layer.viewport.y)) + 0.5;
const painted_x = shown.x + (x / 10 - track.to.x) / track.to.w * shown.w;
const painted_y = shown.y + (source_y - track.to.y) / track.to.h * shown.h;
+ // Each is a first click, whatever cell the one before hit.
+ p.last_click = null;
for ([_]pardes.Mouse.Kind{ .press, .release }) |kind| {
var event = mouse(layer, x, kind);
// Hosts inverse the exact painted pixel into the tag envelope;
@@ -91,7 +96,7 @@ const TagLayerTests = struct {
event.row = @intFromFloat(painted_y);
p.update(.{ .mouse = event });
}
- try std.testing.expectEqual(@as(u16, @intCast(at)), pane.tag_col);
+ try std.testing.expectEqual(at, @as(usize, @intCast(pane.tag.cur_col)));
}
}
@@ -100,7 +105,6 @@ const TagLayerTests = struct {
defer p.deinit();
_ = try p.setTestFile("body\n");
p.presentation.enabled = false;
- p.settings.column_tags = true;
p.row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 5, .tagline_h = 10 };
try std.testing.expect(p.executeBuiltinLine(0, "New"));
const second = p.active;
@@ -117,24 +121,24 @@ const TagLayerTests = struct {
try std.testing.expectEqual(second, p.drag.move.id);
p.update(.{ .mouse = mouse(layer, grip_edge - 0.1, .release) });
try std.testing.expectEqualStrings(" ", p.surface.at(layer.viewport.x - 1, layer.viewport.y).grapheme());
- p.update(.{ .mouse = mouse(layer, edge - 0.1, .press) });
- try std.testing.expect(p.drag != .move);
- try std.testing.expect(!p.panes[second].?.tag_edit);
- p.update(.{ .mouse = mouse(layer, edge - 0.1, .release) });
+ if (pardes.TAG_GAP > 0) {
+ p.update(.{ .mouse = mouse(layer, edge - 0.1, .press) });
+ try std.testing.expect(p.drag != .move);
+ try std.testing.expect(p.panes[second].?.focus == .body);
+ p.update(.{ .mouse = mouse(layer, edge - 0.1, .release) });
+ }
p.update(.{ .mouse = mouse(layer, edge + 0.1, .press) });
p.update(.{ .mouse = mouse(layer, edge + 0.1, .release) });
try std.testing.expectEqual(second, p.active);
- try std.testing.expect(p.panes[second].?.tag_edit);
- try std.testing.expectEqual(@as(u16, 0), p.panes[second].?.tag_col);
+ // The first cell of the tag is its path: a click there drafts a name.
+ try std.testing.expect(p.panes[second].?.prompt == .name);
+ try std.testing.expectEqual(@as(i32, 0), p.panes[second].?.input.cur_col);
p.update(.{ .key = .{ .cp = Key.escape } });
const left = p.panes[0].?;
- const tail = " " ++ "a" ** 110;
- @memcpy(left.tag_tail[0..tail.len], tail);
- left.tag_tail_len = tail.len;
- left.tag_init = true;
+ try setTag(left, " " ++ &@as([110]u8, @splat('a')));
_ = try p.render(frame.allocator());
const left_layer = try findLayer(p, .pane, 0);
- const left_text = try p.tagText(frame.allocator(), left);
+ const left_text = try pardes.tagline.tagText(p, frame.allocator(), left);
const start_x = @as(f32, @floatFromInt(left_layer.viewport.x)) * 10 + 12.5;
const beyond_x = edge + 12.5;
p.update(.{ .mouse = mouse(left_layer, start_x, .press) });
@@ -142,12 +146,12 @@ const TagLayerTests = struct {
p.update(.{ .mouse = mouse(layer, beyond_x, .release) });
try std.testing.expectEqual(@as(usize, 0), p.active);
const end_col = left_layer.capacity(p.row_metrics) - 1;
- try std.testing.expectEqual(@as(u16, @intCast(panes.File.rawAtDisplay(left_text, end_col))), left.tag_col);
- try std.testing.expect(left.tag_sel);
+ try std.testing.expectEqual(panes.File.rawAtDisplay(left_text, end_col), @as(usize, @intCast(left.tag.cur_col)));
+ try std.testing.expect(left.sel[0].state == .done and left.sel[0].r0 == 0);
p.update(.{ .key = .{ .cp = Key.escape } });
- const long = "a" ** 60 ++ "界END";
- try std.testing.expect(p.global_tag.set(long));
- for (p.col_tags[0..p.ncol]) |*tag| try std.testing.expect(tag.set(long));
+ const long = &@as([60]u8, @splat('a')) ++ "界END";
+ p.global_tag.own = try p.gpa.dupe(u8, long);
+ for (p.col_tags[0..p.ncol]) |*tag| tag.own = try p.gpa.dupe(u8, long);
_ = try p.render(frame.allocator());
for ([_]Kind{ .workspace, .column }) |kind| {
const id: usize = if (kind == .column) 1 else 0;
@@ -155,24 +159,235 @@ const TagLayerTests = struct {
const x = @as(f32, @floatFromInt(header.viewport.x)) * 10 + 62.5 * 5;
p.update(.{ .mouse = mouse(header, x, .press) });
p.update(.{ .mouse = mouse(header, x, .release) });
- try std.testing.expectEqual(@as(?u16, 63), p.topbar_col);
+ try std.testing.expectEqual(@as(i32, 63), pardes.tagline.focusedHeader(p).?.cur_col);
if (kind == .column) try std.testing.expectEqual(@as(?usize, 1), p.header_column) else try std.testing.expect(p.header_column == null);
p.update(.{ .key = .{ .cp = Key.escape } });
}
}
};
+// Rows relative to where the pane's body and tag are, whatever height its
+// tag has (a tag wraps onto more rows when it is long).
+fn paneAt(p: *Pardes, r: anytype) *pardes.Pane {
+ for (p.panes, 0..) |slot, id| if (slot) |pane| if (std.meta.eql(p.rects[id], r)) return pane;
+ unreachable;
+}
+fn bodyY(p: *Pardes, r: anytype) u16 {
+ return p.bodyTop(paneAt(p, r), r);
+}
+fn bodyH(p: *Pardes, r: anytype) u16 {
+ return r.h -| paneAt(p, r).tag_rows;
+}
+fn tagY(p: *Pardes, r: anytype) u16 {
+ return p.tagTop(paneAt(p, r), r);
+}
+
+test "a tag with a newline in it is as tall as its lines, and each line is typed into and pointed at" {
+ for ([_]bool{ false, true }) |bottom| {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 14 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ p.presentation.enabled = false;
+ p.settings.tag_bottom = bottom;
+ p.update(.tick);
+ try std.testing.expectEqual(@as(u16, 1), pane.tag_rows);
+ const height = p.rects[0].h;
+ const body_rows = pane.rows;
+ // Insert mode in a tag is a body's: Enter is a new line.
+ p.update(.{ .key = .{ .cp = ':' } });
+ p.update(.{ .key = .{ .cp = 'A' } });
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ p.update(.{ .key = .{ .cp = 'S', .text = "Second" } });
+ try std.testing.expect(std.mem.endsWith(u8, pardes.tagline.curTail(pane), "\nSecond"));
+ try std.testing.expectEqual(@as(u16, 2), pane.tag_rows);
+ // The pane keeps its height; the body gives the tag its row.
+ try std.testing.expectEqual(height, p.rects[0].h);
+ try std.testing.expectEqual(body_rows - 1, pane.rows);
+ var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer frame.deinit();
+ const surface = try p.render(frame.allocator());
+ const r = p.rects[0];
+ const tag_y = p.tagTop(pane, r);
+ const x = r.x + pardes.TAG_TEXT_INSET;
+ try std.testing.expectEqualStrings("/", surface.at(x, tag_y).grapheme());
+ for ("Second", 0..) |byte, i| try std.testing.expectEqual(byte, surface.at(x + @as(u16, @intCast(i)), tag_y + 1).text[0]);
+ try std.testing.expectEqual(pardes.FontRole.tagline, surface.at(x, tag_y + 1).style.font_role);
+ // the caret is on the second line, after what was typed
+ try std.testing.expectEqual(tag_y + 1, surface.cursor.?.y);
+ try std.testing.expectEqual(x + 6, surface.cursor.?.x);
+ // the body starts under (or over) the whole tag
+ const body_y = p.bodyTop(pane, r);
+ try std.testing.expectEqual(if (bottom) r.y else r.y + 2, body_y);
+ try std.testing.expectEqualStrings("b", surface.at(r.x + config.GUTTER + panes.File.gutterWidth(pane), body_y).grapheme());
+ // one layer, a row to each line, for a pixel shell
+ var layers: usize = 0;
+ for (p.surface.tagLayers()) |*layer| {
+ if (layer.rows == 0 or layer.kind != .pane or layer.id != 0) continue;
+ try std.testing.expectEqual(tag_y, layer.viewport.y);
+ try std.testing.expectEqual(@as(u16, 2), layer.rows);
+ try std.testing.expectEqual(@as(u16, 2), layer.viewport.h);
+ layers += 1;
+ }
+ try std.testing.expectEqual(@as(usize, 1), layers);
+ // a click on the second line puts the tag's cursor on it
+ p.update(.{ .key = .{ .cp = Key.escape } });
+ p.update(.{ .key = .{ .cp = ':' } });
+ ClickCursorTests.click(p, .left, x + 2, tag_y + 1);
+ try std.testing.expect(pane.focus == .tag);
+ try std.testing.expectEqual(@as(i32, 1), pane.tag.cur_row);
+ try std.testing.expectEqual(@as(i32, 2), pane.tag.cur_col);
+ // and the pane's text, a row to a screen row, has both of its lines
+ const text = try pardes.edit.paneText(p, pane);
+ try std.testing.expect(std.mem.startsWith(u8, modal.lineSlice(text, 0), "/test.txt"));
+ try std.testing.expectEqualStrings("Second", modal.lineSlice(text, 1));
+ try std.testing.expectEqualStrings("body\n", pane.file.?.content);
+ }
+}
+
+test "a tag with more lines than rows scrolls to keep its caret in view" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 30 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ p.presentation.enabled = false;
+ var many: std.ArrayList(u8) = .empty;
+ defer many.deinit(std.testing.allocator);
+ for (1..21) |n| try many.print(std.testing.allocator, "\nL{d}", .{n});
+ try pane.appendTag(many.items);
+ p.update(.tick);
+ try std.testing.expectEqual(@as(u16, pardes.MAX_TAG_ROWS), pane.tag_rows);
+ var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer frame.deinit();
+ const r = p.rects[0];
+ const x = r.x + pardes.TAG_TEXT_INSET;
+ // To the last line: the tag scrolls so it is the bottom row, caret on it.
+ p.update(.{ .key = .{ .cp = ':' } });
+ p.update(.{ .key = .{ .cp = 'g' } });
+ p.update(.{ .key = .{ .cp = 'e' } });
+ try std.testing.expectEqual(@as(i32, 20), pane.tag.cur_row);
+ const bottom = try p.render(frame.allocator());
+ const tag_y = p.tagTop(pane, r);
+ const last_row = tag_y + pardes.MAX_TAG_ROWS - 1;
+ try std.testing.expectEqual(last_row, bottom.cursor.?.y);
+ try std.testing.expectEqualStrings("L", bottom.at(x, last_row).grapheme());
+ try std.testing.expectEqualStrings("2", bottom.at(x + 1, last_row).grapheme());
+ try std.testing.expectEqualStrings("0", bottom.at(x + 2, last_row).grapheme());
+ // what the pointer sees is what is shown: its first row is line 13
+ const text = try pardes.edit.paneText(p, pane);
+ try std.testing.expectEqualStrings("L13", modal.lineSlice(text, 0));
+ ClickCursorTests.click(p, .left, x + 1, tag_y + 1);
+ try std.testing.expectEqual(@as(i32, 14), pane.tag.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), pane.tag.cur_col);
+ // Back to the first line brings the prefix back into view.
+ p.update(.{ .key = .{ .cp = Key.escape } });
+ p.update(.{ .key = .{ .cp = 'g' } });
+ p.update(.{ .key = .{ .cp = 'g' } });
+ const top = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(u16, 0), pane.tag_top);
+ try std.testing.expectEqual(tag_y, top.cursor.?.y);
+ try std.testing.expectEqualStrings("/", top.at(x, tag_y).grapheme());
+
+ // A column tag is one row, as acme's: its lines are joined.
+ many.clearRetainingCapacity();
+ try many.appendSlice(std.testing.allocator, "New");
+ for (1..21) |n| try many.print(std.testing.allocator, "\nC{d}", .{n});
+ p.col_tags[0].own = try p.gpa.dupe(u8, many.items);
+ p.update(.tick);
+ try std.testing.expectEqual(pardes.COLBAR_H, p.columnBarHeight());
+ try std.testing.expect(std.mem.indexOfScalar(u8, p.col_tags[0].own.?, '\n') == null);
+}
+
const TagNavigationTests = struct {
fn key(p: *Pardes, cp: u21) void {
p.update(.{ .key = .{ .cp = cp } });
}
- fn enterNormal(p: *Pardes) *Pane {
+ test "s, S and | in a tag answer for the tag's own text; / still searches the body" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
+ defer p.deinit();
+ const pane = try p.setTestFile("Some body\n");
+ try setTag(pane, " Save Del Snarf");
+ key(p, ':');
+ key(p, 'x'); // the tag's line
+ key(p, 's');
+ try std.testing.expect(pane.prompt == .search and pane.prompt_for == .tag and pane.focus == .tag);
+ p.update(.{ .key = .{ .cp = 'S', .text = "S" } });
+ key(p, Key.enter);
+ try std.testing.expect(pane.focus == .tag and pane.prompt == .none);
+ var ranges: [panes.Text.max_selections]modal.Selection = undefined;
+ const text = try pardes.edit.flatSurface(p, &pane.tag);
+ const got = pane.tag.ranges(text, 0, &ranges);
+ try std.testing.expectEqual(@as(usize, 2), got.n);
+ for (ranges[0..got.n]) |range| try std.testing.expectEqualStrings("S", text[@min(range.anchor, range.head)..@max(range.anchor, range.head)]);
+ // the body's selection is its own
+ try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
+ // `/` from the tag is the body's search, as acme's Look from a tag is
+ key(p, ',');
+ key(p, '/');
+ try std.testing.expect(pane.prompt == .search and pane.prompt_for == .body and pane.focus == .body);
+ key(p, Key.escape);
+ try std.testing.expect(pane.prompt == .none and pane.focus == .body);
+ }
+
+ test "ms and md edit a tag's own text, and the text the edit made is read back whole" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ p.update(.tick);
+ key(p, ':'); // the tag, on `Save` the first time
+ for ("miwms(") |cp| key(p, cp);
+ try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), "(Save)") != null);
+ for ("md(") |cp| key(p, cp);
+ try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), " Save ") != null);
+ try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), "(") == null);
+ }
+
+ test "the keyboard reaches a tag's path, which it can select and yank but not edit" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ p.update(.tick);
key(p, ':');
- return p.panes[p.active].?;
+ // `0` is the line's start, as in acme, where the name is ordinary text
+ key(p, '0');
+ try std.testing.expectEqual(@as(i32, 0), pane.tag.cur_col);
+ key(p, 'E');
+ key(p, 'y');
+ try std.testing.expectEqualStrings("/test.txt", p.registers.text(p.gpa, '"').?);
+ // an edit that reaches into it is refused, the cursor with it
+ const before = try std.testing.allocator.dupe(u8, try pardes.edit.flatSurface(p, &pane.tag));
+ defer std.testing.allocator.free(before);
+ const cursor = pane.tag.cur_col;
+ key(p, 'd');
+ try std.testing.expectEqualStrings(before, try pardes.edit.flatSurface(p, &pane.tag));
+ try std.testing.expectEqual(cursor, pane.tag.cur_col);
+ try std.testing.expect(pane.tag.vsel.active);
+ // typed into, the path drafts a name there, as a click on it does
+ key(p, ';');
+ key(p, '0');
+ key(p, 'i');
+ p.update(.{ .key = .{ .cp = 'x', .text = "x" } });
+ try std.testing.expect(pane.prompt == .name);
+ try std.testing.expectEqualStrings("x/test.txt", pane.input.own.?);
+ // Esc keeps the draft pending; a second drops it.
+ key(p, Key.escape);
+ key(p, Key.escape);
+ try std.testing.expect(pane.prompt == .none);
+ try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
+ // after the path, the text is the tag's own to edit
+ key(p, ':');
+ key(p, 'A');
+ p.update(.{ .key = .{ .cp = '!', .text = "!" } });
+ try std.testing.expect(std.mem.endsWith(u8, pardes.tagline.curTail(pane), "!"));
+ try std.testing.expectEqualStrings("body\n", pane.file.?.content);
}
- test "tag navigation retains each pane cursor and mouse placement overrides memory" {
+ fn window(p: *Pardes, letter: u21) void {
+ p.update(.{ .key = .{ .cp = 'w', .ctrl = true } });
+ key(p, letter);
+ key(p, Key.enter);
+ }
+
+ test "a tag remembers its cursor, starts on Save, and a click moves it" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
defer p.deinit();
const first = try p.setTestFile("body\n");
@@ -183,65 +398,100 @@ const TagNavigationTests = struct {
try std.testing.expect(layout.splitColumn(p, second_id, second_id, false));
p.update(.tick);
p.active = 0;
+ // Nothing to remember yet: `:` lands on Save, in normal mode.
key(p, ':');
+ try std.testing.expect(first.focus == .tag and first.tag.mode == .normal);
+ const shown = try pardes.edit.flatSurface(p, &first.tag);
+ try std.testing.expectEqualStrings("Save", shown[@intCast(first.tag.cur_col)..][0..4]);
+ // Home is the line's start, the path's: the keyboard reaches it.
key(p, Key.home);
for (0..3) |_| key(p, Key.right);
- const first_col = first.tag_col;
- key(p, Key.escape);
+ try std.testing.expectEqual(@as(i32, 3), first.tag.cur_col);
+ // `:` in the tag's normal mode is the way back to the body.
+ key(p, ':');
+ try std.testing.expect(first.focus == .body);
p.active = second_id;
key(p, ':');
key(p, Key.home);
for (0..5) |_| key(p, Key.right);
- const second_col = second.tag_col;
- key(p, Key.escape);
+ key(p, ':');
p.active = 0;
key(p, ':');
- try std.testing.expectEqual(first_col, first.tag_col);
- key(p, Key.escape);
+ try std.testing.expectEqual(@as(i32, 3), first.tag.cur_col);
+ key(p, ':');
p.active = second_id;
key(p, ':');
- try std.testing.expectEqual(second_col, second.tag_col);
- key(p, Key.escape);
+ try std.testing.expectEqual(@as(i32, 5), second.tag.cur_col);
+ key(p, ':');
var frame = std.heap.ArenaAllocator.init(p.gpa);
defer frame.deinit();
_ = try p.render(frame.allocator());
const rect = p.rects[0];
- const y = if (p.settings.tag_bottom) rect.y + rect.h - pardes.BOX_H else rect.y;
- ClickCursorTests.click(p, .left, rect.x + pardes.TAG_TEXT_INSET + 6, y);
+ const y = tagY(p, rect);
+ const prefix: u16 = @intCast(panes.File.displayWidth(try pardes.tagline.tagPrefix(p, first)));
+ ClickCursorTests.click(p, .left, rect.x + pardes.TAG_TEXT_INSET + prefix + 6, y);
try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(@as(u16, 6), first.tag_col);
- key(p, Key.escape);
- p.startPrompt(first, .{ .search = config.search_marker });
+ try std.testing.expect(first.focus == .tag and first.tag.mode == .insert);
+ try std.testing.expectEqual(@as(i32, prefix + 6), first.tag.cur_col);
key(p, Key.escape);
key(p, ':');
- try std.testing.expectEqual(@as(u16, 6), first.tag_col);
+ p.startPrompt(first, &first.body, .{ .search = config.search_marker });
key(p, Key.escape);
+ key(p, ':');
+ try std.testing.expectEqual(@as(i32, prefix + 6), first.tag.cur_col);
+ key(p, ':');
try std.testing.expectEqualStrings("body\n", first.file.?.content);
}
- test "tag navigation clamps remembered columns to renamed graphemes and shorter tags" {
+ test "executing a word from the tag runs it and gives the keyboard back to the body" {
+ for ([_]u21{ Key.tab, Key.enter }) |chord| {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ p.update(.{ .key = .{ .cp = 'i' } });
+ p.update(.{ .key = .{ .cp = 'x', .text = "x" } });
+ p.update(.{ .key = .{ .cp = Key.escape } });
+ while (p.nextEffect()) |_| {}
+ // `:` lands on Save; the execute key runs it, the look key looks
+ // it up. Either way the tag lets go of the keyboard first.
+ key(p, ':');
+ try std.testing.expect(pane.focus == .tag);
+ key(p, chord);
+ try std.testing.expect(pane.focus == .body);
+ try std.testing.expectEqual(.normal, pane.body.mode);
+ var saved = false;
+ while (p.nextEffect()) |effect| {
+ if (effect == .save_file) saved = true;
+ }
+ try std.testing.expectEqual(chord == Key.tab, saved);
+ // ...and the tag still knows where it was.
+ key(p, ':');
+ try std.testing.expectEqualStrings("Save", (try pardes.edit.flatSurface(p, &pane.tag))[@intCast(pane.tag.cur_col)..][0..4]);
+ }
+ }
+
+ test "a renamed path moves the tag's cursor with the text after it and a shorter tag pulls it back" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 14 });
defer p.deinit();
const pane = try p.setTestFile("body\n");
+ key(p, ':'); // on Save
key(p, ':');
- key(p, Key.home);
- for (0..3) |_| key(p, Key.right);
- key(p, Key.escape);
p.gpa.free(pane.file.?.path);
pane.file.?.path = try p.gpa.dupe(u8, "/界.zig");
+ p.update(.tick);
key(p, ':');
- try std.testing.expectEqual(@as(u16, 1), pane.tag_col);
- key(p, Key.end);
- key(p, Key.escape);
- p.gpa.free(pane.file.?.path);
- pane.file.?.path = try p.gpa.dupe(u8, "/é");
- pane.tag_tail_len = 0;
+ const shown = try pardes.edit.flatSurface(p, &pane.tag);
+ try std.testing.expectEqualStrings("Save", shown[@intCast(pane.tag.cur_col)..][0..4]);
+ key(p, ':');
+ try setTag(pane, "é");
+ p.update(.tick);
key(p, ':');
- try std.testing.expectEqual(@as(u16, 3), pane.tag_col);
+ // `/界.zig é`: the cursor is pulled back onto the last character
+ try std.testing.expectEqual(@as(i32, "/界.zig ".len), pane.tag.cur_col);
try std.testing.expectEqualStrings("body\n", pane.file.?.content);
}
- test "tag navigation J and K restore cursors in stacked panes" {
+ test "window keys move between panes from a tag and each tag keeps its cursor" {
for ([_]bool{ false, true }) |bottom| {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
defer p.deinit();
@@ -253,99 +503,78 @@ const TagNavigationTests = struct {
const second = p.panes[second_id].?;
p.update(.tick);
p.active = 0;
- _ = enterNormal(p);
+ key(p, ':');
key(p, Key.home);
key(p, 'l');
key(p, 'l');
- key(p, 'J');
+ window(p, 'j');
try std.testing.expectEqual(second_id, p.active);
- try std.testing.expect(!first.tag_edit and second.tag_edit);
+ try std.testing.expect(first.focus == .body and second.focus == .body);
+ key(p, ':');
key(p, Key.home);
for (0..4) |_| key(p, 'l');
- key(p, 'K');
+ window(p, 'k');
try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(@as(u16, 2), first.tag_col);
- key(p, 'J');
- try std.testing.expectEqual(second_id, p.active);
- try std.testing.expectEqual(@as(u16, 4), second.tag_col);
+ try std.testing.expect(second.focus == .body);
+ key(p, ':');
+ try std.testing.expectEqual(@as(i32, 2), first.tag.cur_col);
+ window(p, 'j');
+ key(p, ':');
+ try std.testing.expectEqual(@as(i32, 4), second.tag.cur_col);
}
}
- test "tag navigation uses uppercase pane and header keys while lowercase stays local" {
+ test "a tag's normal mode is the body's: motions stay in the tag and insert types into it" {
for ([_]bool{ false, true }) |bottom| {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
defer p.deinit();
_ = try p.setTestFile("body\n");
p.presentation.enabled = false;
p.settings.tag_bottom = bottom;
- p.settings.column_tags = true;
try std.testing.expect(p.executeBuiltinLine(0, "New"));
const right = p.active;
try std.testing.expect(layout.splitColumn(p, right, right, false));
p.update(.tick);
p.active = 0;
- const pane = enterNormal(p);
+ key(p, ':');
+ const pane = p.panes[0].?;
key(p, Key.home);
key(p, 'l');
- try std.testing.expectEqual(@as(u16, 1), pane.tag_col);
+ try std.testing.expectEqual(@as(i32, 1), pane.tag.cur_col);
key(p, 'h');
key(p, 'k');
- try std.testing.expectEqual(@as(u16, 0), pane.tag_col);
+ key(p, 'j');
+ try std.testing.expectEqual(@as(i32, 0), pane.tag.cur_col);
try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expect(pane.tag_edit and p.topbar_col == null);
- key(p, 'L');
+ try std.testing.expect(pane.focus == .tag and !p.header_focus);
+ window(p, 'l');
try std.testing.expectEqual(right, p.active);
- try std.testing.expect(!pane.tag_edit and p.panes[right].?.tag_edit);
- key(p, 'H');
- try std.testing.expectEqual(@as(usize, 0), p.active);
- key(p, 'K');
- try std.testing.expect(p.topbar_col != null and p.header_column != null);
- try std.testing.expect(!pane.tag_edit);
- key(p, 'l');
- const column_cursor = p.topbar_col.?;
- key(p, 'K');
- try std.testing.expect(p.topbar_col != null and p.header_column == null);
- key(p, 'l');
- key(p, 'l');
- const workspace_cursor = p.topbar_col.?;
- key(p, 'J');
- try std.testing.expect(p.topbar_col != null and p.header_column != null);
- try std.testing.expectEqual(column_cursor, p.topbar_col.?);
- key(p, 'K');
- try std.testing.expectEqual(workspace_cursor, p.topbar_col.?);
- key(p, 'J');
- key(p, 'J');
- try std.testing.expect(p.topbar_col == null and pane.tag_edit);
- key(p, 'j');
- try std.testing.expect(!pane.tag_edit and p.topbar_col == null);
+ try std.testing.expect(pane.focus == .body and p.panes[right].?.focus == .body);
+ window(p, 'h');
try std.testing.expectEqual(@as(usize, 0), p.active);
- _ = enterNormal(p);
- key(p, 'K');
- key(p, 'j');
- try std.testing.expect(p.topbar_col == null and !pane.tag_edit);
key(p, ':');
key(p, 'i');
key(p, Key.end);
- const before = pane.tag_tail_len;
- try std.testing.expect(pane.tag_edit and pane.mode == .insert);
- for ("hjklHJKL") |letter| {
+ const before = pardes.tagline.curTail(pane).len;
+ try std.testing.expect(pane.focus == .tag and pane.tag.mode == .insert and pane.body.mode == .normal);
+ for ("hjklHJKL:") |letter| {
const text = [_]u8{letter};
p.update(.{ .key = .{ .cp = letter, .text = &text } });
- try std.testing.expect(pane.tag_edit and pane.mode == .insert);
+ try std.testing.expect(pane.focus == .tag and pane.tag.mode == .insert);
}
- try std.testing.expectEqualStrings("hjklHJKL", pane.tag_tail[before..pane.tag_tail_len]);
- try std.testing.expect(pane.tag_edit and pane.mode == .insert and p.topbar_col == null);
+ try std.testing.expectEqualStrings("hjklHJKL:", pardes.tagline.curTail(pane)[before..]);
+ try std.testing.expectEqualStrings("body\n", pane.file.?.content);
try std.testing.expectEqual(@as(usize, 0), p.active);
}
}
};
const BodyHitTests = struct {
- fn mouse(layer: *const pardes.BodyLayer, row: u16, col: u16, kind: pardes.Mouse.Kind) pardes.Mouse {
+ fn mouse(layer: *const pardes.Layer, row: u16, col: u16, kind: pardes.Mouse.Kind) pardes.Mouse {
const width: f32 = if (row < layer.context_rows) 8 else 10;
const x = @as(f32, @floatFromInt(layer.viewport.x)) * 10 + (@as(f32, @floatFromInt(col)) + 0.5) * width;
const y = layer.rowTop(row, 20, 10) + layer.rowHeight(row, 20, 10) / 2;
- return .{ .button = .left, .kind = kind, .col = @intFromFloat(x / 10), .row = @intFromFloat(y / 20), .body_hit = layer.hitAt(x, y, 10, 20, 8, 10).? };
+ return .{ .button = .left, .kind = kind, .col = @intFromFloat(x / 10), .row = @intFromFloat(y / 20), .body_hit = layer.bodyHit(x, y, 10, 20, 8, 10).? };
}
test "compact TreeContext mouse follows source rows in reclaimed space" {
@@ -353,7 +582,7 @@ const BodyHitTests = struct {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 64, .rows = 18 });
defer p.deinit();
p.row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 8, .tagline_h = 10 };
- const pane = try TreeContextTests.setZigFile(p, "const Box = struct {\n pub fn work(\n value: usize,\n ) void {\n" ++ " // body\n" ** 60 ++ " }\n};\n");
+ const pane = try TreeContextTests.setZigFile(p, "const Box = struct {\n pub fn work(\n value: usize,\n ) void {\n" ++ std.mem.asBytes(&@as([60][16]u8, @splat(" // body\n".*))) ++ " }\n};\n");
try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
pane.scrollBy(10);
var frame = std.heap.ArenaAllocator.init(p.gpa);
@@ -370,7 +599,7 @@ const BodyHitTests = struct {
const expected = pane.wrapAt(row).line;
p.update(.{ .mouse = mouse(layer, row, 2, .press) });
p.update(.{ .mouse = mouse(layer, row, 2, .release) });
- try std.testing.expectEqual(expected, pane.cur_row);
+ try std.testing.expectEqual(expected, pane.body.cur_row);
try std.testing.expectEqual(top, pane.scroll());
}
const last = pane.body_visible_rows - 1;
@@ -380,20 +609,57 @@ const BodyHitTests = struct {
p.update(.{ .mouse = mouse(layer, last - 1, prefix + 11, .press) });
// Release at a different source row without an intermediate drag event.
p.update(.{ .mouse = mouse(layer, last, prefix + 14, .release) });
- try std.testing.expectEqualStrings("body\nbody", pardes.test_api.heldSelection(p, 0).?);
+ // A stream: the last row from its start, indentation and all.
+ try std.testing.expect(std.mem.endsWith(u8, pardes.exec.heldSelection(p, 0).?, "// body") and std.mem.startsWith(u8, pardes.exec.heldSelection(p, 0).?, "body\n"));
p.update(.{ .mouse = mouse(layer, last, 10, .press) });
p.update(.{ .mouse = mouse(layer, last, 10, .release) });
- try std.testing.expectEqual(expected, pane.cur_row);
+ try std.testing.expectEqual(expected, pane.body.cur_row);
var stale = mouse(layer, 0, 2, .press);
stale.body_hit.?.serial +%= 1;
p.update(.{ .mouse = stale });
- try std.testing.expectEqual(expected, pane.cur_row);
+ try std.testing.expectEqual(expected, pane.body.cur_row);
p.update(.{ .key = .{ .cp = 'i' } });
p.update(.{ .key = .{ .cp = 'X', .text = "X" } });
try std.testing.expect(std.mem.indexOfScalar(u8, modal.lineSlice(pane.file.?.content, @intCast(expected)), 'X') != null);
}
};
+const LineNumberLookTests = struct {
+ test "right-click on a line number looks at that line, sticky context headers included" {
+ if (!syntax.enabled) return error.SkipZigTest;
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 64, .rows = 18 });
+ defer p.deinit();
+ p.row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 8, .tagline_h = 10 };
+ const pane = try TreeContextTests.setZigFile(p, "const Box = struct {\n pub fn work(\n value: usize,\n ) void {\n" ++ std.mem.asBytes(&@as([60][16]u8, @splat(" // body\n".*))) ++ " }\n};\n");
+ try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
+ pane.scrollBy(30);
+ var frame = std.heap.ArenaAllocator.init(p.gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const layer = &p.surface.body_layers[0];
+ try std.testing.expect(layer.context_rows >= 2);
+ // A header row's number is its declaration's own source line, not the
+ // body line it sits over (`pub fn work(` is line 1); a body row's is
+ // its own.
+ try std.testing.expectEqual(@as(i32, 1), pane.wrapAt(1).line);
+ const rows = [_]u16{ 1, pane.context_rows + 3 };
+ for (rows) |row| {
+ // Each Look recentres the view; come back under the headers.
+ pane.scrollBy(30 - pane.scroll());
+ _ = frame.reset(.retain_capacity);
+ _ = try p.render(frame.allocator());
+ const expected = pane.wrapAt(row).line;
+ var press = BodyHitTests.mouse(&p.surface.body_layers[0], row, 1, .press);
+ press.button = .right;
+ var release = BodyHitTests.mouse(&p.surface.body_layers[0], row, 1, .release);
+ release.button = .right;
+ p.update(.{ .mouse = press });
+ p.update(.{ .mouse = release });
+ try std.testing.expectEqual(expected, pane.body.cur_row);
+ }
+ }
+};
+
const TreeContextTests = struct {
const source = "const Box = struct {\n" ++
" pub fn work(\n" ++
@@ -421,7 +687,7 @@ const TreeContextTests = struct {
if (!syntax.enabled) return error.SkipZigTest;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 64, .rows = 18 });
defer p.deinit();
- const pane = try setZigFile(p, "const Box = struct {\n\n // omitted member comment\n\n pub fn work(\n value: usize,\n ) void {\n" ++ " // body\n" ** 30 ++ " }\n};\n");
+ const pane = try setZigFile(p, "const Box = struct {\n\n // omitted member comment\n\n pub fn work(\n value: usize,\n ) void {\n" ++ std.mem.asBytes(&@as([30][16]u8, @splat(" // body\n".*))) ++ " }\n};\n");
p.row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 8, .tagline_h = 10 };
try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
pane.scrollBy(10);
@@ -437,7 +703,7 @@ const TreeContextTests = struct {
const y = layer.rowTop(row, 20, 10) + 9.5;
const x = @as(f32, @floatFromInt(layer.viewport.x)) * 10 + 5;
// A one-pixel separator remains inside its existing header row.
- try std.testing.expectEqual(row, layer.hitAt(x, y, 10, 20, 8, 10).?.row);
+ try std.testing.expectEqual(row, layer.bodyHit(x, y, 10, 20, 8, 10).?.row);
}
pane.scrollBy(-5);
_ = try p.render(frame.allocator());
@@ -452,23 +718,23 @@ const TreeContextTests = struct {
if (context and !syntax.enabled) continue;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 64, .rows = 18 });
defer p.deinit();
- const pane = try setZigFile(p, "pub fn work() void {\n" ++ " // body\n" ** 100 ++ "}\n");
+ const pane = try setZigFile(p, "pub fn work() void {\n" ++ std.mem.asBytes(&@as([100][12]u8, @splat(" // body\n".*))) ++ "}\n");
if (context) try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
var frame = std.heap.ArenaAllocator.init(p.gpa);
defer frame.deinit();
_ = try p.render(frame.allocator());
try std.testing.expectEqual(@as(i32, 0), pane.scroll());
- p.lookAt(0, "/tree-context.zig:60");
+ pardes.look.lookAt(p, 0, "/tree-context.zig:60");
try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(@as(i32, 59), pane.cur_row);
+ try std.testing.expectEqual(@as(i32, 59), pane.body.cur_row);
const surface = try p.render(frame.allocator());
- const visible = pane.wrapRow(pane.cur_row, pane.cur_col);
+ const visible = pane.wrapRow(pane.body.cur_row, pane.body.cur_col);
try std.testing.expect(visible.row >= pane.context_rows);
try std.testing.expect(visible.row < pane.rows);
try std.testing.expectEqual(@as(i32, 59), pane.wrapAt(visible.row).line);
const cursor = surface.cursor orelse return error.MissingLookCursor;
const rect = p.rects[0];
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = p.bodyTop(pane, rect);
try std.testing.expectEqual(y + @as(u16, @intCast(visible.row)), cursor.y);
}
}
@@ -490,14 +756,16 @@ const TreeContextTests = struct {
try std.testing.expectEqual(@as(i32, 7), pane.wrapAt(pane.context_rows).line);
const rect = p.rects[0];
const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = p.bodyTop(pane, rect);
ClickCursorTests.click(p, .left, x + 6, y);
- try std.testing.expectEqual(@as(i32, 0), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 6), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 6), pane.body.cur_col);
try std.testing.expectEqual(@as(i32, 7), pane.scroll());
const cursor = (try p.render(frame.allocator())).cursor orelse return error.MissingContextCursor;
try std.testing.expectEqual(x + 6, cursor.x);
- try std.testing.expectEqual(y, cursor.y);
+ // Read the body top again: the click cleared the announcement band the
+ // builtin above put up, and the body moved back up with it.
+ try std.testing.expectEqual(p.bodyTop(pane, p.rects[0]), cursor.y);
p.update(.{ .key = .{ .cp = 'i' } });
p.update(.{ .key = .{ .cp = 'Z', .text = "Z" } });
try std.testing.expect(std.mem.startsWith(u8, pane.file.?.content, "const ZBox = struct {"));
@@ -514,7 +782,7 @@ const TreeContextTests = struct {
try std.testing.expectEqual(pane.scroll(), pane.wrapAt(pane.context_rows).line);
}
try std.testing.expectEqual(@as(u16, 0), pane.context_rows);
- try std.testing.expectEqual(@as(i32, 0), pane.wrapRow(0, pane.cur_col).row);
+ try std.testing.expectEqual(@as(i32, 0), pane.wrapRow(0, pane.body.cur_col).row);
try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
pane.scrollBy(7);
_ = try p.render(frame.allocator());
@@ -525,7 +793,9 @@ const TreeContextTests = struct {
if (!syntax.enabled) return error.SkipZigTest;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 48, .rows = 14 });
defer p.deinit();
- const pane = try setZigFile(p, "pub fn @\"界name\"(\n\tvalue: usize,\n) void {\n" ++ " _ = value;\n" ** 12 ++ "}\n");
+ const pane = try setZigFile(p, "pub fn @\"界name\"(\n\tvalue: usize,\n) void {\n" ++ std.mem.asBytes(&@as([12][15]u8, @splat(" _ = value;\n".*))) ++ "}\n");
+ pane.tag_expanded = false; // a one-row tag keeps this small screen's rows
+ p.sync();
p.settings.wrap = false;
p.settings.colors = false;
try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
@@ -536,20 +806,22 @@ const TreeContextTests = struct {
const surface = try p.render(frame.allocator());
try std.testing.expectEqual(@as(u16, 3), pane.context_rows);
const rect = p.rects[0];
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = p.bodyTop(pane, rect);
var glyph_x: ?u16 = null;
for (0..surface.cols) |col| {
if (std.mem.eql(u8, surface.at(@intCast(col), y).grapheme(), "界")) glyph_x = @intCast(col);
}
const x = glyph_x orelse return error.MissingContextUnicode;
ClickCursorTests.click(p, .left, x + 1, y);
- try std.testing.expectEqual(@as(i32, 0), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 9), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 9), pane.body.cur_col);
try std.testing.expectEqual(@as(i32, 8), pane.scroll());
const cursor = (try p.render(frame.allocator())).cursor orelse return error.MissingContextCursor;
try std.testing.expectEqual(x, cursor.x);
- try std.testing.expectEqual(y, cursor.y);
- panes.File.setContent(p, &pane.file.?, try p.gpa.dupe(u8, "// no enclosing declaration\n" ** 18));
+ // Read the body top again: the click cleared the announcement band the
+ // builtin above put up, so the body moved with it.
+ try std.testing.expectEqual(p.bodyTop(pane, p.rects[0]), cursor.y);
+ panes.File.setContent(p, &pane.file.?, try p.gpa.dupe(u8, std.mem.asBytes(&@as([18][28]u8, @splat("// no enclosing declaration\n".*)))));
_ = try p.render(frame.allocator());
try std.testing.expectEqual(@as(u16, 0), pane.context_rows);
try std.testing.expectEqual(pane.scroll(), pane.wrapAt(0).line);
@@ -561,6 +833,8 @@ const TreeContextTests = struct {
defer p.deinit();
const body = " // 012345678901234567890123456789界tail";
const pane = try setZigFile(p, "pub fn aLongDeclarationNameThatCannotFit() void {\n // before\n" ++ body ++ "\n}\n");
+ pane.tag_expanded = false; // a one-row tag keeps this small screen's rows
+ p.sync();
p.settings.wrap = true;
try std.testing.expect(p.executeBuiltinLine(0, "TreeContext"));
pane.scrollBy(2);
@@ -577,8 +851,8 @@ const TreeContextTests = struct {
};
const glyph = target orelse return error.MissingWrappedContextBody;
ClickCursorTests.click(p, .left, glyph.x + 1, glyph.y);
- try std.testing.expectEqual(@as(i32, 2), pane.cur_row);
- try std.testing.expectEqual(@as(i32, @intCast(std.mem.indexOf(u8, body, "界").?)), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, @intCast(std.mem.indexOf(u8, body, "界").?)), pane.body.cur_col);
const cursor = (try p.render(frame.allocator())).cursor orelse return error.MissingContextBodyCursor;
try std.testing.expectEqual(glyph.x, cursor.x);
try std.testing.expectEqual(glyph.y, cursor.y);
@@ -594,7 +868,7 @@ const TtySelectionTests = struct {
}
test "tty selection yields to a new modal cursor selection" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
defer p.deinit();
p.presentation.enabled = false;
@@ -607,24 +881,24 @@ const TtySelectionTests = struct {
_ = try p.render(frame.allocator());
const rect = p.rects[0];
const x = rect.x + config.GUTTER;
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = p.bodyTop(pane, rect);
JumpSelectionTests.drag(p, x + 1, y, x + 3, y);
- try std.testing.expectEqualStrings("lph", p.yank orelse return error.MissingAutomaticTtyYank);
+ try std.testing.expectEqualStrings("lph", p.registers.text(p.gpa, '"') orelse return error.MissingAutomaticTtyYank);
p.update(.{ .key = .{ .cp = p.opts.tty_toggle, .ctrl = true } });
p.update(.{ .key = .{ .cp = 'l' } });
- try std.testing.expectEqual(@as(i32, 4), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 4), pane.body.cur_col);
p.update(.{ .key = .{ .cp = 'y' } });
- try std.testing.expectEqualStrings("a", p.yank.?);
+ try std.testing.expectEqualStrings("a", p.registers.text(p.gpa, '"').?);
try noChildInput(p);
}
- test "tty selection preserves exact rectangle through yank clipboard and mode changes" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ test "tty selection preserves its exact stream through yank clipboard and mode changes" {
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
for ([_]bool{ false, true }) |prompt| {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
defer p.deinit();
const pane = p.panes[0].?;
- pane.mode = .tty;
+ pane.body.mode = .tty;
pane.tty_filter = false;
p.presentation.enabled = false;
while (p.nextEffect()) |_| {}
@@ -637,53 +911,57 @@ const TtySelectionTests = struct {
_ = try p.render(frame.allocator());
const rect = p.rects[0];
const x = rect.x + config.GUTTER;
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = p.bodyTop(pane, rect);
JumpSelectionTests.drag(p, x + @as(u16, if (prompt) 0 else 1), y, x + 3, y + @as(u16, if (prompt) 0 else 1));
- const expected = if (prompt) "$ ab" else "lph\nrav";
- try std.testing.expectEqual(Pane.Mode.tty, pane.mode);
- try std.testing.expectEqualStrings(expected, pardes.test_api.heldSelection(p, 0).?);
- try std.testing.expectEqualStrings(expected, p.yank orelse return error.MissingAutomaticTtyYank);
+ const expected = if (prompt) "$ ab" else "lpha\nbrav";
+ try std.testing.expectEqual(panes.Text.Mode.tty, pane.body.mode);
+ try std.testing.expectEqualStrings(expected, pardes.exec.heldSelection(p, 0).?);
+ try std.testing.expectEqualStrings(expected, p.registers.text(p.gpa, '"') orelse return error.MissingAutomaticTtyYank);
try noChildInput(p);
try std.testing.expect(p.executeBuiltinLine(0, "ClipYank"));
try noChildInput(p);
try std.testing.expectEqualStrings(expected, p.fallback.clipboard.items);
p.update(.{ .key = .{ .cp = p.opts.tty_toggle, .ctrl = true } });
- try std.testing.expectEqual(Pane.Mode.normal, pane.mode);
+ try std.testing.expectEqual(panes.Text.Mode.normal, pane.body.mode);
const normal = try p.render(frame.allocator());
if (!prompt) {
- const selection_bg: pardes.Color = .{ .rgb = p.theme().sel_bg };
- try std.testing.expect(!std.meta.eql(selection_bg, normal.at(x + 4, y).style.bg));
- try std.testing.expect(!std.meta.eql(selection_bg, normal.at(x, y + 1).style.bg));
+ // A stream: the first row to its edge, the last from its
+ // start; (x + 1, y) is surely in it, whatever its tint.
+ const selected = normal.at(x + 1, y).style.bg;
+ try std.testing.expect(std.meta.eql(selected, normal.at(x + 4, y).style.bg));
+ try std.testing.expect(std.meta.eql(selected, normal.at(x, y + 1).style.bg));
+ try std.testing.expect(!std.meta.eql(selected, normal.at(x + 4, y + 1).style.bg));
+ try std.testing.expect(!std.meta.eql(selected, normal.at(x, y).style.bg));
}
- try std.testing.expectEqualStrings(expected, pardes.test_api.heldSelection(p, 0).?);
+ try std.testing.expectEqualStrings(expected, pardes.exec.heldSelection(p, 0).?);
p.update(.{ .key = .{ .cp = 'y' } });
- try std.testing.expectEqualStrings(expected, p.yank.?);
+ try std.testing.expectEqualStrings(expected, p.registers.text(p.gpa, '"').?);
try noChildInput(p);
p.update(.{ .key = .{ .cp = p.opts.tty_toggle, .ctrl = true } });
- try std.testing.expectEqual(Pane.Mode.tty, pane.mode);
+ try std.testing.expectEqual(panes.Text.Mode.tty, pane.body.mode);
try noChildInput(p);
_ = try p.render(frame.allocator());
- try std.testing.expectEqualStrings(expected, pardes.test_api.heldSelection(p, 0).?);
- p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;C\x07" ++ "\r\nnew output" ** 30 } });
+ try std.testing.expectEqualStrings(expected, pardes.exec.heldSelection(p, 0).?);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;C\x07" ++ std.mem.asBytes(&@as([30][12]u8, @splat("\r\nnew output".*))) } });
_ = try p.render(frame.allocator());
- try std.testing.expectEqual(Pane.Mode.tty, pane.mode);
- try std.testing.expectEqualStrings(expected, pardes.test_api.heldSelection(p, 0).?);
- try std.testing.expectEqualStrings(expected, p.yank.?);
+ try std.testing.expectEqual(panes.Text.Mode.tty, pane.body.mode);
+ try std.testing.expectEqualStrings(expected, pardes.exec.heldSelection(p, 0).?);
+ try std.testing.expectEqualStrings(expected, p.registers.text(p.gpa, '"').?);
try noChildInput(p);
}
}
test "tty selection pastes across panes once with existing bracket and mouse protocols" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
for ([_]bool{ false, true }) |bracketed| {
for ([_]bool{ false, true }) |reports_mouse| {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 24 });
defer p.deinit();
p.presentation.enabled = false;
- p.spawnTty(0);
+ _ = pardes.exec.spawnTty(p, 0);
for (p.panes[0..2]) |slot| {
- slot.?.mode = .tty;
+ slot.?.body.mode = .tty;
slot.?.tty_filter = false;
slot.?.greet = false;
slot.?.vweight = 1;
@@ -699,18 +977,20 @@ const TtySelectionTests = struct {
_ = try p.render(frame.allocator());
const source = p.rects[0];
const sx = source.x + config.GUTTER;
- const sy = if (p.settings.tag_bottom) source.y else source.y + pardes.BOX_H;
+ const sy = bodyY(p, source);
JumpSelectionTests.drag(p, sx + 1, sy, sx + 3, sy + 1);
- try std.testing.expectEqualStrings("lph\nrav", p.yank orelse return error.MissingAutomaticTtyYank);
+ try std.testing.expectEqualStrings("lpha\nbrav", p.registers.text(p.gpa, '"') orelse return error.MissingAutomaticTtyYank);
try noChildInput(p);
const target = p.rects[1];
const tx = target.x + config.GUTTER + 2;
- const ty = if (p.settings.tag_bottom) target.y else target.y + pardes.BOX_H;
- p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = tx, .row = ty } });
+ const ty = bodyY(p, target);
+ // Over a program that tracks the mouse B1 is its own, so
+ // the chord's B1 holds Shift; B3 is pardes's either way.
+ p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = tx, .row = ty, .shift = true } });
p.update(.{ .mouse = .{ .button = .right, .kind = .press, .col = tx, .row = ty } });
p.update(.{ .mouse = .{ .button = .right, .kind = .release, .col = tx, .row = ty } });
- p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = tx, .row = ty } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = tx, .row = ty, .shift = true } });
var written: std.Io.Writer.Allocating = .init(p.gpa);
defer written.deinit();
while (p.nextEffect()) |effect| {
@@ -721,16 +1001,82 @@ const TtySelectionTests = struct {
}
const expected = try std.fmt.allocPrint(p.gpa, "{s}{s}", .{
if (reports_mouse) "\x1b[<0;3;1M\x1b[<0;3;1m" else "",
- if (bracketed) "\x1b[200~lph\nrav\x1b[201~" else "lph\rrav",
+ if (bracketed) "\x1b[200~lpha\nbrav\x1b[201~" else "lpha\rbrav",
});
defer p.gpa.free(expected);
try std.testing.expectEqualStrings(expected, written.written());
- try std.testing.expectEqual(Pane.Mode.tty, p.panes[0].?.mode);
- try std.testing.expectEqual(Pane.Mode.tty, p.panes[1].?.mode);
- try std.testing.expectEqualStrings("lph\nrav", pardes.test_api.heldSelection(p, 0).?);
+ try std.testing.expectEqual(panes.Text.Mode.tty, p.panes[0].?.body.mode);
+ try std.testing.expectEqual(panes.Text.Mode.tty, p.panes[1].?.body.mode);
+ try std.testing.expectEqualStrings("lpha\nbrav", pardes.exec.heldSelection(p, 0).?);
}
}
}
+
+ /// Every byte the pane's program would have read off its pty since the
+ /// last call, joined.
+ fn childInput(p: *Pardes, buf: []u8) []const u8 {
+ var n: usize = 0;
+ while (p.nextEffect()) |effect| switch (effect) {
+ .write => |w| {
+ const bytes = w.bytes.slice();
+ if (n + bytes.len > buf.len) break;
+ @memcpy(buf[n..][0..bytes.len], bytes);
+ n += bytes.len;
+ },
+ else => {},
+ };
+ return buf[0..n];
+ }
+
+ // Raw tty mode forwards nearly every key to the child; the two paste
+ // chords are the exception, and forwarding them instead is what broke
+ // pasting into a terminal pane. An application that gets Ctrl-V rather
+ // than the text goes and reads the desktop clipboard on its own account,
+ // and a coding agent reading it is looking for an image, not for words.
+ test "raw tty paste chords type at the program instead of reaching it as keys" {
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
+ for ([_]bool{ false, true }) |bracketed| {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ try std.testing.expectEqual(panes.Text.Mode.tty, pane.body.mode);
+ if (bracketed) p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h" } });
+ try std.testing.expectEqual(bracketed, panes.terminal.bracketedPaste(pane));
+ p.registers.put(p.gpa, '"', "one\ntwo", 0, 1, true); // what a `y` anywhere left behind
+ var buf: [256]u8 = undefined;
+ _ = childInput(p, &buf);
+
+ // Ctrl-V types the register straight at the program, asking the
+ // desktop for nothing. Under DECSET 2004 the program's own fences
+ // carry it, which is what stops readline RUNNING a multi-line paste.
+ p.update(.{ .key = .{ .cp = 'v', .ctrl = true } });
+ try std.testing.expectEqualStrings(
+ if (bracketed) "\x1b[200~one\ntwo\x1b[201~" else "one\rtwo",
+ childInput(p, &buf),
+ );
+ try std.testing.expect(p.clip_pending == null);
+
+ // Ctrl-Shift-V is the other store: it ASKS, types nothing yet, and
+ // the answer lands at the program rather than in an edit buffer. A
+ // host that folds the Shift into the letter says the same thing.
+ for ([_]Key{
+ .{ .cp = 'v', .ctrl = true, .shift = true },
+ .{ .cp = 'V', .ctrl = true },
+ }) |chord| {
+ p.update(.{ .key = chord });
+ try std.testing.expect(p.clip_pending != null);
+ try std.testing.expectEqualStrings("", childInput(p, &buf));
+ p.update(.{ .paste = "from-desktop" });
+ try std.testing.expect(p.clip_pending == null);
+ try std.testing.expectEqualStrings(
+ if (bracketed) "\x1b[200~from-desktop\x1b[201~" else "from-desktop",
+ childInput(p, &buf),
+ );
+ }
+ // ...and neither chord put the clipboard in the register on its way.
+ try std.testing.expectEqualStrings("one\ntwo", p.registers.text(p.gpa, '"') orelse "");
+ }
+ }
};
const ClickCursorTests = struct {
@@ -739,6 +1085,107 @@ const ClickCursorTests = struct {
p.update(.{ .mouse = .{ .button = button, .kind = .release, .col = x, .row = y } });
}
+ test "a B1 sweep held past a pane's bottom scrolls the body and keeps its start" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
+ defer p.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(std.testing.allocator);
+ for (0..60) |i| try text.print(std.testing.allocator, "line{d}\n", .{i});
+ const pane = try p.setTestFile(text.items);
+ var frame = std.heap.ArenaAllocator.init(p.gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const rect = p.rects[0];
+ const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
+ const y = p.bodyTop(pane, rect);
+ // The pane reaches the screen's bottom: its last row is the edge.
+ const below = rect.y + rect.h - 1;
+ p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = x, .row = y + 1 } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .drag, .col = x + 2, .row = below } });
+ for (0..20) |_| p.update(.tick);
+ try std.testing.expect(pane.scroll() >= 20);
+ _ = try p.render(frame.allocator()); // a frame between the ticks and the release
+ p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = x + 2, .row = below } });
+ const got = pardes.edit.currentSelText(p, pane).?;
+ try std.testing.expect(std.mem.startsWith(u8, got, "line1\nline2\n"));
+ try std.testing.expect(std.mem.count(u8, got, "\n") > 20);
+ }
+
+ test "everything a B1 chord does while B1 is down is one undo step" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("one two three\n");
+ var frame = std.heap.ArenaAllocator.init(p.gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const rect = p.rects[0];
+ const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
+ const y = p.bodyTop(pane, rect);
+ const M = struct {
+ fn ev(pp: *Pardes, b: pardes.Mouse.Button, k: pardes.Mouse.Kind, cx: u16, cy: u16) void {
+ pp.update(.{ .mouse = .{ .button = b, .kind = k, .col = cx, .row = cy } });
+ }
+ };
+ // B1-B2 then B1-B3: cut, then paste back: a copy, one step.
+ const before = pane.file.?.history.undo_len;
+ M.ev(p, .left, .press, x + 4, y);
+ M.ev(p, .left, .drag, x + 6, y);
+ M.ev(p, .middle, .press, x + 6, y);
+ M.ev(p, .middle, .release, x + 6, y);
+ M.ev(p, .right, .press, x + 6, y);
+ M.ev(p, .right, .release, x + 6, y);
+ M.ev(p, .left, .release, x + 6, y);
+ try std.testing.expectEqualStrings("one two three\n", pane.file.?.content);
+ try std.testing.expectEqualStrings("two", p.registers.text(p.gpa, '"').?);
+ try std.testing.expect(pane.file.?.history.undo_len <= before + 1);
+ // A cut alone comes back with one Undo.
+ M.ev(p, .left, .press, x + 4, y);
+ M.ev(p, .left, .drag, x + 6, y);
+ M.ev(p, .middle, .press, x + 6, y);
+ M.ev(p, .middle, .release, x + 6, y);
+ M.ev(p, .left, .release, x + 6, y);
+ try std.testing.expectEqualStrings("one three\n", pane.file.?.content);
+ try std.testing.expect(p.executeBuiltinLine(0, "Undo"));
+ try std.testing.expectEqualStrings("one two three\n", pane.file.?.content);
+ }
+
+ test "a double-click selects a word, a line, a bracketed or quoted text, as acme's" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("call foo_bar(a, b)\nsay \"hi there\"\n");
+ var frame = std.heap.ArenaAllocator.init(p.gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const rect = p.rects[0];
+ const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
+ const y = p.bodyTop(pane, rect);
+ const Want = struct { col: u16, row: u16, text: []const u8 };
+ for ([_]Want{
+ .{ .col = 6, .row = 0, .text = "foo_bar" },
+ .{ .col = 13, .row = 0, .text = "a, b" },
+ .{ .col = 0, .row = 0, .text = "call foo_bar(a, b)\n" },
+ .{ .col = 5, .row = 1, .text = "hi there" },
+ }) |w| {
+ click(p, .left, x + w.col, y + w.row);
+ click(p, .left, x + w.col, y + w.row);
+ try std.testing.expectEqualStrings(w.text, pardes.edit.currentSelText(p, pane).?);
+ // A third click is a plain click again: the caret, no selection.
+ click(p, .left, x + w.col, y + w.row);
+ try std.testing.expect(!pane.body.vsel.active);
+ }
+ // In the tag too.
+ const tag_text = try pardes.tagline.tagText(p, frame.allocator(), pane);
+ const del: u16 = @intCast(std.mem.indexOf(u8, tag_text, "Del").? + 1);
+ const tag_x = rect.x + pardes.TAG_TEXT_INSET + del;
+ click(p, .left, tag_x, p.tagTop(pane, rect));
+ click(p, .left, tag_x, p.tagTop(pane, rect));
+ try std.testing.expect(pane.tag.vsel.active);
+ const tag_now = try pardes.tagline.tagText(p, frame.allocator(), pane);
+ const a = modal.offsetAt(tag_now, .{ .row = @intCast(pane.tag.vsel.row), .col = @intCast(pane.tag.vsel.col) });
+ const h = modal.offsetAt(tag_now, .{ .row = @intCast(pane.tag.cur_row), .col = @intCast(pane.tag.cur_col) });
+ try std.testing.expectEqualStrings("Del", tag_now[a .. h + 1]);
+ }
+
test "click cursor and insertion agree beyond line and file ends" {
for ([_]bool{ false, true }) |already_insert| {
for ([_]bool{ false, true }) |bottom_tag| {
@@ -759,15 +1206,15 @@ const ClickCursorTests = struct {
_ = try p.render(frame.allocator());
const rect = p.rects[0];
const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = if (bottom_tag) rect.y else rect.y + pardes.BOX_H;
+ const y = bodyY(p, rect);
click(p, .left, x + 15, y + case.click_row);
- try std.testing.expectEqual(case.row, pane.cur_row);
- try std.testing.expectEqual(case.col, pane.cur_col);
+ try std.testing.expectEqual(case.row, pane.body.cur_row);
+ try std.testing.expectEqual(case.col, pane.body.cur_col);
const clicked = (try p.render(frame.allocator())).cursor orelse return error.MissingClickCursor;
try std.testing.expectEqual(x + @as(u16, @intCast(case.col)), clicked.x);
try std.testing.expectEqual(y + @as(u16, @intCast(case.row)), clicked.y);
if (!already_insert) p.update(.{ .key = .{ .cp = 'i' } });
- try std.testing.expectEqual(Pane.Mode.insert, pane.mode);
+ try std.testing.expectEqual(panes.Text.Mode.insert, pane.body.mode);
const insert = (try p.render(frame.allocator())).cursor orelse return error.MissingInsertCursor;
try std.testing.expectEqual(clicked.x, insert.x);
try std.testing.expectEqual(clicked.y, insert.y);
@@ -800,12 +1247,12 @@ const ClickCursorTests = struct {
if (wrap) try std.testing.expect(glyph.y > p.rects[0].y + pardes.BOX_H);
click(p, .left, glyph.x + 1, glyph.y);
const byte = std.mem.indexOf(u8, source, "界").?;
- try std.testing.expectEqual(@as(i32, @intCast(byte)), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, @intCast(byte)), pane.body.cur_col);
const clicked = (try p.render(frame.allocator())).cursor orelse return error.MissingClickCursor;
try std.testing.expectEqual(glyph.x, clicked.x);
try std.testing.expectEqual(glyph.y, clicked.y);
if (!already_insert) p.update(.{ .key = .{ .cp = 'i' } });
- try std.testing.expectEqual(Pane.Mode.insert, pane.mode);
+ try std.testing.expectEqual(panes.Text.Mode.insert, pane.body.mode);
const insert = (try p.render(frame.allocator())).cursor orelse return error.MissingInsertCursor;
try std.testing.expectEqual(clicked.x, insert.x);
try std.testing.expectEqual(clicked.y, insert.y);
@@ -820,7 +1267,7 @@ const ClickCursorTests = struct {
test "click operands and hover follow the scrolled source selection" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 14 });
defer p.deinit();
- const pane = try p.setTestFile("zero\none\ntwo\nthree\nalpha beta\nfive\ngamma delta\nseven\n" ++ "tail\n" ** 20);
+ const pane = try p.setTestFile("zero\none\ntwo\nthree\nalpha beta\nfive\ngamma delta\nseven\n" ++ std.mem.asBytes(&@as([20][5]u8, @splat("tail\n".*))));
p.presentation.enabled = false;
p.settings.wrap = false;
var frame = std.heap.ArenaAllocator.init(p.gpa);
@@ -828,9 +1275,9 @@ const ClickCursorTests = struct {
_ = try p.render(frame.allocator());
const rect = p.rects[0];
const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = bodyY(p, rect);
JumpSelectionTests.drag(p, x + 1, y + 4, x + 3, y + 4);
- try std.testing.expectEqualStrings("lph", pardes.test_api.heldSelection(p, 0).?);
+ try std.testing.expectEqualStrings("lph", pardes.exec.heldSelection(p, 0).?);
for (0..2) |_| p.update(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = x + 2, .row = y + 4 } });
try std.testing.expectEqual(@as(usize, 2), pane.file.?.scroll);
_ = try p.render(frame.allocator());
@@ -840,7 +1287,7 @@ const ClickCursorTests = struct {
defer _ = pardes.ctlfs.handle(p, .{ .tag = 0, .op = .release, .node = event_node, .handle = opened.handle });
for ([_]pardes.Mouse.Button{ .middle, .right }) |button| {
- const events = &p.fs.panes[0].events;
+ const events = &p.panes[0].?.fs.events;
while (!events.empty()) events.pop();
click(p, button, x + 2, y + 2);
const selected = events.peek() orelse return error.MissingSelectionGesture;
@@ -877,7 +1324,7 @@ const JumpSelectionTests = struct {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 34, .rows = 10 });
defer p.deinit();
p.settings.wrap = wrap;
- const text = try std.fmt.allocPrint(p.gpa, "{s}{s}", .{ prefix, "unrelated destination text\n" ** 80 });
+ const text = try std.fmt.allocPrint(p.gpa, "{s}{s}", .{ prefix, std.mem.asBytes(&@as([80][27]u8, @splat("unrelated destination text\n".*))) });
defer p.gpa.free(text);
const pane = try p.setTestFile(text);
var frame = std.heap.ArenaAllocator.init(p.gpa);
@@ -886,13 +1333,13 @@ const JumpSelectionTests = struct {
if (wrap) try std.testing.expectEqual(pane.wrap_line[0], pane.wrap_line[1]);
const rect = p.rects[0];
const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = p.bodyTop(pane, rect);
if (reverse)
drag(p, x + last_col, y + 1, x + first_col, y)
else
drag(p, x + first_col, y, x + last_col, y + 1);
- const selected = try p.gpa.dupe(u8, pardes.test_api.heldSelection(p, 0) orelse return error.MissingMouseSelection);
+ const selected = try p.gpa.dupe(u8, pardes.exec.heldSelection(p, 0) orelse return error.MissingMouseSelection);
defer p.gpa.free(selected);
if (expected) |want| try std.testing.expectEqualStrings(want, selected);
try std.testing.expect(std.mem.indexOfScalar(u8, selected, '\n') != null);
@@ -910,29 +1357,64 @@ const JumpSelectionTests = struct {
try std.testing.expectEqual(@as(usize, 0), p.jcur);
try std.testing.expect(pane.file.?.scroll > 20);
try LookResetTests.cleared(pane);
- try std.testing.expect(!pane.vsel.active);
- try std.testing.expect(pardes.test_api.heldSelection(p, 0) == null);
- try std.testing.expectEqual(@as(i32, 59), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 0), pane.cur_col);
+ try std.testing.expect(!pane.body.vsel.active);
+ try std.testing.expect(pardes.exec.heldSelection(p, 0) == null);
+ try std.testing.expectEqual(@as(i32, 59), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_col);
// A selection created after Back must also disappear on Forward.
- drag(p, x + 1, y, x + 3, y + 1);
- try std.testing.expect(pardes.test_api.heldSelection(p, 0) != null);
+ // Back announces itself, so the body sits under a notice band now.
+ const y2 = p.bodyTop(pane, p.rects[0]);
+ drag(p, x + 1, y2, x + 3, y2 + 1);
+ try std.testing.expect(pardes.exec.heldSelection(p, 0) != null);
p.update(.{ .key = .{ .cp = 'i', .ctrl = true } });
_ = frame.reset(.retain_capacity);
_ = try p.render(frame.allocator());
try std.testing.expectEqual(@as(usize, 1), p.jcur);
try std.testing.expectEqual(@as(usize, 0), pane.file.?.scroll);
try LookResetTests.cleared(pane);
- try std.testing.expect(!pane.vsel.active);
- try std.testing.expect(pardes.test_api.heldSelection(p, 0) == null);
- try std.testing.expectEqual(@as(i32, 0), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 0), pane.cur_col);
+ try std.testing.expect(!pane.body.vsel.active);
+ try std.testing.expect(pardes.exec.heldSelection(p, 0) == null);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_col);
}
- test "jump selection clears copied rectangles in both history directions" {
+ test "a B1 sweep over several lines is a stream, as acme's, in a body and a tag" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("alpha\nbravo\ncharlie\n");
+ var frame = std.heap.ArenaAllocator.init(p.gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const rect = p.rects[0];
+ const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
+ const y = p.bodyTop(pane, rect);
+ // From the press to the end of its line, the line between whole, the
+ // last from its start: no line numbers, no rectangle.
+ drag(p, x + 2, y, x + 1, y + 2);
+ try std.testing.expectEqualStrings("pha\nbravo\nch", pardes.exec.heldSelection(p, 0).?);
+ // Upward, the same text.
+ drag(p, x + 1, y + 2, x + 2, y);
+ try std.testing.expectEqualStrings("pha\nbravo\nch", pardes.exec.heldSelection(p, 0).?);
+ // A tag of several rows sweeps the same way.
+ if (pane.tag.own) |own| p.gpa.free(own);
+ pane.tag.own = try p.gpa.dupe(u8, "Save Del\nLook Edit");
+ p.sync();
+ _ = try p.render(frame.allocator());
+ p.sync();
+ try std.testing.expectEqual(@as(u16, 2), pane.tag_rows);
+ const sl: panes.Pane.Sel = .{ .state = .done, .r0 = 0, .c0 = 3, .r1 = 1, .c1 = 1 };
+ const text = try pardes.edit.paneText(p, pane);
+ const swept = try pardes.edit.selectionText(p, pane, sl);
+ const first_line = text[0 .. std.mem.indexOfScalar(u8, text, '\n') orelse text.len];
+ const second = std.mem.sliceTo(text[first_line.len + 1 ..], '\n');
+ const want = try std.fmt.allocPrint(frame.allocator(), "{s}\n{s}", .{ first_line[3..], second[0..@min(2, second.len)] });
+ try std.testing.expectEqualStrings(want, swept);
+ }
+
+ test "jump selection clears copied sweeps in both history directions" {
for ([_]bool{ false, true }) |reverse|
- try exercise("alpha\nbravo\n", false, reverse, 1, 3, "lph\nrav");
+ try exercise("alpha\nbravo\n", false, reverse, 1, 3, "lpha\nbrav");
}
test "jump selection clears wrapped Unicode and tab rectangles" {
@@ -965,9 +1447,9 @@ const JumpSelectionTests = struct {
try std.testing.expectEqual(@as(usize, 0), p.jcur);
try LookResetTests.cleared(source);
try LookResetTests.cleared(destination);
- try std.testing.expect(!source.vsel.active and !destination.vsel.active);
- try std.testing.expectEqual(@as(i32, 2), destination.cur_row);
- try std.testing.expectEqual(@as(i32, 1), destination.cur_col);
+ try std.testing.expect(!source.body.vsel.active and !destination.body.vsel.active);
+ try std.testing.expectEqual(@as(i32, 2), destination.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), destination.body.cur_col);
try LookResetTests.seed(source, "new source held text");
try LookResetTests.seed(destination, "new destination held text");
@@ -976,9 +1458,9 @@ const JumpSelectionTests = struct {
try std.testing.expectEqual(@as(usize, 1), p.jcur);
try LookResetTests.cleared(source);
try LookResetTests.cleared(destination);
- try std.testing.expect(!source.vsel.active and !destination.vsel.active);
- try std.testing.expectEqual(@as(i32, 1), source.cur_row);
- try std.testing.expectEqual(@as(i32, 0), source.cur_col);
+ try std.testing.expect(!source.body.vsel.active and !destination.body.vsel.active);
+ try std.testing.expectEqual(@as(i32, 1), source.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 0), source.body.cur_col);
}
};
@@ -1002,22 +1484,29 @@ const TagNameTintTests = struct {
var arena = std.heap.ArenaAllocator.init(p.gpa);
defer arena.deinit();
const surface = try p.render(arena.allocator());
- const text = try p.tagText(arena.allocator(), pane);
+ // The tag as shown: its rows wrapped, each offset mapped back to the
+ // tag's own to say whether it is in the name.
+ const shown = try pardes.tagline.shownTag(p, arena.allocator(), pane);
const base = std.mem.lastIndexOfScalar(u8, name, '/') orelse return error.MissingDirectory;
const rect = p.rects[id];
- const y = if (p.settings.tag_bottom) rect.y + rect.h - pardes.BOX_H else rect.y;
const left = rect.x + pardes.TAG_TEXT_INSET;
var visible_name: usize = 0;
- var at: usize = 0;
- while (at < text.len) : (at = modal.nextGrapheme(text, at)) {
- const start: i32 = @as(i32, @intCast(panes.File.rawDisplayCol(text, at))) - pane.tag_scroll;
- const end = start + @as(i32, @intCast(panes.File.displayWidth(text[at..modal.nextGrapheme(text, at)])));
- var col = @max(0, start);
- while (col < end and col < rect.w - pardes.TAG_TEXT_INSET) : (col += 1) {
- const in_name = at > base and at < name.len;
- const fg = if (in_name) name_fg else tag_fg;
- try std.testing.expectEqual(pardes.Color{ .rgb = fg }, surface.at(left + @as(u16, @intCast(col)), y).style.fg);
- if (in_name) visible_name += 1;
+ for (0..pane.tag_rows) |row| {
+ const line_start = modal.lineStartOffset(shown.text, row + pane.tag_top);
+ const line = modal.lineSlice(shown.text, row + pane.tag_top);
+ const y = tagY(p, rect) + @as(u16, @intCast(row));
+ var at: usize = 0;
+ while (at < line.len) : (at = modal.nextGrapheme(line, at)) {
+ const real = shown.toReal(line_start + at);
+ const start: i32 = @intCast(panes.File.rawDisplayCol(line, at));
+ const end = start + @as(i32, @intCast(panes.File.displayWidth(line[at..modal.nextGrapheme(line, at)])));
+ var col = start;
+ while (col < end and col < rect.w - pardes.TAG_TEXT_INSET) : (col += 1) {
+ const in_name = real > base and real < name.len;
+ const fg = if (in_name) name_fg else tag_fg;
+ try std.testing.expectEqual(pardes.Color{ .rgb = fg }, surface.at(left + @as(u16, @intCast(col)), y).style.fg);
+ if (in_name) visible_name += 1;
+ }
}
}
return visible_name;
@@ -1043,38 +1532,35 @@ const TagNameTintTests = struct {
}
}
- test "tag filename tint follows scrolled Unicode staged names and yields to selection" {
+ test "tag filename tint follows wrapped Unicode drafted names and yields to selection" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 38, .rows = 14 });
defer p.deinit();
const pane = try p.setTestFile("body\n");
- const old = pane.file.?.path.len;
configure(p);
defer p.custom_theme = null;
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'i' } });
- pane.tag_anchor = 0;
- pane.tag_col = @intCast(old - 1);
- pane.tag_sel = true;
const name = "/a/very/long/directory/that/extends/past/the/tag/界e\u{301}name-with-a-long-tail.zig";
- p.update(.{ .paste = name });
- try std.testing.expectEqualStrings(name, pane.tag_name[0..pane.tag_name_len.?]);
- pane.tag_col = @intCast(std.mem.indexOf(u8, name, "界").?);
- pane.tag_sel = false;
+ pardes.tagline.draftName(p, pane, 0);
+ redraft(pane, name);
+ pane.input.cur_col = @intCast(std.mem.indexOf(u8, name, "界").?);
+ p.sync(); // the drafted name's rows
try std.testing.expect((try check(p, 0, name)) > 0);
- try std.testing.expect(pane.tag_scroll > 0);
- pane.tag_anchor = pane.tag_col;
- pane.tag_sel = true;
- pane.tag_scroll += 4; // bring both cells of the selected wide glyph into view
+ try std.testing.expect(pane.tag_rows > 1); // the long name wraps
+ // A sweep over the wide glyph, on the row it wrapped to, wears the
+ // selection over the tint.
var arena = std.heap.ArenaAllocator.init(p.gpa);
defer arena.deinit();
+ const shown = try pardes.tagline.shownTag(p, arena.allocator(), pane);
+ const pos = modal.positionAt(shown.text, shown.fromReal(@intCast(pane.input.cur_col)));
+ const col: i32 = @intCast(panes.File.rawDisplayCol(modal.lineSlice(shown.text, pos.row), pos.col));
+ pane.sel[0] = .{ .state = .done, .c0 = col, .c1 = col + 1, .r0 = @intCast(pos.row), .r1 = @intCast(pos.row) };
const surface = try p.render(arena.allocator());
- const x = p.rects[0].x + pardes.TAG_TEXT_INSET + @as(u16, @intCast(panes.File.rawDisplayCol(name, pane.tag_col) - pane.tag_scroll));
- const y = if (p.settings.tag_bottom) p.rects[0].y + p.rects[0].h - pardes.BOX_H else p.rects[0].y;
+ const x = p.rects[0].x + pardes.TAG_TEXT_INSET + @as(u16, @intCast(col));
+ const y = tagY(p, p.rects[0]) + @as(u16, @intCast(pos.row));
try std.testing.expectEqual(pardes.Color{ .rgb = p.theme().sel_fg }, surface.at(x, y).style.fg);
try std.testing.expectEqual(pardes.Color{ .rgb = p.theme().sel_fg }, surface.at(x + 1, y).style.fg);
}
- test "tag filename tint legacy themes retain distinct active foreground" {
+ test "tag filename tint legacy themes keep their active foreground and tint the name with a hue of their own" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 70, .rows = 14 });
defer p.deinit();
const pane = try p.setTestFile("body\n");
@@ -1092,70 +1578,88 @@ const TagNameTintTests = struct {
p.settings.focus_tint = active;
const surface = try p.render(arena.allocator());
const x = p.rects[0].x + pardes.TAG_TEXT_INSET;
- const y = if (p.settings.tag_bottom) p.rects[0].y + p.rects[0].h - pardes.BOX_H else p.rects[0].y;
+ const y = tagY(p, p.rects[0]);
const fg = if (active) active_fg else tag_fg;
+ // The directory in the ink; the name tinted, never in it.
+ const chrome = p.chromeTheme();
+ const tint = if (active) chrome.tag_active_name_fg else chrome.tag_name_fg;
+ try std.testing.expect(!std.meta.eql(tint, fg));
try std.testing.expectEqual(pardes.Color{ .rgb = fg }, surface.at(x + 1, y).style.fg);
- try std.testing.expectEqual(pardes.Color{ .rgb = fg }, surface.at(x + 5, y).style.fg);
+ try std.testing.expectEqual(pardes.Color{ .rgb = tint }, surface.at(x + 5, y).style.fg);
}
}
};
-test "pane filename edits stage commit and cancel without changing body or command tail" {
+/// Replace a name draft's text, the caret after it, as clearing it and
+/// typing would.
+fn redraft(pane: *Pane, name: []const u8) void {
+ if (pane.input.own) |own| pane.gpa.free(own);
+ pane.input.own = pane.gpa.dupe(u8, name) catch unreachable;
+ pane.input.cur_col = @intCast(name.len);
+}
+
+/// Click the tagline at the end of the path: a name draft, caret there.
+fn clickPathEnd(p: *Pardes, pane: *Pane) void {
+ const rect = p.rects[p.active];
+ const y = tagY(p, rect);
+ const x = rect.x + pardes.TAG_TEXT_INSET + @as(u16, @intCast(panes.File.displayWidth(pane.file.?.path) - 1));
+ ClickCursorTests.click(p, .left, x, y);
+ std.debug.assert(pane.prompt == .name);
+ pane.input.cur_col = @intCast(pane.input.own.?.len);
+}
+
+test "pane filename drafts commit and cancel without changing body or command tail" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 70, .rows = 12 });
defer p.deinit();
const pane = try p.setTestFile("original body\n");
const original = try p.gpa.dupe(u8, pane.file.?.path);
defer p.gpa.free(original);
- p.seedTail(pane);
- try std.testing.expect(pane.appendTag(" SyntaxBold"));
- const tail = try p.gpa.dupe(u8, pane.tagSlice());
+ try pane.appendTag(" SyntaxBold");
+ const tail = try p.gpa.dupe(u8, pardes.tagline.curTail(pane));
defer p.gpa.free(tail);
for ([_]bool{ false, true }) |commit| {
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'i' } });
- pane.tag_anchor = 0;
- pane.tag_col = @intCast(original.len - 1);
- pane.tag_sel = true;
+ clickPathEnd(p, pane);
+ p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
p.update(.{ .paste = "/new name.zig" });
try std.testing.expectEqualStrings(original, pane.file.?.path);
- try std.testing.expectEqualStrings("/new name.zig", pane.tag_name[0..pane.tag_name_len.?]);
- try std.testing.expectEqualStrings(tail, pane.tagSlice());
+ try std.testing.expectEqualStrings("/new name.zig", pane.input.own.?);
+ try std.testing.expectEqualStrings(tail, pardes.tagline.curTail(pane));
try std.testing.expectEqualStrings("original body\n", pane.file.?.content);
+ // Esc keeps the draft pending; a second drops it.
p.update(.{ .key = .{ .cp = if (commit) Key.enter else Key.escape } });
- try std.testing.expect(!pane.tag_edit);
- try std.testing.expect(pane.tag_name_len == null);
+ if (!commit) p.update(.{ .key = .{ .cp = Key.escape } });
+ try std.testing.expect(pane.focus == .body);
+ try std.testing.expect(pane.prompt == .none);
try std.testing.expectEqualStrings(if (commit) "/new name.zig" else original, pane.file.?.path);
- try std.testing.expectEqualStrings(tail, pane.tagSlice());
+ try std.testing.expectEqualStrings(tail, pardes.tagline.curTail(pane));
while (p.nextEffect()) |effect| try std.testing.expect(std.meta.activeTag(effect) != .save_file);
}
- try std.testing.expect(pane.file.?.revision != pane.file.?.saved_revision);
+ // A name alone is no edit: the pane stays clean.
+ try std.testing.expect(pane.file.?.revision == pane.file.?.saved_revision);
}
test "pane filename grapheme edits and invalid empty commits preserve the buffer" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("untouched\n");
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'i' } });
- pane.tag_anchor = 0;
- pane.tag_col = @intCast(pane.file.?.path.len - 1);
- pane.tag_sel = true;
+ clickPathEnd(p, pane);
+ p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
p.update(.{ .paste = "/café界" });
p.update(.{ .key = .{ .cp = Key.backspace } });
- try std.testing.expectEqualStrings("/café", pane.tag_name[0..pane.tag_name_len.?]);
+ try std.testing.expectEqualStrings("/café", pane.input.own.?);
p.update(.{ .key = .{ .cp = Key.backspace } });
- try std.testing.expectEqualStrings("/caf", pane.tag_name[0..pane.tag_name_len.?]);
- pane.tag_anchor = 0;
- pane.tag_col = 3;
- pane.tag_sel = true;
- p.update(.{ .key = .{ .cp = Key.delete } });
- try std.testing.expectEqual(@as(u16, 0), pane.tag_name_len.?);
+ try std.testing.expectEqualStrings("/caf", pane.input.own.?);
+ p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
+ try std.testing.expectEqualStrings("", pane.input.own.?);
p.update(.{ .key = .{ .cp = Key.enter } });
- try std.testing.expect(pane.tag_edit);
+ try std.testing.expect(pane.prompt == .name);
try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
try std.testing.expectEqualStrings("untouched\n", pane.file.?.content);
+ // Esc keeps the draft pending; a second drops it.
+ p.update(.{ .key = .{ .cp = Key.escape } });
+ try std.testing.expect(pane.prompt == .name);
p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.tag_name_len == null);
+ try std.testing.expect(pane.prompt == .none);
}
test "leaving a pane or entering a header cancels an uncommitted filename" {
@@ -1164,39 +1668,35 @@ test "leaving a pane or entering a header cancels an uncommitted filename" {
const pane = try p.setTestFile("untouched\n");
for ([_]bool{ false, true }) |header| {
p.active = 0;
- p.topbar_col = null;
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'i' } });
- p.update(.{ .key = .{ .cp = Key.home } });
+ pardes.tagline.exitHeader(p);
+ p.update(.tick);
+ clickPathEnd(p, pane);
p.update(.{ .paste = "/draft" });
- try std.testing.expect(pane.tag_name_len != null);
+ try std.testing.expect(pane.prompt == .name);
if (header) {
- p.topbar_col = 0;
+ pardes.tagline.enterHeader(p, null);
p.update(.tick);
} else {
try std.testing.expect(p.executeBuiltinLine(0, "New"));
p.update(.tick);
}
- try std.testing.expect(pane.tag_name_len == null);
- try std.testing.expect(!pane.tag_edit);
+ try std.testing.expect(pane.prompt == .none);
+ try std.testing.expect(pane.focus == .body);
try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
}
}
-test "middle clicking Save commits the staged filename before issuing a save" {
+test "middle clicking Save commits the drafted filename before issuing a save" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 70, .rows = 12 });
defer p.deinit();
const pane = try p.setTestFile("untouched\n");
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'i' } });
- pane.tag_anchor = 0;
- pane.tag_col = @intCast(pane.file.?.path.len - 1);
- pane.tag_sel = true;
+ clickPathEnd(p, pane);
+ p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
p.update(.{ .paste = "/renamed.txt" });
var arena = std.heap.ArenaAllocator.init(p.gpa);
defer arena.deinit();
_ = try p.render(arena.allocator());
- const text = try p.tagText(arena.allocator(), pane);
+ const text = try pardes.tagline.tagText(p, arena.allocator(), pane);
const save_at = std.mem.indexOf(u8, text, "Save").?;
const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + save_at - pane.tag_scroll);
const y = p.rects[0].y;
@@ -1204,7 +1704,7 @@ test "middle clicking Save commits the staged filename before issuing a save" {
p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .press } });
p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .release } });
try std.testing.expectEqualStrings("/renamed.txt", pane.file.?.path);
- try std.testing.expect(pane.tag_name_len == null);
+ try std.testing.expect(pane.prompt == .none);
try std.testing.expectEqualStrings("untouched\n", pane.file.?.content);
var saves: usize = 0;
while (p.nextEffect()) |effect| if (effect == .save_file) {
@@ -1214,24 +1714,19 @@ test "middle clicking Save commits the staged filename before issuing a save" {
try std.testing.expectEqual(@as(usize, 1), saves);
}
-test "oversized filename paste refuses atomically across a selected tag boundary" {
+test "an oversized drafted name is refused at commit and the draft stays to correct" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("untouched\n");
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'i' } });
- const before = try p.tagText(p.gpa, pane);
- defer p.gpa.free(before);
- pane.tag_anchor = 0;
- pane.tag_col = @intCast(before.len - 1);
- pane.tag_sel = true;
- const excess = try p.gpa.alloc(u8, pane.tag_name.len + 1);
+ clickPathEnd(p, pane);
+ const excess = try p.gpa.alloc(u8, 5000);
defer p.gpa.free(excess);
@memset(excess, 'x');
+ excess[0] = '/';
p.update(.{ .paste = excess });
- try std.testing.expect(pane.tag_name_len == null);
- try std.testing.expect(pane.tag_sel);
- try std.testing.expectEqualStrings(before, try p.tagText(p.scratch.allocator(), pane));
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ try std.testing.expect(pane.prompt == .name);
+ try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
try std.testing.expectEqualStrings("untouched\n", pane.file.?.content);
}
@@ -1241,42 +1736,97 @@ test "paste into pane commands and prompts never inserts into the body" {
const pane = try p.setTestFile("one two one\n");
p.update(.{ .key = .{ .cp = ':' } });
p.update(.{ .key = .{ .cp = 'A' } });
- p.update(.{ .paste = " Custom\r\nCommand" });
- try std.testing.expect(std.mem.endsWith(u8, pane.tagSlice(), " CustomCommand"));
+ // A tag takes a paste as a body does, newline and all.
+ p.update(.{ .paste = " Custom\nCommand" });
+ try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), " Custom\nCommand") != null);
p.update(.{ .key = .{ .cp = Key.escape } });
- p.startPrompt(pane, .{ .search = config.search_marker });
- p.update(.{ .paste = "two" });
- try std.testing.expect(std.mem.endsWith(u8, pane.tagSlice(), "two"));
+ p.startPrompt(pane, &pane.body, .{ .search = config.search_marker });
+ p.update(.{ .paste = "t\r\nwo" });
+ try std.testing.expectEqualStrings(config.search_marker ++ "two", pane.promptText().?);
+ try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), " Custom\nCommand") != null);
try std.testing.expectEqualStrings("one two one\n", pane.file.?.content);
p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(std.mem.endsWith(u8, pane.tagSlice(), " CustomCommand"));
+ try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), " Custom\nCommand") != null);
}
-test "long pane tags reveal commands and map visible clicks to whole tag addresses" {
+test "a tag that exactly fills its row stays one row, its caret at the edge as acme's tick" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 50, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ const width = pardes.tagline.tagWidth(p, 0);
+ // Pad the path until the whole tag is exactly the row.
+ const bare = try pardes.tagline.tagText(p, p.scratch.allocator(), pane);
+ const pad = width - bare.len + pane.file.?.path.len;
+ p.gpa.free(pane.file.?.path);
+ const path = try p.gpa.alloc(u8, pad);
+ @memset(path, 'a');
+ path[0] = '/';
+ pane.file.?.path = path;
+ try std.testing.expectEqual(width, (try pardes.tagline.tagText(p, p.scratch.allocator(), pane)).len);
+ p.update(.{ .key = .{ .cp = ':' } });
+ p.update(.{ .key = .{ .cp = 'A' } });
+ var arena = std.heap.ArenaAllocator.init(p.gpa);
+ defer arena.deinit();
+ const surface = try p.render(arena.allocator());
+ try std.testing.expectEqual(@as(u16, 1), pane.tag_rows);
+ // The layer's caret is past the last character; the grid's, on the pane's
+ // last cell, since it has none past it.
+ try std.testing.expectEqual(@as(u16, @intCast(width)), surface.tag_layers[0].cursor.?.x);
+ try std.testing.expectEqual(p.rects[0].x + p.rects[0].w - 1, surface.cursor.?.x);
+}
+
+test "a long pane tag wraps onto rows, and a click on a wrapped row maps to the whole tag's address" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 50, .rows = 12 });
defer p.deinit();
const pane = try p.setTestFile("body\n");
p.gpa.free(pane.file.?.path);
pane.file.?.path = try p.gpa.dupe(u8, "/an/especially/deep/project/path/with/a/long/component/filename.zig");
- p.seedTail(pane);
- try std.testing.expect(pane.appendTag(" SyntaxBold"));
+ try pane.appendTag(" SyntaxBold");
p.update(.{ .key = .{ .cp = ':' } });
p.update(.{ .key = .{ .cp = 'A' } });
var arena = std.heap.ArenaAllocator.init(p.gpa);
defer arena.deinit();
const surface = try p.render(arena.allocator());
- try std.testing.expect(pane.tag_scroll > 0);
+ try std.testing.expect(pane.tag_rows > 1);
try std.testing.expect(surface.cursor.?.x < p.rects[0].x + p.rects[0].w);
- const text = try p.tagText(p.gpa, pane);
+ const text = try pardes.tagline.tagText(p, p.gpa, pane);
defer p.gpa.free(text);
- const offset = std.mem.indexOf(u8, text, "SyntaxBold").?;
- const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + panes.File.rawDisplayCol(text, offset) - pane.tag_scroll);
- const y = p.rects[0].y;
+ const shown = try pardes.tagline.shownTag(p, arena.allocator(), pane);
+ const at = shown.fromReal(std.mem.indexOf(u8, text, "SyntaxBold").?);
+ const pos = modal.positionAt(shown.text, at);
+ const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + panes.File.rawDisplayCol(modal.lineSlice(shown.text, pos.row), pos.col));
+ const y = p.tagTop(pane, p.rects[0]) + @as(u16, @intCast(pos.row));
+ const before = p.settings.syntax_bold;
+ p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .press } });
+ p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .release } });
+ try std.testing.expectEqual(!before, p.settings.syntax_bold);
+ try std.testing.expectEqualStrings(text, try pardes.tagline.tagText(p, p.scratch.allocator(), pane));
+}
+
+test "a word the tag's wrapping breaks across rows is still one word to a click" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 50, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("body\n");
+ try pane.appendTag(" SyntaxBold");
+ var arena = std.heap.ArenaAllocator.init(p.gpa);
+ defer arena.deinit();
+ // Lengthen the path until the wrap splits the word after "Synt".
+ var pad: usize = 1;
+ const shown = while (pad < 80) : (pad += 1) {
+ p.gpa.free(pane.file.?.path);
+ const path = try std.fmt.allocPrint(arena.allocator(), "/{s}/f.zig", .{(&@as([80]u8, @splat('a')))[0..pad]});
+ pane.file.?.path = try p.gpa.dupe(u8, path);
+ p.sync();
+ const s = try pardes.tagline.shownTag(p, arena.allocator(), pane);
+ if (std.mem.indexOf(u8, s.text, "Synt\n") != null) break s;
+ } else return error.NoSplit;
+ const pos = modal.positionAt(shown.text, std.mem.indexOf(u8, shown.text, "Synt").?);
+ const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + pos.col + 1);
+ const y = p.tagTop(pane, p.rects[0]) + @as(u16, @intCast(pos.row));
const before = p.settings.syntax_bold;
p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .press } });
p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .release } });
try std.testing.expectEqual(!before, p.settings.syntax_bold);
- try std.testing.expectEqualStrings(text, try p.tagText(p.scratch.allocator(), pane));
}
test "terminal overlay recoloring never materializes unrelated history" {
@@ -1287,46 +1837,46 @@ test "terminal overlay recoloring never materializes unrelated history" {
const pane = p.panes[0].?;
pane.tty_filter = false;
for (0..1000) |_| p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[32mcaf\xc3\xa9 \xe7\x95\x8c\x1b[0m\r\n" } });
- pane.mode = .normal;
+ pane.body.mode = .normal;
pane.ovl = .{ .row = 0, .rows = 1, .text = try p.gpa.dupe(u8, "edited history") };
var frame = std.heap.ArenaAllocator.init(testing.allocator);
defer frame.deinit();
_ = try p.render(frame.allocator());
try testing.expect(p.shell_rows.pane == null);
- pane.ovl.?.row = panes.Terminal.gridOffset(pane);
+ pane.ovl.?.row = panes.terminal.gridOffset(pane);
p.gpa.free(pane.ovl.?.text);
pane.ovl.?.text = try p.gpa.dupe(u8, "caf\xc3\xa9 \xe7\x95\x8c");
_ = frame.reset(.retain_capacity);
const surface = try p.render(frame.allocator());
try testing.expect(p.shell_rows.pane == null);
const rect = p.rects[0];
- const body_y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const body_y = bodyY(p, rect);
const cell = surface.at(rect.x + config.GUTTER, body_y);
try testing.expectEqualStrings("c", cell.grapheme());
try testing.expectEqual(pardes.Color{ .rgb = p.theme().palette.?[2] }, cell.style.fg);
}
test "terminal output keeps following new rows after scrollback eviction" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
- pane.mode = .tty;
+ pane.body.mode = .tty;
pane.tty_filter = false;
const pages = &pane.terminal.?.vt.screens.active.pages;
- pages.explicit_max_size = 64 * 1024;
+ pages.limits.set(.bytes, 64 * 1024);
var frame = std.heap.ArenaAllocator.init(gpa);
defer frame.deinit();
var evictions: usize = 0;
for (0..3) |phase| {
if (phase > 0) {
- pane.mode = .normal;
- panes.Terminal.scrollGrid(pane, -30);
+ pane.body.mode = .normal;
+ panes.terminal.scrollGrid(pane, -30);
try std.testing.expect(pages.scrollbar().offset < pages.scrollbar().total - pane.rows);
- panes.Terminal.enterTty(p, 0);
+ panes.terminal.enterTty(p, 0);
}
for (phase * 20_000..(phase + 1) * 20_000) |n| {
var buf: [64]u8 = undefined;
@@ -1336,10 +1886,10 @@ test "terminal output keeps following new rows after scrollback eviction" {
if (pages.scrollbar().total < previous) evictions += 1;
}
try std.testing.expect(evictions > phase);
- try std.testing.expect(pages.page_size <= pages.maxSize());
+ try std.testing.expect(pages.page_size <= pages.limits.max(.bytes));
const sb = pages.scrollbar();
try std.testing.expectEqual(sb.total - pane.rows, sb.offset);
- const full = try panes.Terminal.screenTextAlloc(pane, gpa);
+ const full = try panes.terminal.screenTextAlloc(pane, gpa);
defer gpa.free(full);
var last_buf: [16]u8 = undefined;
const last = try std.fmt.bufPrint(&last_buf, "row-{d:0>5}", .{(phase + 1) * 20_000 - 1});
@@ -1349,7 +1899,7 @@ test "terminal output keeps following new rows after scrollback eviction" {
const surface = try p.render(frame.allocator());
const rect = p.rects[0];
const x = rect.x + config.GUTTER;
- const y = (if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H) + pane.rows - 2;
+ const y = (bodyY(p, rect)) + pane.rows - 2;
for (last, 0..) |byte, col| {
const cell = surface.at(x + @as(u16, @intCast(col)), y);
try std.testing.expectEqualStrings(&.{byte}, cell.grapheme());
@@ -1363,21 +1913,18 @@ test "terminal output keeps following new rows after scrollback eviction" {
try std.testing.expectEqualStrings("f", effect.write.bytes.slice());
try std.testing.expect(p.nextEffect() == null);
}
- const replay = &pane.terminal.?.replay;
- try std.testing.expectEqual(replay.bytes.len, replay.len);
- try std.testing.expect(replay.head > 0);
}
test "terminal edit stays on its surviving row when old scrollback is evicted" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
- pane.mode = .tty;
+ pane.body.mode = .tty;
const pages = &pane.terminal.?.vt.screens.active.pages;
- pages.explicit_max_size = 64 * 1024;
+ pages.limits.set(.bytes, 64 * 1024);
var next: usize = 0;
while (next < 3000) {
var buf: [32]u8 = undefined;
@@ -1389,12 +1936,12 @@ test "terminal edit stays on its surviving row when old scrollback is evicted" {
try std.testing.expect(next < 3000);
var last_buf: [16]u8 = undefined;
const last = try std.fmt.bufPrint(&last_buf, "row-{d:0>5}", .{next - 1});
- pane.mode = .normal;
+ pane.body.mode = .normal;
const original_row: i32 = @intCast(pages.scrollbar().total - 2);
pane.ovl = .{ .row = original_row, .rows = 1, .text = try gpa.dupe(u8, "my unsent edit") };
- pane.cur_row = original_row;
- pane.cur_col = 3;
- pane.cur_pinned = true;
+ pane.body.cur_row = original_row;
+ pane.body.cur_col = 3;
+ pane.body.cur_pinned = true;
var removed: usize = 0;
for (next..next + 3000) |n| {
var buf: [32]u8 = undefined;
@@ -1407,17 +1954,17 @@ test "terminal edit stays on its surviving row when old scrollback is evicted" {
}
}
try std.testing.expect(removed > 0 and removed < original_row);
- const full = try panes.Terminal.screenTextAlloc(pane, gpa);
+ const full = try panes.terminal.screenTextAlloc(pane, gpa);
defer gpa.free(full);
const row = original_row - @as(i32, @intCast(removed));
try std.testing.expectEqualStrings(last, modal.lineSlice(full, @intCast(row)));
try std.testing.expectEqual(row, pane.ovl.?.row);
- try std.testing.expectEqual(row, pane.cur_row);
+ try std.testing.expectEqual(row, pane.body.cur_row);
try std.testing.expectEqualStrings("my unsent edit", pane.ovl.?.text);
}
test "terminal edits and undo survive partial history clearing and whole-screen loss" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const Action = enum { clear_history, partial_clear_history, reset_primary, reset_alternate, evict_all, hidden_undo };
for (std.enums.values(Action)) |action| {
@@ -1425,91 +1972,105 @@ test "terminal edits and undo survive partial history clearing and whole-screen
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
- pane.mode = .tty;
+ pane.body.mode = .tty;
if (action == .reset_alternate)
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1049h" } });
- p.update(.{ .output = .{ .pane = 0, .bytes = "old row\r\n" ** 40 } });
+ p.update(.{ .output = .{ .pane = 0, .bytes = std.mem.asBytes(&@as([40][9]u8, @splat("old row\r\n".*))) } });
const pages = &pane.terminal.?.vt.screens.active.pages;
- pages.explicit_max_size = 64 * 1024;
+ pages.limits.set(.bytes, 64 * 1024);
const row: i32 = @as(i32, @intCast(pages.total_rows - pane.rows)) +
@as(i32, if (action == .partial_clear_history) -1 else 2);
- pane.mode = .normal;
+ pane.body.mode = .normal;
pane.ovl = .{ .row = row, .rows = if (action == .partial_clear_history) 3 else 2, .text = try gpa.dupe(u8, "edit one\nedit two") };
- pane.cur_row = row + 1;
- pane.cur_col = 4;
- pane.cur_pinned = true;
- pane.vsel = .{ .active = true, .row = row, .col = 1 };
- panes.Terminal.pushUndo(p, pane);
- pane.ed_redo[0] = panes.Terminal.snap(p, pane) orelse return error.SnapshotFailed;
- pane.ed_redo_len = 1;
+ pane.body.cur_row = row + 1;
+ pane.body.cur_col = 4;
+ pane.body.cur_pinned = true;
+ pane.body.vsel = .{ .active = true, .row = row, .col = 1 };
+ panes.terminal.pushUndo(p, pane);
+ const overlay = pane.ovl.?;
+ pane.body.ed_redo[0] = .{
+ .ovl = .{ .row = overlay.row, .rows = overlay.rows, .text = try gpa.dupe(u8, overlay.text) },
+ .cur_row = pane.body.cur_row,
+ .cur_col = pane.body.cur_col,
+ .vsel = pane.body.vsel,
+ };
+ pane.body.ed_redo_len = 1;
if (action == .hidden_undo) {
gpa.free(pane.ovl.?.text);
pane.ovl = null;
- panes.Terminal.enterTty(p, 0);
+ panes.terminal.enterTty(p, 0);
}
const bytes = switch (action) {
.clear_history, .partial_clear_history => "\x1b[3J",
.reset_primary, .reset_alternate => "\x1bc",
- .evict_all, .hidden_undo => "new row\r\n" ** 4000,
+ .evict_all, .hidden_undo => std.mem.asBytes(&@as([4000][9]u8, @splat("new row\r\n".*))),
};
p.update(.{ .output = .{ .pane = 0, .bytes = bytes } });
const expected: i32 = if (action == .clear_history) 2 else 0;
+ // The copy's top row was in the history ED 3 erased: the copy goes
+ // with it (terminal.zig's rule for rows that are gone), and the
+ // selection made in it too. Undo still has it, at the top.
+ if (action == .partial_clear_history) {
+ try std.testing.expect(pane.ovl == null);
+ try std.testing.expect(!pane.body.vsel.active);
+ }
+ if (action == .clear_history) try std.testing.expect(pane.ovl != null);
if (pane.ovl) |edit| {
try std.testing.expectEqual(expected, edit.row);
try std.testing.expectEqual(@as(i32, if (action == .clear_history or action == .partial_clear_history) 2 else 1), edit.rows);
try std.testing.expectEqualStrings("edit one\nedit two", edit.text);
- try std.testing.expectEqual(expected + 1, pane.cur_row);
- try std.testing.expectEqual(expected, pane.vsel.row);
+ try std.testing.expectEqual(expected + 1, pane.body.cur_row);
+ try std.testing.expectEqual(expected, pane.body.vsel.row);
}
- for ([_]panes.Terminal.Snapshot{ pane.ed_undo[0], pane.ed_redo[0] }) |snapshot| {
+ for ([_]panes.terminal.Snapshot{ pane.body.ed_undo[0], pane.body.ed_redo[0] }) |snapshot| {
try std.testing.expectEqual(expected, snapshot.ovl.?.row);
try std.testing.expectEqual(expected + 1, snapshot.cur_row);
try std.testing.expectEqualStrings("edit one\nedit two", snapshot.ovl.?.text);
}
try std.testing.expectEqual(@as(usize, 2), pane.terminal.?.vt.screens.active.pages.countTrackedPins());
- panes.Terminal.undo(p, pane);
+ panes.terminal.undo(p, pane);
try std.testing.expectEqualStrings("edit one\nedit two", pane.ovl.?.text);
try std.testing.expectEqual(expected, pane.ovl.?.row);
}
}
test "terminal lower scroll regions do not move edits above them" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
- pane.mode = .normal;
+ pane.body.mode = .normal;
p.update(.{ .output = .{ .pane = 0, .bytes = "top\r\nsecond\r\nthird" } });
pane.ovl = .{ .row = 1, .rows = 1, .text = try gpa.dupe(u8, "unsent") };
- pane.cur_row = 1;
- pane.cur_pinned = true;
- panes.Terminal.pushUndo(p, pane);
- const total = panes.Terminal.scrollbar(pane).total;
+ pane.body.cur_row = 1;
+ pane.body.cur_pinned = true;
+ panes.terminal.pushUndo(p, pane);
+ const total = panes.terminal.scrollbar(pane).total;
var setup: [64]u8 = undefined;
const bytes = try std.fmt.bufPrint(&setup, "\x1b[4;{d}r\x1b[{d};1H", .{ pane.rows, pane.rows });
p.update(.{ .output = .{ .pane = 0, .bytes = bytes } });
- p.update(.{ .output = .{ .pane = 0, .bytes = "tail\r\n" ** 50 } });
- try std.testing.expectEqual(total, panes.Terminal.scrollbar(pane).total);
+ p.update(.{ .output = .{ .pane = 0, .bytes = std.mem.asBytes(&@as([50][6]u8, @splat("tail\r\n".*))) } });
+ try std.testing.expectEqual(total, panes.terminal.scrollbar(pane).total);
try std.testing.expectEqual(@as(i32, 1), pane.ovl.?.row);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 1), pane.ed_undo[0].ovl.?.row);
- const full = try panes.Terminal.screenTextAlloc(pane, gpa);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.ed_undo[0].ovl.?.row);
+ const full = try panes.terminal.screenTextAlloc(pane, gpa);
defer gpa.free(full);
try std.testing.expect(std.mem.startsWith(u8, full, "top\nsecond\nthird\n"));
}
test "terminal eviction and lower-region scrolling in one read preserve a surviving edit" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
- pane.mode = .tty;
+ pane.body.mode = .tty;
const pages = &pane.terminal.?.vt.screens.active.pages;
- pages.explicit_max_size = 64 * 1024;
+ pages.limits.set(.bytes, 64 * 1024);
var next: usize = 0;
while (next < 3000) {
var buf: [32]u8 = undefined;
@@ -1522,23 +2083,23 @@ test "terminal eviction and lower-region scrolling in one read preserve a surviv
try std.testing.expect(next < 3000);
const removed = pages.pages.first.?.rows();
const old_row: i32 = @intCast(removed + 2);
- pane.mode = .normal;
+ pane.body.mode = .normal;
pane.ovl = .{ .row = old_row, .rows = 1, .text = try gpa.dupe(u8, "kept edit") };
- pane.cur_row = old_row;
- pane.cur_pinned = true;
- panes.Terminal.pushUndo(p, pane);
+ pane.body.cur_row = old_row;
+ pane.body.cur_pinned = true;
+ panes.terminal.pushUndo(p, pane);
const old_total = pages.total_rows;
var buf: [128]u8 = undefined;
const bytes = try std.fmt.bufPrint(&buf, "new\r\n\x1b[4;{d}r\x1b[{d};1Hregion\r\n", .{ pane.rows, pane.rows });
p.update(.{ .output = .{ .pane = 0, .bytes = bytes } });
try std.testing.expectEqual(old_total + 1 - removed, pages.total_rows);
try std.testing.expectEqual(@as(i32, 2), pane.ovl.?.row);
- try std.testing.expectEqual(@as(i32, 2), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 2), pane.ed_undo[0].ovl.?.row);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.ed_undo[0].ovl.?.row);
try std.testing.expectEqualStrings("kept edit", pane.ovl.?.text);
}
-test "tag prompt entry and cancellation preserve exact text and cursor state" {
+test "a prompt's entry and cancellation leave the tag, the body and its cursor as they were" {
const Case = struct { key: ?Key = null, save: bool = false, marker: []const u8 };
const cases = [_]Case{
.{ .marker = config.search_marker },
@@ -1554,61 +2115,52 @@ test "tag prompt entry and cancellation preserve exact text and cursor state" {
try pane.setOwnedCwd("/dír space");
const tail = " keep";
for (cases) |case| {
- @memcpy(pane.tag_tail[0..tail.len], tail);
- pane.tag_tail_len = tail.len;
- pane.tag_init = true;
- pane.tag_sel = true;
- pane.tag_col = 1;
- pane.cur_row = 1;
- pane.cur_col = 2;
- pane.cur_pinned = true;
+ try setTag(pane, tail);
+ pane.body.cur_row = 1;
+ pane.body.cur_col = 2;
+ pane.body.cur_pinned = true;
if (case.key) |key| {
p.update(.{ .key = key });
} else if (case.save) {
- p.startPrompt(pane, .save);
+ p.startPrompt(pane, &pane.body, .save);
} else {
- p.startPrompt(pane, .{ .search = config.search_marker });
+ p.startPrompt(pane, &pane.body, .{ .search = config.search_marker });
}
- try std.testing.expect(pane.tag_edit);
- try std.testing.expect(!pane.tag_sel);
- try std.testing.expectEqual(.insert, pane.mode);
- try std.testing.expectEqualDeep(modal.Normal.State{}, pane.normal);
- try std.testing.expectEqualStrings(tail, pane.tag_tail[0..tail.len]);
- try std.testing.expectEqualStrings(case.marker, pane.tag_tail[tail.len..pane.tag_tail_len]);
- try std.testing.expectEqual(pane.file.?.path.len + pane.tag_tail_len, pane.tag_col);
+ // The answer is typed into the prompt's own line, never the tag.
+ try std.testing.expect(pane.focus == .body);
+ try std.testing.expectEqual(.insert, pane.input.mode);
+ try std.testing.expectEqualStrings(case.marker, pane.promptText().?);
+ try std.testing.expectEqual(@as(i32, @intCast(case.marker.len)), pane.input.cur_col);
+ try std.testing.expectEqualStrings(tail, pane.tag.own.?);
+ try std.testing.expectEqualDeep(modal.Normal.State{}, pane.body.normal);
p.update(.{ .key = .{ .cp = Key.escape } });
try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(!pane.tag_edit);
- try std.testing.expectEqual(.normal, pane.mode);
- try std.testing.expectEqualStrings(tail, pane.tag_tail[0..pane.tag_tail_len]);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 2), pane.cur_col);
+ try std.testing.expect(pane.input.own == null);
+ try std.testing.expectEqual(.normal, pane.body.mode);
+ try std.testing.expectEqualStrings(tail, pane.tag.own.?);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.cur_col);
try std.testing.expectEqualStrings("one\ntwo\n", pane.file.?.content);
}
}
-test "tag prompt capacity refusal leaves the existing tail and input state untouched" {
+test "a prompt opens whatever the tag already holds" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("one\n");
- @memset(&pane.tag_tail, 'x');
- pane.tag_tail_len = pane.tag_tail.len - 1;
- pane.tag_init = true;
- pane.tag_col = 17;
- pane.tag_sel = true;
+ const full = try p.gpa.alloc(u8, pardes.memory.limits.max_tag_tail);
+ defer p.gpa.free(full);
+ @memset(full, 'x');
+ try setTag(pane, full);
for (0..3) |case| {
switch (case) {
- 0 => p.startPrompt(pane, .{ .search = config.search_marker }),
- 1 => p.startPrompt(pane, .save),
+ 0 => p.startPrompt(pane, &pane.body, .{ .search = config.search_marker }),
+ 1 => p.startPrompt(pane, &pane.body, .save),
else => p.update(.{ .key = .{ .cp = '|' } }),
}
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(!pane.tag_edit);
- try std.testing.expect(pane.tag_sel);
- try std.testing.expectEqual(.normal, pane.mode);
- try std.testing.expectEqual(@as(u16, 17), pane.tag_col);
- try std.testing.expectEqual(pane.tag_tail.len - 1, pane.tag_tail_len);
- for (pane.tag_tail) |byte| try std.testing.expectEqual(@as(u8, 'x'), byte);
+ try std.testing.expect(pane.prompt != .none);
+ try std.testing.expectEqualStrings(full, pane.tag.own.?);
+ p.update(.{ .key = .{ .cp = Key.escape } });
}
}
@@ -1616,41 +2168,45 @@ test "generated output refuses every pipe prompt before seeding the tag" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const content = try p.gpa.dupe(u8, "generated\n");
- const pane = try panes.Output.open(p, 1, "/", .{ .cmd = .Help }, "", content);
+ const pane = try panes.Output.open(p, p.freeSlot().?, "/", .{ .cmd = .Help }, "", content);
p.active = 1;
for ([_]Key{ .{ .cp = '|' }, .{ .cp = '|', .alt = true }, .{ .cp = '!' }, .{ .cp = '!', .alt = true } }) |key| {
p.update(.{ .key = key });
try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(!pane.tag_init);
- try std.testing.expect(!pane.tag_edit);
+ try std.testing.expect(pane.tag.own == null);
+ try std.testing.expect(pane.focus == .body);
try std.testing.expectEqualStrings("generated\n", pane.file.?.content);
}
}
-test "tag prompt owns the pipe behavior through cancellation and submission" {
+test "a prompt owns the pipe behavior through cancellation and submission" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("one\ntwo\n");
- pane.cur_row = 0;
- pane.cur_col = 2;
- pane.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
+ pane.body.cur_row = 0;
+ pane.body.cur_col = 2;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
for (std.enums.values(modal.Normal.PipeBehavior)) |how| {
- p.startPrompt(pane, .{ .pipe = .append });
+ p.startPrompt(pane, &pane.body, .{ .pipe = .append });
p.update(.{ .key = .{ .cp = Key.escape } });
- p.startPrompt(pane, .{ .pipe = how });
- try std.testing.expectEqual(how, pane.prompt.pipe.how);
+ p.startPrompt(pane, &pane.body, .{ .pipe = how });
+ try std.testing.expectEqual(how, pane.prompt.pipe);
p.update(.{ .key = .{ .cp = 'c', .text = "cat" } });
p.update(.{ .key = .{ .cp = Key.enter } });
- const pending = p.pipe_wait orelse return error.MissingPipe;
+ const pending = p.pipe.wait orelse return error.MissingPipe;
try std.testing.expectEqual(how, pending.how);
- try std.testing.expectEqualStrings("cat", pending.command);
+ // `$` runs the command in a subshell that reports its status
+ if (how == .keep)
+ try std.testing.expect(std.mem.indexOf(u8, pending.command, "\ncat\n") != null)
+ else
+ try std.testing.expectEqualStrings("cat", pending.command);
try std.testing.expectEqual(@as(usize, 1), pending.inputs.len);
try std.testing.expectEqualStrings(if (how.pipes()) "one" else "", pending.inputs[0].bytes);
try std.testing.expect(pane.prompt == .none);
}
}
-test "tag prompt cancellation restores the selection before regex previews" {
+test "prompt cancellation restores the selection before regex previews" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("one two one");
@@ -1659,152 +2215,76 @@ test "tag prompt cancellation restores the selection before regex previews" {
.{ .key = 'S', .pattern = " ", .secondary = 2 },
};
for (cases) |case| {
- pane.cur_row = 0;
- pane.cur_col = 10;
- pane.cur_pinned = true;
- pane.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
- pane.nsel = 0;
+ pane.body.cur_row = 0;
+ pane.body.cur_col = 10;
+ pane.body.cur_pinned = true;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
+ pane.body.nsel = 0;
p.update(.{ .key = .{ .cp = case.key } });
try std.testing.expect(pane.prompt == .search);
p.update(.{ .key = .{ .cp = case.pattern[0], .text = case.pattern } });
- try std.testing.expectEqual(case.secondary, pane.nsel);
+ try std.testing.expectEqual(case.secondary, pane.body.nsel);
p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expectEqual(@as(u8, 0), pane.nsel);
- try std.testing.expectEqual(@as(u8, 0), pane.nsel_snap);
- try std.testing.expectEqual(@as(i32, 10), pane.cur_col);
- try std.testing.expectEqual(@as(i32, 0), pane.vsel.col);
- try std.testing.expect(pane.vsel.active and pane.vsel.explicit);
+ try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
+ try std.testing.expectEqual(@as(u16, 0), pane.nsel_snap);
+ try std.testing.expectEqual(@as(i32, 10), pane.body.cur_col);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.vsel.col);
+ try std.testing.expect(pane.body.vsel.active and pane.body.vsel.explicit);
try std.testing.expectEqualStrings("one two one", pane.file.?.content);
}
}
-test "tag prompt prefix allocation failure preserves an already seeded prompt" {
- const Request = @typeInfo(@TypeOf(Pardes.startPrompt)).@"fn".params[2].type.?;
+test "a prompt that cannot be opened leaves the open one as it was" {
+ const Request = @typeInfo(@TypeOf(Pardes.startPrompt)).@"fn".param_types[3].?;
for ([_]Request{ .{ .search = config.search_marker }, .save, .{ .pipe = .replace }, .{ .pipe = .ignore }, .{ .pipe = .insert }, .{ .pipe = .append } }) |request| {
var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{});
const p = try Pardes.init(failing.allocator(), .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("one\n");
- const tail = " keep /prior";
- @memcpy(pane.tag_tail[0..tail.len], tail);
- pane.tag_tail_len = tail.len;
- pane.tag_init = true;
- pane.prompt = .{ .search = 5 };
- pane.tag_edit = true;
- pane.tag_sel = true;
- pane.tag_col = 14;
- pane.tag_anchor = 7;
- pane.normal = .{ .count = 9, .prefix = .goto };
- const previous_prompt = pane.prompt;
- const previous_normal = pane.normal;
+ p.startPrompt(pane, &pane.body, .{ .search = config.search_marker });
+ p.update(.{ .key = .{ .cp = 'p', .text = "prior" } });
+ pane.body.normal = .{ .count = 9, .prefix = .goto };
+ const previous_normal = pane.body.normal;
_ = p.scratch.reset(.free_all);
failing.fail_index = failing.alloc_index;
- p.startPrompt(pane, request);
+ p.startPrompt(pane, &pane.body, request);
try std.testing.expect(failing.has_induced_failure);
- try std.testing.expectEqualDeep(previous_prompt, pane.prompt);
- try std.testing.expectEqualDeep(previous_normal, pane.normal);
- try std.testing.expectEqualStrings(tail, pane.tag_tail[0..pane.tag_tail_len]);
- try std.testing.expect(pane.tag_edit and pane.tag_sel);
- try std.testing.expectEqual(.normal, pane.mode);
- try std.testing.expectEqual(@as(u16, 14), pane.tag_col);
- try std.testing.expectEqual(@as(u16, 7), pane.tag_anchor);
+ try std.testing.expect(pane.prompt == .search);
+ try std.testing.expectEqualStrings(config.search_marker ++ "prior", pane.promptText().?);
+ try std.testing.expectEqualDeep(previous_normal, pane.body.normal);
+ try std.testing.expect(pane.tag.own == null and pane.focus == .body);
}
}
-test "tag prompt Save requires room for its complete directory prefix" {
+test "Save's prompt starts from the pane's directory" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("one\n");
for ([_][]const u8{ "/dír space", "/dír space/", "" }) |dir| {
try pane.setOwnedCwd(dir);
- const slash: usize = @intFromBool(dir.len == 0 or dir[dir.len - 1] != '/');
- const needed = config.save_marker.len + dir.len + slash;
- for ([_]usize{ 1, 0 }) |shortfall| {
- @memset(&pane.tag_tail, 'x');
- pane.tag_tail_len = pane.tag_tail.len - needed + shortfall;
- pane.tag_init = true;
- pane.tag_edit = false;
- pane.tag_sel = true;
- pane.tag_col = 17;
- const start = pane.tag_tail_len;
- p.startPrompt(pane, .save);
- if (shortfall != 0) {
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expectEqual(start, pane.tag_tail_len);
- try std.testing.expect(!pane.tag_edit and pane.tag_sel);
- try std.testing.expectEqual(@as(u16, 17), pane.tag_col);
- for (pane.tag_tail) |byte| try std.testing.expectEqual(@as(u8, 'x'), byte);
- } else {
- try std.testing.expect(pane.prompt == .save);
- try std.testing.expectEqual(pane.tag_tail.len, pane.tag_tail_len);
- try std.testing.expectEqualStrings(config.save_marker, pane.tag_tail[start..][0..config.save_marker.len]);
- try std.testing.expectEqualStrings(dir, pane.tag_tail[start + config.save_marker.len ..][0..dir.len]);
- try std.testing.expectEqual(@as(u8, '/'), pane.tag_tail[pane.tag_tail_len - 1]);
- p.update(.{ .key = .{ .cp = Key.escape } });
- }
- }
+ const slash = if (dir.len == 0 or dir[dir.len - 1] != '/') "/" else "";
+ p.startPrompt(pane, &pane.body, .save);
+ try std.testing.expect(pane.prompt == .save);
+ const answer = pane.promptText().?;
+ try std.testing.expect(std.mem.startsWith(u8, answer, config.save_marker));
+ try std.testing.expectEqualStrings(dir, answer[config.save_marker.len..][0..dir.len]);
+ try std.testing.expectEqualStrings(slash, answer[config.save_marker.len + dir.len ..]);
+ p.update(.{ .key = .{ .cp = Key.escape } });
}
}
-test "tag prompt successful seeded entry needs one scratch allocation" {
- const Request = @typeInfo(@TypeOf(Pardes.startPrompt)).@"fn".params[2].type.?;
+test "a prompt opens with one allocation" {
+ const Request = @typeInfo(@TypeOf(Pardes.startPrompt)).@"fn".param_types[3].?;
for ([_]Request{ .{ .search = config.search_marker }, .save, .{ .pipe = .replace }, .{ .pipe = .ignore }, .{ .pipe = .insert }, .{ .pipe = .append } }) |request| {
var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{});
const p = try Pardes.init(failing.allocator(), .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("one\n");
- pane.tag_tail_len = 0;
- pane.tag_init = true;
_ = p.scratch.reset(.free_all);
const before = failing.alloc_index;
- p.startPrompt(pane, request);
+ p.startPrompt(pane, &pane.body, request);
try std.testing.expectEqual(before + 1, failing.alloc_index);
- try std.testing.expect(pane.tag_edit and pane.mode == .insert);
- }
-}
-
-test "tag prompt failure may initialize only the default tail" {
- const Request = @typeInfo(@TypeOf(Pardes.startPrompt)).@"fn".params[2].type.?;
- for ([_]Request{ .{ .search = config.search_marker }, .save, .{ .pipe = .replace }, .{ .pipe = .ignore }, .{ .pipe = .insert }, .{ .pipe = .append } }) |request| {
- var saw_seeded_failure = false;
- var succeeded = false;
- for (0..16) |failure| {
- var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{});
- const p = try Pardes.init(failing.allocator(), .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("one\n");
- const path = try p.gpa.dupe(u8, "/" ++ "a" ** 2048 ++ ".zig");
- p.gpa.free(pane.file.?.path);
- pane.file.?.path = path;
- p.seedTail(pane);
- try std.testing.expect(pane.tag_init);
- const default_tail = pane.tag_tail;
- const default_len = pane.tag_tail_len;
- pane.tag_init = false;
- pane.tag_tail_len = 0;
- pane.tag_col = 17;
- pane.tag_sel = true;
- pane.normal = .{ .count = 9, .prefix = .goto };
- const previous_normal = pane.normal;
- _ = p.scratch.reset(.free_all);
- failing.fail_index = failing.alloc_index + failure;
- p.startPrompt(pane, request);
- if (!failing.has_induced_failure) {
- try std.testing.expect(pane.tag_edit and pane.mode == .insert);
- succeeded = true;
- break;
- }
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(!pane.tag_edit and pane.tag_sel);
- try std.testing.expectEqual(.normal, pane.mode);
- try std.testing.expectEqualDeep(previous_normal, pane.normal);
- try std.testing.expectEqual(@as(u16, 17), pane.tag_col);
- if (pane.tag_init) {
- saw_seeded_failure = true;
- try std.testing.expectEqualStrings(default_tail[0..default_len], pane.tag_tail[0..pane.tag_tail_len]);
- } else try std.testing.expectEqual(@as(usize, 0), pane.tag_tail_len);
- }
- try std.testing.expect(succeeded and saw_seeded_failure);
+ try std.testing.expect(pane.focus == .body and pane.input.mode == .insert);
}
}
@@ -1825,14 +2305,14 @@ test "file history construction failures preserve existing panes" {
defer if (incoming) |bytes| p.gpa.free(bytes);
failing.fail_index = failing.alloc_index + failure;
const result = switch (case) {
- .open => panes.File.open(p, 1, path, 0),
+ .open => panes.File.open(p, p.freeSlot().?, path, 0),
.restore => panes.File.restore(p, 1, .{
.kind = .file,
.tag = "",
.body = "",
.file = .{ .path = "/restored.zig", .content = "restored\n" },
}),
- .output => panes.Output.open(p, 1, "/", .{ .cmd = .Help }, "", incoming.?),
+ .output => panes.Output.open(p, p.freeSlot().?, "/", .{ .cmd = .Help }, "", incoming.?),
.tutor => p.openTutorView(1),
.replace => p.setTestFile("replacement\n"),
};
@@ -1900,14 +2380,14 @@ test "file history owns bounded snapshot storage without per-edit bookkeeping al
try std.testing.expectEqual(@as(usize, 0), history.redo_len);
}
-test "file history allocation precedes a filesystem read with side effects" {
+test "file history allocation precedes reading the served tree" {
var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{});
const p = try Pardes.init(failing.allocator(), .{ .tty_only = true, .cols = 40, .rows = 12 });
defer p.deinit();
const original = p.panes[0].?;
const serial = p.next_serial;
failing.fail_index = failing.alloc_index + 2;
- try std.testing.expectError(error.OutOfMemory, panes.File.open(p, 1, "/n/self/new", 0));
+ try std.testing.expectError(error.OutOfMemory, panes.File.open(p, p.freeSlot().?, "/n/self/index", 0));
try std.testing.expect(failing.has_induced_failure);
try std.testing.expectEqual(original, p.panes[0].?);
try std.testing.expectEqual(serial, p.next_serial);
@@ -1931,7 +2411,7 @@ test "file history survives PDF fallback restoration and allocation failures" {
var succeeded = false;
for (0..256) |failure| {
var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{ .fail_index = failure });
- if (Pardes.initFromDump(failing.allocator(), .{ .tty_only = true }, saved)) |p| {
+ if (pardes.dump.initFromDump(failing.allocator(), .{ .tty_only = true }, saved)) |p| {
defer p.deinit();
const pane = p.panes[0].?;
try std.testing.expect(pane.file != null);
@@ -2041,21 +2521,48 @@ test "Save on a scratch does not watch a path the host could not create" {
const id = p.active;
while (p.nextEffect()) |_| {}
p.host = .{ .ctx = p, .vtable = &.{ .write_file = Refusing.write } };
+ const file = &p.panes[id].?.file.?;
+ const scratch_name = try std.testing.allocator.dupe(u8, file.path);
+ defer std.testing.allocator.free(scratch_name);
+ const was_dirty = file.revision != file.saved_revision;
try std.testing.expect(p.executeBuiltinLine(id, "Save /new-file.txt"));
while (p.nextEffect()) |effect| p.perform(effect);
- const file = &p.panes[id].?.file.?;
- try std.testing.expect(file.output == null);
- try std.testing.expect(file.watch_after_save);
- try std.testing.expect(file.revision != file.saved_revision);
+ // Failed, it changed nothing: still the scratch, its name and dirty
+ // flag as they were, unwatched.
+ try std.testing.expect(file.output != null);
+ try std.testing.expectEqualStrings(scratch_name, file.path);
+ try std.testing.expectEqual(was_dirty, file.revision != file.saved_revision);
try std.testing.expect(!p.fallback.watched[id]);
p.host = .{};
- try std.testing.expect(p.executeBuiltinLine(id, "Save"));
+ try std.testing.expect(p.executeBuiltinLine(id, "Save /new-file.txt"));
while (p.nextEffect()) |effect| p.perform(effect);
- try std.testing.expect(!file.watch_after_save);
+ try std.testing.expect(file.output == null);
+ try std.testing.expectEqualStrings("/new-file.txt", file.path);
try std.testing.expectEqual(file.revision, file.saved_revision);
try std.testing.expect(p.fallback.watched[id]);
}
+test "a failed Save to another name leaves a clean named file clean" {
+ const Refusing = struct {
+ fn write(ctx: ?*anyopaque, id: u8, _: []const u8, _: []const u8) void {
+ const p: *Pardes = @ptrCast(@alignCast(ctx.?));
+ p.saveFailed(id, "save", error.AccessDenied);
+ }
+ };
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("clean\n");
+ while (p.nextEffect()) |_| {}
+ const file = &pane.file.?;
+ try std.testing.expectEqual(file.revision, file.saved_revision);
+ p.host = .{ .ctx = p, .vtable = &.{ .write_file = Refusing.write } };
+ try std.testing.expect(p.executeBuiltinLine(0, "Save /root/x.txt"));
+ while (p.nextEffect()) |effect| p.perform(effect);
+ try std.testing.expectEqual(file.revision, file.saved_revision);
+ try std.testing.expectEqualStrings("/test.txt", file.path);
+ p.host = .{};
+}
+
test "unplaced terminal panes keep their allocated grid until placement" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 30 });
defer p.deinit();
@@ -2077,7 +2584,7 @@ test "unplaced terminal panes keep their allocated grid until placement" {
p.update(.tick);
try std.testing.expect(p.rects[id].w > 0 and p.rects[id].h > pardes.BOX_H);
try std.testing.expectEqual(p.rects[id].w - config.GUTTER, pane.cols);
- try std.testing.expectEqual(p.rects[id].h - pardes.BOX_H, pane.rows);
+ try std.testing.expectEqual(bodyH(p, p.rects[id]), pane.rows);
}
test "document panes ignore terminal output without allocating terminal state" {
@@ -2085,6 +2592,7 @@ test "document panes ignore terminal output without allocating terminal state" {
const p = try Pardes.init(allocator.allocator(), .{ .tty_only = true });
defer p.deinit();
const pane = try p.setTestFile("document body\n");
+ p.update(.tick); // the step that installed it records it in /log
while (p.nextEffect()) |_| {}
const revision = pane.file.?.revision;
const allocations = allocator.alloc_index;
@@ -2234,6 +2742,146 @@ const OutputTests = struct {
}
}
+ test "stacked Callstack aligns source below locations and keeps exact emphasis and navigation" {
+ if (!syntax.enabled) return error.SkipZigTest;
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 30 });
+ defer p.deinit();
+ const source = " pub fn caller(\n value: u32,\n ) void {\n work(value);\n }\n";
+ const pane = try TreeContextTests.setZigFile(p, source);
+ try std.testing.expectEqual(config.Runtime.CallstackLayout.stacked, p.settings.callstack_layout);
+ const input = try std.fmt.allocPrint(p.gpa, "╰──╮ {s}:1:12-17 caller\n@callstack-match ╰─ {s}:4:9-12 work(value);\n", .{ pane.file.?.path, pane.file.?.path });
+ try fillResults(p, 0, "/", .{ .query = .callstack }, "", input, null);
+ const result_id = pane.search_pane.?;
+ const result = p.panes[result_id].?;
+ const file = &result.file.?;
+ try std.testing.expectEqual(@as(usize, 6), file.location_rows.len);
+ try std.testing.expectEqualStrings(" │ pub fn caller(", modal.lineSlice(file.content, 1));
+ try std.testing.expectEqualStrings(" │ value: u32,", modal.lineSlice(file.content, 2));
+ try std.testing.expectEqualStrings(" │ ) void {", modal.lineSlice(file.content, 3));
+ try std.testing.expectEqualStrings(" work(value);", modal.lineSlice(file.content, 5));
+ const site = file.location_rows[5];
+ try std.testing.expectEqual(@as(usize, 8), site.source_column);
+ try std.testing.expect(site.colors.len > 0);
+ const text = modal.lineSlice(file.content, 5);
+ const decoration = panes.Output.decorateRow(file.output, text, site);
+ try std.testing.expectEqualStrings("work", text[decoration.mark_start..decoration.mark_end]);
+ for (file.location_rows, 0..) |row, i| {
+ try std.testing.expectEqual(i == 0 or i == 4, panes.Output.isResultRow(file, i));
+ if (i != 5) try std.testing.expect(!row.mark_occurrence);
+ }
+ p.active = result_id;
+ result.body.cur_row = 4;
+ result.body.cur_col = " └─ ".len;
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ try std.testing.expectEqual(@as(usize, 0), p.active);
+ try std.testing.expectEqual(@as(i32, 3), pane.body.cur_row);
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?);
+ defer restored.deinit();
+ try std.testing.expectEqual(config.Runtime.CallstackLayout.stacked, restored.settings.callstack_layout);
+ const after = restored.panes[result_id].?.file.?;
+ try std.testing.expectEqualStrings(file.content, after.content);
+ try std.testing.expectEqual(@as(usize, 8), after.location_rows[5].source_column);
+ const restored_decoration = panes.Output.decorateRow(after.output, text, after.location_rows[5]);
+ try std.testing.expectEqual(decoration, restored_decoration);
+ try std.testing.expect(p.executeBuiltinLine(0, "CallstackLayout inline"));
+ try fillResults(p, 0, "/", .{ .query = .callstack }, "", try p.gpa.dupe(u8, "No callers reported\n"), null);
+ try std.testing.expectEqual(config.Runtime.CallstackLayout.@"inline", p.settings.callstack_layout);
+ }
+
+ test "Callstack signatures share unsaved tree context and keep guides out of Look selections" {
+ if (!syntax.enabled) return error.SkipZigTest;
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 110, .rows = 30 });
+ defer p.deinit();
+ p.settings.callstack_layout = .@"inline";
+ const source = "const Box = struct {\n" ++
+ " pub fn caller(\n" ++
+ " value: u32,\n" ++
+ " ) void {\n" ++
+ " work(value);\n" ++
+ " }\n};\n";
+ const pane = try TreeContextTests.setZigFile(p, source);
+ const path = pane.file.?.path;
+ const input = try std.fmt.allocPrint(p.gpa, "├──┬ {s}:2:12-17 caller\n@callstack-match │ └─ {s}:5:9-12 work(value);\n└─── missing.zig:3:4-8 other ↻ recursion\n", .{ path, path });
+ try fillResults(p, 0, "/", .{ .query = .callstack }, "", input, null);
+ const result_id = pane.search_pane.?;
+ const result = p.panes[result_id].?;
+ const file = &result.file.?;
+ try std.testing.expect(std.mem.indexOf(u8, file.content, "pub fn caller(") != null);
+ try std.testing.expect(std.mem.indexOf(u8, file.content, "value: u32,") != null);
+ try std.testing.expect(std.mem.indexOf(u8, file.content, "const Box") == null);
+ try std.testing.expect(std.mem.indexOf(u8, file.content, "other ↻ recursion") != null);
+ try std.testing.expectEqual(@as(usize, 5), file.location_rows.len);
+ for (file.location_rows[0..3]) |row| {
+ try std.testing.expect(!row.declaration);
+ try std.testing.expect(!row.mark_occurrence);
+ try std.testing.expect(row.colors.len > 0);
+ }
+ for (1..3) |index| try std.testing.expect(std.mem.startsWith(u8, modal.lineSlice(file.content, index), "│ │ "));
+ const analysis = try syntax.analyzeSource(p.scratch.allocator(), path, source, true, true);
+ for (file.location_rows[0..3], 1..) |row, source_row| {
+ const offset = modal.lineStartOffset(source, source_row);
+ try std.testing.expectEqualSlices(u8, analysis.colors[offset..][0..row.colors.len], row.colors);
+ }
+ try std.testing.expect(file.location_rows[3].mark_occurrence);
+ try std.testing.expect(!file.location_rows[3].declaration);
+ try std.testing.expect(!panes.Output.isWalkRow(file, 1, modal.lineSlice(file.content, 1)));
+ p.active = result_id;
+ result.body.cur_row = 0;
+ result.body.cur_col = 0;
+ p.update(.{ .key = .{ .cp = ' ' } });
+ p.update(.{ .key = .{ .cp = 'j' } });
+ p.update(.{ .key = .{ .cp = 'n' } });
+ try std.testing.expectEqual(@as(i32, 0), result.body.cur_row);
+ try std.testing.expectEqual(@as(i32, "├──┬ ".len), result.body.cur_col);
+ // Enter on the selected signature address must open source, not a path
+ // accidentally prefixed with tree glyphs.
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ try std.testing.expectEqual(@as(usize, 0), p.active);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
+ p.settings.callstack_depth = 16;
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?);
+ defer restored.deinit();
+ try std.testing.expectEqual(@as(u8, 16), restored.settings.callstack_depth);
+ const restored_file = restored.panes[result_id].?.file.?;
+ try std.testing.expectEqualStrings(file.content, restored_file.content);
+ try std.testing.expectEqual(file.location_rows.len, restored_file.location_rows.len);
+ for (file.location_rows, restored_file.location_rows) |before, after| {
+ try std.testing.expectEqual(before.mark_occurrence, after.mark_occurrence);
+ try std.testing.expectEqual(before.at, after.at);
+ try std.testing.expectEqual(before.code_start, after.code_start);
+ try std.testing.expectEqualSlices(u8, before.colors, after.colors);
+ }
+ // Narrow enough that the location itself wraps. The repeated guide
+ // consumes cells, but neither changes the source address nor steals
+ // a click from the wrapped portion of that address.
+ p.active = result_id;
+ p.row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 8, .tagline_h = 10 };
+ p.update(.{ .resize = .{ .cols = 28, .rows = 40 } });
+ result.file.?.scroll = 0;
+ var frame = std.heap.ArenaAllocator.init(p.gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const wrapped = for (0..result.wrap_n) |vr| {
+ const w = result.wrapAt(@intCast(vr));
+ if (w.line == 0 and w.pad > 0 and w.at < file.location_rows[0].location_end) break vr;
+ } else return error.MissingWrappedLocation;
+ const w = result.wrapAt(@intCast(wrapped));
+ const shown = try panes.File.bodyText(frame.allocator(), result, file, true);
+ const shown_line = modal.lineSlice(shown, wrapped);
+ try std.testing.expect(std.mem.startsWith(u8, shown_line[panes.File.gutterWidth(result)..], "│ │ "));
+ const rect = p.rects[result_id];
+ const press: pardes.Mouse = .{ .button = .right, .kind = .press, .col = @intCast(rect.x + config.GUTTER + panes.File.gutterWidth(result) + w.pad + 1), .row = @intCast(p.bodyTop(result, rect) + wrapped) };
+
+ var release = press;
+ release.kind = .release;
+ p.update(.{ .mouse = press });
+ p.update(.{ .mouse = release });
+ try std.testing.expectEqual(@as(usize, 0), p.active);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
+ }
+
test "Locations context uses unsaved sources and navigation visits only matches" {
if (!syntax.enabled) return error.SkipZigTest;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 30 });
@@ -2279,17 +2927,17 @@ const OutputTests = struct {
}
try std.testing.expectEqual(@as(usize, 2), count);
try std.testing.expectEqual(matches[1], pane.search_row.?);
- try std.testing.expect(pardes.test_api.searchStep(p, 0, -1));
+ try std.testing.expect(pardes.look.searchStep(p, 0, -1));
try std.testing.expectEqual(matches[0], pane.search_row.?);
- try std.testing.expectEqual(@as(i32, 3), pane.cur_row);
- try std.testing.expect(pardes.test_api.searchStep(p, 0, 1));
+ try std.testing.expectEqual(@as(i32, 3), pane.body.cur_row);
+ try std.testing.expect(pardes.look.searchStep(p, 0, 1));
try std.testing.expectEqual(matches[1], pane.search_row.?);
- try std.testing.expectEqual(@as(i32, 5), pane.cur_row);
- try std.testing.expect(pardes.test_api.searchStep(p, 0, 1));
+ try std.testing.expectEqual(@as(i32, 5), pane.body.cur_row);
+ try std.testing.expect(pardes.look.searchStep(p, 0, 1));
try std.testing.expectEqual(matches[1], pane.search_row.?);
pane.search_row = null;
- try std.testing.expect(pardes.test_api.searchStep(p, 0, 1));
+ try std.testing.expect(pardes.look.searchStep(p, 0, 1));
try std.testing.expectEqual(matches[0], pane.search_row.?);
var frame = std.heap.ArenaAllocator.init(p.gpa);
defer frame.deinit();
@@ -2307,8 +2955,8 @@ const OutputTests = struct {
neighbor_colored = neighbor_colored or style != 0;
try std.testing.expect(neighbor_colored);
- try p.dumpState();
- const restored = try Pardes.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?);
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?);
defer restored.deinit();
const restored_source = restored.panes[0].?;
const restored_id = pane.search_pane.?;
@@ -2331,11 +2979,11 @@ const OutputTests = struct {
// still governs stepping when that output is attached to a source.
restored_source.search_pane = restored_id;
restored_source.search_row = null;
- try std.testing.expect(pardes.test_api.searchStep(restored, 0, 1));
+ try std.testing.expect(pardes.look.searchStep(restored, 0, 1));
try std.testing.expectEqual(matches[0], restored_source.search_row.?);
- try std.testing.expect(pardes.test_api.searchStep(restored, 0, 1));
+ try std.testing.expect(pardes.look.searchStep(restored, 0, 1));
try std.testing.expectEqual(matches[1], restored_source.search_row.?);
- try std.testing.expect(pardes.test_api.searchStep(restored, 0, -1));
+ try std.testing.expect(pardes.look.searchStep(restored, 0, -1));
try std.testing.expectEqual(matches[0], restored_source.search_row.?);
// Editing drops source metadata; hidden context padding still keeps
@@ -2343,9 +2991,9 @@ const OutputTests = struct {
panes.File.setContent(p, file, try p.gpa.dupe(u8, file.content));
try std.testing.expectEqual(@as(usize, 0), file.location_rows.len);
pane.search_row = null;
- try std.testing.expect(pardes.test_api.searchStep(p, 0, 1));
+ try std.testing.expect(pardes.look.searchStep(p, 0, 1));
try std.testing.expectEqual(matches[0], pane.search_row.?);
- try std.testing.expect(pardes.test_api.searchStep(p, 0, 1));
+ try std.testing.expect(pardes.look.searchStep(p, 0, 1));
try std.testing.expectEqual(matches[1], pane.search_row.?);
}
@@ -2411,8 +3059,8 @@ const OutputTests = struct {
try std.testing.expectEqual(.match, file.location_rows[next].kind);
const wrapped = panes.Output.nextResult(file.content, file.location_rows, path, .{ .line = 99 });
try std.testing.expectEqual(@as(usize, 2), file.location_rows[wrapped].at.line);
- try p.dumpState();
- const restored = try Pardes.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?);
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?);
defer restored.deinit();
const restored_file = &restored.panes[pane.search_pane.?].?.file.?;
try std.testing.expectEqualStrings(file.content, restored_file.content);
@@ -2429,7 +3077,7 @@ const OutputTests = struct {
layout.compute(p);
const surface = try p.render(frame.allocator());
const rect = p.rects[pane.search_pane.?];
- const body_y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const body_y = bodyY(p, rect);
for (file.location_rows, 0..) |row, index| {
if (!row.declaration) continue;
const line = modal.lineSlice(file.content, index);
@@ -2462,9 +3110,9 @@ const OutputTests = struct {
const id = p.active;
const help = p.panes[id].?;
for ("gevkk") |key| p.update(.{ .key = .{ .cp = key } });
- try std.testing.expect(help.vsel.active);
- try std.testing.expect(help.vsel.row > 5);
- try std.testing.expect(help.cur_row != help.vsel.row);
+ try std.testing.expect(help.body.vsel.active);
+ try std.testing.expect(help.body.vsel.row > 5);
+ try std.testing.expect(help.body.cur_row != help.body.vsel.row);
for (" h?") |key| p.update(.{ .key = .{ .cp = key } });
try std.testing.expectEqual(id, p.active);
const content = help.file.?.content;
@@ -2477,7 +3125,7 @@ const OutputTests = struct {
_ = try p.render(frame.allocator());
const rect = p.rects[id];
const x = rect.x + config.GUTTER + panes.File.gutterWidth(help) + @as(u16, @intCast(at - line_start + 2));
- const y = (if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H) + @as(u16, @intCast(row));
+ const y = (bodyY(p, rect)) + @as(u16, @intCast(row));
p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .press, .col = x, .row = y } });
p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .release, .col = x, .row = y } });
try std.testing.expect(p.active != id);
@@ -2498,35 +3146,35 @@ const OutputTests = struct {
const result = p.panes[id].?;
p.active = id;
for ("Cv3") |key| p.update(.{ .key = .{ .cp = key } });
- try std.testing.expect(result.nsel > 0);
- try std.testing.expect(result.select);
- try std.testing.expect(result.vsel.active);
- try std.testing.expect(result.normal.count > 0);
+ try std.testing.expect(result.body.nsel > 0);
+ try std.testing.expect(result.body.select);
+ try std.testing.expect(result.body.vsel.active);
+ try std.testing.expect(result.body.normal.count > 0);
result.file.?.scroll = 1;
result.hscroll = 2;
- const selected = result.vsel;
- const selections = result.nsel;
- const cursor_row = result.cur_row;
- const cursor_col = result.cur_col;
+ const selected = result.body.vsel;
+ const selections = result.body.nsel;
+ const cursor_row = result.body.cur_row;
+ const cursor_col = result.body.cur_col;
try fillResults(p, 0, "/", .{ .query = .hover }, "", try p.gpa.dupe(u8, content), null);
- try std.testing.expectEqual(selected, result.vsel);
- try std.testing.expectEqual(selections, result.nsel);
- try std.testing.expectEqual(cursor_row, result.cur_row);
- try std.testing.expectEqual(cursor_col, result.cur_col);
+ try std.testing.expectEqual(selected, result.body.vsel);
+ try std.testing.expectEqual(selections, result.body.nsel);
+ try std.testing.expectEqual(cursor_row, result.body.cur_row);
+ try std.testing.expectEqual(cursor_col, result.body.cur_col);
try std.testing.expectEqual(@as(usize, 1), result.file.?.scroll);
try std.testing.expectEqual(@as(i32, 2), result.hscroll);
- try std.testing.expect(result.normal.count > 0);
+ try std.testing.expect(result.body.normal.count > 0);
try fillResults(p, 0, "/", .{ .query = .hover }, "", try p.gpa.dupe(u8, "short\n"), null);
try std.testing.expectEqualStrings("short\n", result.file.?.content);
- try std.testing.expect(!result.vsel.active and !result.msel.active and !result.select);
- try std.testing.expectEqual(@as(u8, 0), result.nsel);
- try std.testing.expectEqual(@as(i32, 0), result.cur_row);
- try std.testing.expectEqual(@as(i32, 0), result.cur_col);
+ try std.testing.expect(!result.body.vsel.active and !result.body.msel.active and !result.body.select);
+ try std.testing.expectEqual(@as(u16, 0), result.body.nsel);
+ try std.testing.expectEqual(@as(i32, 0), result.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 0), result.body.cur_col);
try std.testing.expectEqual(@as(usize, 0), result.file.?.scroll);
try std.testing.expectEqual(@as(i32, 0), result.hscroll);
- try std.testing.expectEqual(modal.Normal.State{}, result.normal);
+ try std.testing.expectEqual(modal.Normal.State{}, result.body.normal);
}
test "generated result replacement cancels an in-progress body selection" {
@@ -2547,16 +3195,16 @@ const OutputTests = struct {
p.acknowledgePanelPresentation(&.{});
const rect = p.rects[id];
const x = rect.x + config.GUTTER + panes.File.gutterWidth(result);
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = bodyY(p, rect);
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = x, .row = y } });
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .drag, .col = x + 2, .row = y + 1 } });
try std.testing.expect(p.drag == .select);
- try std.testing.expectEqual(.dragging, result.sel[@intFromEnum(config.select_button)].state);
+ try std.testing.expectEqual(.dragging, result.sel[@backingInt(config.select_button)].state);
try fillResults(p, 0, "/", .{ .query = .hover }, "", try p.gpa.dupe(u8, "short\n"), null);
try std.testing.expect(p.drag == .none);
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = x + 2, .row = y + 1 } });
for (result.sel) |selection| try std.testing.expectEqual(.none, selection.state);
- try std.testing.expect(!result.vsel.active and !result.msel.active);
+ try std.testing.expect(!result.body.vsel.active and !result.body.msel.active);
}
test "dump origins accept only builtins that actually own output panes" {
@@ -2642,23 +3290,18 @@ const ImageTests = struct {
const togglePalette = panes.Image.togglePalette;
const toggleAscii = panes.Image.toggleAscii;
const tagPrefix = panes.Image.tagPrefix;
- const legacySavedPrefix = panes.Image.legacySavedPrefix;
test "pane-local renderer choices are visible in the image tag" {
var state: State = .{ .path = @constCast("/tmp/picture.ppm") };
toggleGlyphArt(&state);
togglePalette(&state);
toggleAscii(&state);
- const tag = try tagPrefix(std.testing.allocator, &state);
+ const tag = try tagPrefix(std.testing.allocator, &state, state.glyph_art);
defer std.testing.allocator.free(tag);
try std.testing.expectEqualStrings(
config.tag_image ++ " petscii:on palette:terminal ascii:off /tmp/picture.ppm",
tag,
);
- try std.testing.expectEqualStrings(
- "img /tmp/picture.ppm",
- legacySavedPrefix(&state, "img /tmp/picture.ppm Keep Del").?,
- );
}
test "dump restore propagates malformed embedded image bytes" {
@@ -2681,7 +3324,6 @@ const PdfTests = struct {
const Point = panes.Pdf.Point;
const Document = panes.Pdf.Document;
const isPath = panes.Pdf.isPath;
- const legacySavedPrefix = panes.Pdf.legacySavedPrefix;
const State = panes.Pdf.State;
const probeWord = panes.Pdf.probeWord;
const pointAtGeometry = panes.Pdf.pointAtGeometry;
@@ -2694,26 +3336,10 @@ const PdfTests = struct {
try std.testing.expect(!isPath("pdf"));
}
- test "legacy PDF prefix is delimited by its stable marker and exact path" {
- const path = "/tmp/a document.pdf";
- const tag = "pdf 2/9 height PdfFit full PdfTint PdfSections " ++ path ++ " Keep Del";
- try std.testing.expectEqualStrings(
- "pdf 2/9 height PdfFit full PdfTint PdfSections " ++ path,
- legacySavedPrefix(path, tag).?,
- );
- }
-
test "feature-off PDF state is zero-sized" {
if (!enabled) try std.testing.expectEqual(@as(usize, 0), @sizeOf(State));
}
- test "compact PDF saved prefix separates page status from editable commands" {
- const path = "/tmp/a document.pdf";
- try std.testing.expectEqualStrings(path ++ " [2/9]", legacySavedPrefix(path, path ++ " [2/9] Keep Del").?);
- try std.testing.expect(legacySavedPrefix(path, path ++ " [oops] Keep Del") == null);
- try std.testing.expect(legacySavedPrefix(path, path ++ " [2/9/4] Keep Del") == null);
- }
-
test "PDF section rows preserve DFS ordinals and sanitise hierarchy" {
if (!enabled) return;
const entries = [_]pdf.OutlineEntry{
@@ -2803,7 +3429,9 @@ const PdfTests = struct {
test "PDF word probe owns quads and text without a selection object" {
if (comptime !enabled) return;
- var document = try Document.open("docs/design.pdf");
+ const bytes = try std.Io.Dir.cwd().readFileAlloc(std.testing.io, "docs/design.pdf", std.testing.allocator, .unlimited);
+ defer std.testing.allocator.free(bytes);
+ var document = try Document.openBytes(bytes);
defer document.deinit();
var found = try document.search(std.testing.allocator, 0, "Pardes");
defer found.deinit(std.testing.allocator);
@@ -2821,7 +3449,7 @@ const PdfTests = struct {
defer probe.deinit(std.testing.allocator);
try std.testing.expectEqual(@as(usize, 0), probe.page);
try std.testing.expect(probe.quads.len > 0);
- try std.testing.expect(std.ascii.indexOfIgnoreCase(probe.text, "Pardes") != null);
+ try std.testing.expect(std.ascii.findIgnoreCase(probe.text, "Pardes") != null);
}
test "PDF point mapping restores band origin and fractional placement" {
@@ -2850,11 +3478,11 @@ const TerminalTests = struct {
// Tests asserting raw ANSI indices explicitly select helix, whose palette
// is inherited. Native-palette coverage lives in the overlay/eviction and
// trailing-blank tests and checks their concrete RGB values instead.
- const gridOffset = panes.Terminal.gridOffset;
- const scrollGrid = panes.Terminal.scrollGrid;
- const promptInputReady = panes.Terminal.promptInputReady;
- const forwardKey = panes.Terminal.forwardKey;
- const enterTty = panes.Terminal.enterTty;
+ const gridOffset = panes.terminal.gridOffset;
+ const scrollGrid = panes.terminal.scrollGrid;
+ const promptInputReady = panes.terminal.promptInputReady;
+ const forwardKey = panes.terminal.forwardKey;
+ const enterTty = panes.terminal.enterTty;
// Align normal-mode glyphs with the VT grid and compare their styles.
fn modeStyleDiffs(p: *Pardes, pane: *Pane, gpa: std.mem.Allocator, note: []const u8) !usize {
@@ -2862,8 +3490,8 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
- const rows: usize = r.h - pardes.BOX_H;
+ const body_y = bodyY(p, r);
+ const rows: usize = bodyH(p, r);
const cols: usize = r.w -| config.GUTTER;
const Snap = struct { text: [][7]u8, len: []u8, style: []pardes.CellStyle };
@@ -2884,8 +3512,8 @@ const TerminalTests = struct {
gpa.free(sn.style);
};
- for ([_]pardes.Pane.Mode{ .tty, .normal }, 0..) |mode, i| {
- pane.mode = mode;
+ for ([_]panes.Text.Mode{ .tty, .normal }, 0..) |mode, i| {
+ pane.body.mode = mode;
p.shell_rows.stale = true;
_ = frame.reset(.retain_capacity);
const s = try p.render(frame.allocator());
@@ -2978,14 +3606,14 @@ const TerminalTests = struct {
.write => return error.GreetedBeforePrompt,
else => {},
};
- p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;A\x07prompt$ " } });
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;A;aid=pardes\x07prompt$ " } });
try std.testing.expect(!promptInputReady(pane));
while (p.nextEffect()) |effect| switch (effect) {
.write => return error.GreetedDuringPrompt,
else => {},
};
- p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;B\x07" } });
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;B;aid=pardes\x07" } });
try std.testing.expect(promptInputReady(pane));
var greeted = false;
while (p.nextEffect()) |effect| switch (effect) {
@@ -2996,14 +3624,38 @@ const TerminalTests = struct {
try std.testing.expect(!pane.greet);
}
+ test "the greeting is dropped, never typed later, once something ran or was typed first" {
+ if (pardes.platform == .web) return;
+ for ([_][]const u8{
+ // A command ran before the first prompt was seen at rest.
+ "\x1b]133;A;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07\x1b]133;C;aid=pardes\x07out\r\n\x1b]133;D;0;aid=pardes\x07\x1b]133;A;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07",
+ // Someone typed at the first prompt.
+ "\x1b]133;A;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07vim",
+ }) |output| {
+ const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ while (p.nextEffect()) |_| {}
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24 } });
+ p.update(.{ .output = .{ .pane = 0, .bytes = output } });
+ // and a later, quiet prompt changes nothing
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\r\n\x1b]133;A;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07" } });
+ while (p.nextEffect()) |effect| switch (effect) {
+ .write => |write| if (std.mem.eql(u8, write.bytes.slice(), "ls\r")) return error.GreetedLate,
+ else => {},
+ };
+ try std.testing.expect(!pane.greet);
+ }
+ }
+
test "fresh-shell commands preserve order and wait for OSC 133 B" {
if (pardes.platform == .web) return;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
while (p.nextEffect()) |_| {} // the host has not acknowledged spawn yet
- try std.testing.expectEqual(@as(?usize, 0), p.execute(0, "echo first"));
- try std.testing.expectEqual(@as(?usize, 0), p.execute(0, "echo second"));
+ try std.testing.expectEqual(@as(?usize, 0), pardes.exec.execute(p, 0, "echo first"));
+ try std.testing.expectEqual(@as(?usize, 0), pardes.exec.execute(p, 0, "echo second"));
while (p.nextEffect()) |effect| switch (effect) {
.write => return error.CommandEscapedBeforeFork,
else => {},
@@ -3095,7 +3747,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[31mAAA\x1b[0m\r\n\x1b[32mBBB\x1b[0m\r\n\x1b[34mCCC\x1b[0m" } });
@@ -3103,7 +3755,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const red: pardes.Color = .{ .index = 1 };
const green: pardes.Color = .{ .index = 2 };
const blue: pardes.Color = .{ .index = 4 };
@@ -3145,7 +3797,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
// A ONE-cell prompt carrying a combining mark — an NFD `e` — then `ABC`
// typed at it. The cell walk that finds the prompt's end must step ONE
@@ -3158,7 +3810,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
p.shell_rows.stale = true;
const s = try p.render(frame.allocator());
@@ -3181,7 +3833,7 @@ const TerminalTests = struct {
// Raw palette, so a leaked background reads back as `.index` — the theme
// filter would repaint every blank cell and hide the evidence.
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
// Sixty rows, each a distinct background, so a leaked colour names the row
// it leaked from.
@@ -3206,8 +3858,8 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
- const body_h = r.h - pardes.BOX_H;
+ const body_y = bodyY(p, r);
+ const body_h = bodyH(p, r);
p.shell_rows.stale = true;
const s = try p.render(frame.allocator());
@@ -3237,7 +3889,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[31mAAA\x1b[0m\r\n\x1b[32mBBB\x1b[0m\r\n\x1b[34mCCC\x1b[0m" } });
@@ -3245,7 +3897,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const red: pardes.Color = .{ .index = 1 };
const green: pardes.Color = .{ .index = 2 };
const blue: pardes.Color = .{ .index = 4 };
@@ -3274,7 +3926,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[31mAAA\x1b[0m\r\n\x1b[32mBBB\x1b[0m\r\n\x1b[34mCCC\x1b[0m" } });
@@ -3282,7 +3934,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const red: pardes.Color = .{ .index = 1 };
// Covers far more rows than the grid was ever dumped for, so the anchor
@@ -3350,7 +4002,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = filter;
- pane.mode = .normal;
+ pane.body.mode = .normal;
var buf: [256]u8 = undefined;
const bytes = try std.fmt.bufPrint(
@@ -3364,7 +4016,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
p.shell_rows.stale = true;
const s = try p.render(frame.allocator());
@@ -3430,7 +4082,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .tty;
+ pane.body.mode = .tty;
for (0..60) |i| {
var buf: [40]u8 = undefined;
@@ -3442,8 +4094,8 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
- const rows: usize = r.h - pardes.BOX_H;
+ const body_y = bodyY(p, r);
+ const rows: usize = bodyH(p, r);
const cols: usize = r.w -| config.GUTTER;
// What tty mode shows with nothing left behind: the reference.
@@ -3489,20 +4141,22 @@ const TerminalTests = struct {
// ABSOLUTE assertions: both modes were wrong identically here, so a
// tty/normal differential says nothing.
for ([_]bool{ false, true }) |filter| {
- for ([_]pardes.Pane.Mode{ .tty, .normal }) |mode| {
+ for ([_]panes.Text.Mode{ .tty, .normal }) |mode| {
const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 12, .rows = 8 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
+ pane.tag_expanded = false; // a one-row tag keeps this small screen's rows
+ p.sync();
pane.tty_filter = filter;
- pane.mode = mode;
+ pane.body.mode = mode;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[32m\u{754C}\x1b[41m\x1b[K\x1b[7G\x1b[44m\x1b[K\r\n" } });
var frame = std.heap.ArenaAllocator.init(testing.allocator);
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
p.shell_rows.stale = true;
const s = try p.render(frame.allocator());
@@ -3525,20 +4179,20 @@ const TerminalTests = struct {
// ghostty leaves a `spacer_head` in that last column, carrying the row's
// background, and wraps the glyph to the next row. A head OWNS its column,
// so skipping it the way a tail is skipped left the row's final column bare.
- for ([_]pardes.Pane.Mode{ .tty, .normal }) |mode| {
+ for ([_]panes.Text.Mode{ .tty, .normal }) |mode| {
const p = try Pardes.init(testing.allocator, .{ .startup_config = "Theme helix\n", .tty_only = true, .cols = 16, .rows = 8 });
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = mode;
+ pane.body.mode = mode;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[41mzzzzzzzzzzzzz\u{754C}\x1b[0m\r\n" } });
var frame = std.heap.ArenaAllocator.init(testing.allocator);
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
p.shell_rows.stale = true;
const s = try p.render(frame.allocator());
@@ -3558,7 +4212,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .tty;
+ pane.body.mode = .tty;
for (0..40) |i| {
var buf: [64]u8 = undefined;
const bytes = std.fmt.bufPrint(&buf, "\x1b[38;5;{d}mline-{d:0>2}\x1b[0m\r\n", .{ 20 + i, i }) catch unreachable;
@@ -3571,10 +4225,10 @@ const TerminalTests = struct {
const s = try p.render(frame.allocator());
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
var bad: usize = 0;
- for (0..r.h -| pardes.BOX_H) |vr| {
+ for (0..bodyH(p, r)) |vr| {
var buf: [16]u8 = undefined;
var n: usize = 0;
for (0..10) |c| {
@@ -3608,13 +4262,13 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = filter;
- pane.mode = .normal;
+ pane.body.mode = .normal;
var frame = std.heap.ArenaAllocator.init(testing.allocator);
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
p.update(.{ .output = .{ .pane = 0, .bytes = "plain text\r\n" } });
p.shell_rows.stale = true;
@@ -3640,7 +4294,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
for (0..6) |i| {
var buf: [40]u8 = undefined;
@@ -3652,7 +4306,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
// The state two ordinary edits reach: one at the bottom, one that split a
// line further up. The buffer now spans rows 2..6 and diverges at BOTH
@@ -3682,7 +4336,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[31m000\x1b[0m\r\n\x1b[32m111\x1b[0m\r\n\r\n\x1b[34m333\x1b[0m\r\n\x1b[35m444\x1b[0m" } });
@@ -3690,7 +4344,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
// The state three keystrokes reach on any blank shell row: type a character
// and delete it, and the buffer holds NO text while still standing in for
@@ -3715,8 +4369,10 @@ const TerminalTests = struct {
defer p.deinit();
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
+ pane.tag_expanded = false; // a one-row tag keeps this small screen's rows
+ p.sync();
pane.tty_filter = false;
- pane.mode = .tty;
+ pane.body.mode = .tty;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[31mAAA\x1b[0m\r\n\x1b[32mBBB\x1b[0m\r\n\x1b[34mCCC\x1b[0m" } });
@@ -3724,7 +4380,7 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const blue: pardes.Color = .{ .index = 4 };
p.shell_rows.stale = true;
@@ -3753,7 +4409,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
for (0..6) |i| {
var buf: [64]u8 = undefined;
const bytes = std.fmt.bufPrint(&buf, "\x1b[38;5;{d}mrow-{d}-abcdefgh\x1b[0m\r\n", .{ 30 + i, i }) catch unreachable;
@@ -3767,12 +4423,12 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const s = try p.render(frame.allocator());
const want = pardes.Color{ .index = 33 };
var seen = false;
- for (0..@as(usize, r.h -| pardes.BOX_H)) |vr| {
+ for (0..@as(usize, bodyH(p, r))) |vr| {
var buf: [15]u8 = undefined;
for (0..15) |c| {
const g = s.at(tx + @as(u16, @intCast(c)), body_y + @as(u16, @intCast(vr))).grapheme();
@@ -3803,7 +4459,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
for (0..26) |i| {
var buf: [64]u8 = undefined;
const bytes = std.fmt.bufPrint(&buf, "\x1b[38;5;{d}mrow-{d:0>2}-xyzzy\x1b[0m\r\n", .{ 20 + i, i }) catch unreachable;
@@ -3820,11 +4476,11 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const s = try p.render(frame.allocator());
var seen = false;
- for (0..@as(usize, r.h -| pardes.BOX_H)) |vr| {
+ for (0..@as(usize, bodyH(p, r))) |vr| {
var buf: [12]u8 = undefined;
for (0..12) |c| {
const g = s.at(tx + @as(u16, @intCast(c)), body_y + @as(u16, @intCast(vr))).grapheme();
@@ -3862,7 +4518,7 @@ const TerminalTests = struct {
// The raw palette, so a row's text names its exact colour instead of one
// this test would have to re-derive from the theme.
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
for (0..26) |i| {
var buf: [64]u8 = undefined;
const bytes = std.fmt.bufPrint(&buf, "\x1b[38;5;{d}mrow-{d:0>2}-xyzzy\x1b[0m\r\n", .{ 20 + i, i }) catch unreachable;
@@ -3874,8 +4530,8 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
- const body_h = r.h -| pardes.BOX_H;
+ const body_y = bodyY(p, r);
+ const body_h = bodyH(p, r);
var step: usize = 0;
while (step < 12) : (step += 1) {
@@ -3950,7 +4606,7 @@ const TerminalTests = struct {
while (p.nextEffect()) |_| {}
const pane = p.panes[0].?;
pane.tty_filter = false;
- pane.mode = .normal;
+ pane.body.mode = .normal;
for (0..26) |i| {
var buf: [64]u8 = undefined;
const bytes = std.fmt.bufPrint(&buf, "\x1b[38;5;{d}mrow-{d:0>2}-xyzzy\x1b[0m\r\n", .{ 20 + i, i }) catch unreachable;
@@ -3969,11 +4625,11 @@ const TerminalTests = struct {
defer frame.deinit();
const r = p.rects[0];
const tx = r.x + config.GUTTER;
- const body_y = if (p.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = bodyY(p, r);
const s = try p.render(frame.allocator());
var seen: usize = 0;
- for (0..@as(usize, r.h -| pardes.BOX_H)) |vr| {
+ for (0..@as(usize, bodyH(p, r))) |vr| {
var buf: [12]u8 = undefined;
for (0..12) |c| {
const g = s.at(tx + @as(u16, @intCast(c)), body_y + @as(u16, @intCast(vr))).grapheme();
@@ -3997,6 +4653,7 @@ test {
_ = TagNameTintTests;
_ = TreeContextTests;
_ = BodyHitTests;
+ _ = LineNumberLookTests;
_ = TtySelectionTests;
_ = ClickCursorTests;
_ = JumpSelectionTests;
@@ -4018,11 +4675,11 @@ test "an empty counted paste leaves no count for the next motion" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
defer p.deinit();
const pane = try p.setTestFile("abcdefgh\n");
- if (empty_register) p.yank = try p.gpa.dupe(u8, "");
+ if (empty_register) p.registers.put(p.gpa, '"', "", 0, 1, true);
for ("3p") |cp| p.update(.{ .key = .{ .cp = cp } });
- try std.testing.expectEqual(modal.Normal.State{}, pane.normal);
+ try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
p.update(.{ .key = .{ .cp = 'l' } });
- try std.testing.expectEqual(@as(i32, 1), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
try std.testing.expectEqualStrings("abcdefgh\n", pane.file.?.content);
}
}
@@ -4046,39 +4703,45 @@ test "cancelled normal gestures leave no count or subprefix after mouse and focu
defer frame.deinit();
_ = try p.render(frame.allocator());
for (keys) |cp| p.update(.{ .key = .{ .cp = cp } });
- try std.testing.expect(!std.meta.eql(modal.Normal.State{}, pane.normal));
+ try std.testing.expect(!std.meta.eql(modal.Normal.State{}, pane.body.normal));
switch (gesture) {
.body, .tag => {
const rect = p.rects[0];
- const tag_y = if (p.settings.tag_bottom) rect.y + rect.h - pardes.BOX_H else rect.y;
- const body_y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
- const x = rect.x + config.GUTTER + @as(u16, @intCast(panes.File.gutterWidth(pane))) + 3;
+ const tag_y = tagY(p, rect);
+ const body_y = p.bodyTop(pane, rect);
+ const x = if (gesture == .tag)
+ rect.x + pardes.TAG_TEXT_INSET + @as(u16, @intCast(panes.File.displayWidth(try pardes.tagline.tagPrefix(p, pane)))) + 3
+ else
+ rect.x + config.GUTTER + @as(u16, @intCast(panes.File.gutterWidth(pane))) + 3;
const y = if (gesture == .tag) tag_y else body_y;
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = x, .row = y } });
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = x, .row = y } });
if (gesture == .tag) {
- try std.testing.expect(pane.tag_edit);
+ try std.testing.expect(pane.focus == .tag);
p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(!pane.tag_edit);
+ p.update(.{ .key = .{ .cp = ':' } });
+ try std.testing.expect(pane.focus == .body);
}
},
.focus, .last => {
p.update(.{ .key = .{ .cp = 'w', .ctrl = true } });
p.update(.{ .key = .{ .cp = 'l' } });
+ p.update(.{ .key = .{ .cp = Key.enter } });
try std.testing.expectEqual(other, p.active);
if (gesture == .last) {
p.update(.{ .key = .{ .cp = Key.escape } });
} else {
p.update(.{ .key = .{ .cp = 'w', .ctrl = true } });
p.update(.{ .key = .{ .cp = 'h' } });
+ p.update(.{ .key = .{ .cp = Key.enter } });
}
try std.testing.expectEqual(@as(usize, 0), p.active);
},
}
- try std.testing.expectEqual(modal.Normal.State{}, pane.normal);
- const col = pane.cur_col;
+ try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
+ const col = pane.body.cur_col;
p.update(.{ .key = .{ .cp = 'l' } });
- try std.testing.expectEqual(col + 1, pane.cur_col);
+ try std.testing.expectEqual(col + 1, pane.body.cur_col);
try std.testing.expectEqualStrings("abcdefghij\n", pane.file.?.content);
}
}
@@ -4089,16 +4752,16 @@ test "cancelled normal gestures leave no count or subprefix through raw tty mode
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 12 });
defer p.deinit();
const pane = p.panes[0].?;
- pane.mode = .normal;
+ pane.body.mode = .normal;
p.update(.{ .output = .{ .pane = 0, .bytes = "abcdefghij\r\n" } });
for (keys) |cp| p.update(.{ .key = .{ .cp = cp } });
- try std.testing.expect(!std.meta.eql(modal.Normal.State{}, pane.normal));
+ try std.testing.expect(!std.meta.eql(modal.Normal.State{}, pane.body.normal));
p.update(.{ .key = .{ .cp = p.opts.tty_toggle, .ctrl = true } });
- try std.testing.expectEqual(pardes.Pane.Mode.tty, pane.mode);
- try std.testing.expectEqual(modal.Normal.State{}, pane.normal);
+ try std.testing.expectEqual(panes.Text.Mode.tty, pane.body.mode);
+ try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
p.update(.{ .key = .{ .cp = p.opts.tty_toggle, .ctrl = true } });
- try std.testing.expectEqual(pardes.Pane.Mode.normal, pane.mode);
- try std.testing.expectEqual(modal.Normal.State{}, pane.normal);
+ try std.testing.expectEqual(panes.Text.Mode.normal, pane.body.mode);
+ try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
}
}
@@ -4159,7 +4822,7 @@ test "growing a file pane colors every newly visible Zig keyword" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 8 });
defer p.deinit();
- const pane = try p.setTestFile("pub fn f() void { if (true) {} }\n" ** 100);
+ const pane = try p.setTestFile(std.mem.asBytes(&@as([100][33]u8, @splat("pub fn f() void { if (true) {} }\n".*))));
const file = &pane.file.?;
gpa.free(file.path);
file.path = try gpa.dupe(u8, "/resize.zig");
@@ -4176,9 +4839,9 @@ test "growing a file pane colors every newly visible Zig keyword" {
_ = frame.reset(.retain_capacity);
const surface = try p.render(frame.allocator());
const rect = p.rects[0];
- const body_y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const body_y = bodyY(p, rect);
var seen: usize = 0;
- for (body_y..body_y + rect.h - pardes.BOX_H) |y| {
+ for (body_y..body_y + bodyH(p, rect)) |y| {
for (rect.x + config.GUTTER..rect.x + rect.w - 1) |x| {
const first = surface.at(@intCast(x), @intCast(y));
const second = surface.at(@intCast(x + 1), @intCast(y));
@@ -4219,12 +4882,14 @@ test "Zig keywords keep every rendered byte colored across line-number widths" {
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = view.cols, .rows = 10 });
defer p.deinit();
const pane = try p.setTestFile(source);
+ pane.tag_expanded = false; // a one-row tag keeps this small screen's rows
+ p.sync();
const file = &pane.file.?;
gpa.free(file.path);
file.path = try gpa.dupe(u8, "/highlight.zig");
file.scroll = line - 1;
- pane.cur_row = @intCast(line - 1);
- pane.cur_col = @intCast(std.mem.indexOf(u8, sample, "fn").?);
+ pane.body.cur_row = @intCast(line - 1);
+ pane.body.cur_col = @intCast(std.mem.indexOf(u8, sample, "fn").?);
pane.hscroll = view.horizontal;
p.settings.colors = true;
p.settings.wrap = view.wrap;
@@ -4235,8 +4900,8 @@ test "Zig keywords keep every rendered byte colored across line-number widths" {
var seen: usize = 0;
var if_position: ?struct { x: u16, y: u16 } = null;
const rect = p.rects[0];
- const body_y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
- for (body_y..body_y + rect.h - pardes.BOX_H) |y| {
+ const body_y = bodyY(p, rect);
+ for (body_y..body_y + bodyH(p, rect)) |y| {
for (rect.x + config.GUTTER..rect.x + rect.w - 1) |x| {
const first = surface.at(@intCast(x), @intCast(y));
const second = surface.at(@intCast(x + 1), @intCast(y));
@@ -4263,15 +4928,15 @@ test "Zig keywords keep every rendered byte colored across line-number widths" {
const clicked = if_position.?;
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = clicked.x, .row = clicked.y } });
p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = clicked.x, .row = clicked.y } });
- try std.testing.expectEqual(@as(i32, @intCast(line - 1)), pane.cur_row);
- try std.testing.expectEqual(@as(i32, @intCast(std.mem.indexOf(u8, sample, "if").?)), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, @intCast(line - 1)), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, @intCast(std.mem.indexOf(u8, sample, "if").?)), pane.body.cur_col);
}
}
}
}
test "terminal overlays preserve trailing blank styles without coloring inserted rows" {
- if (comptime !panes.Terminal.enabled) return error.SkipZigTest;
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 });
defer p.deinit();
@@ -4279,13 +4944,13 @@ test "terminal overlays preserve trailing blank styles without coloring inserted
const pane = p.panes[0].?;
pane.tty_filter = false;
p.update(.{ .output = .{ .pane = 0, .bytes = "A\r\n\x1b[41m\x1b[2K\r\n\x1b[42m\x1b[2K\r\n\x1b[44m\x1b[2K\x1b[0m" } });
- pane.mode = .normal;
+ pane.body.mode = .normal;
pane.ovl = .{ .row = 0, .rows = 3, .text = try gpa.dupe(u8, "A\n\n") };
var frame = std.heap.ArenaAllocator.init(gpa);
defer frame.deinit();
const rect = p.rects[0];
const x = rect.x + config.GUTTER;
- const y = if (p.settings.tag_bottom) rect.y else rect.y + pardes.BOX_H;
+ const y = bodyY(p, rect);
const palette = p.theme().palette.?;
const colors = [_]pardes.Color{ .{ .rgb = palette[1] }, .{ .rgb = palette[2] }, .{ .rgb = palette[4] } };
const original = try p.render(frame.allocator());
@@ -4311,16 +4976,17 @@ test "terminal overlays preserve trailing blank styles without coloring inserted
const LookResetTests = struct {
fn seed(pane: *Pane, operand: []const u8) !void {
- pane.cur_row = 0;
- pane.cur_col = 3;
- pane.vsel = .{ .active = true, .explicit = true, .row = 0, .col = 0 };
- pane.msel = .{ .active = true, .r0 = 0, .r1 = 1 };
- pane.sels[0] = .{ .row = 1, .col = 2, .arow = 0, .acol = 1 };
- pane.nsel = 1;
- pane.select = true;
- pane.normal.count = 5;
- pane.append_at = .{ .row = 0, .col = 3 };
- pane.sticky_col = 7;
+ pane.body.cur_row = 0;
+ pane.body.cur_col = 3;
+ pane.body.vsel = .{ .active = true, .explicit = true, .row = 0, .col = 0 };
+ pane.body.msel = .{ .active = true, .r0 = 0, .r1 = 1 };
+ _ = pane.body.reserveSels();
+ pane.body.sels[0] = .{ .row = 1, .col = 2, .arow = 0, .acol = 1 };
+ pane.body.nsel = 1;
+ pane.body.select = true;
+ pane.body.normal.count = 5;
+ pane.body.restore_cursor = true;
+ pane.body.sticky_col = 7;
for (0..pane.sel.len) |slot| {
pane.clearPointerSelection(slot);
pane.sel[slot] = .{ .state = .done, .source_id = slot + 1, .r0 = 1, .r1 = 1, .c0 = 0, .c1 = 3 };
@@ -4335,21 +5001,21 @@ const LookResetTests = struct {
}
fn cleared(pane: *const Pane) !void {
- try std.testing.expect(!pane.msel.active);
- try std.testing.expectEqual(@as(u8, 0), pane.nsel);
- try std.testing.expect(!pane.select);
- try std.testing.expectEqual(modal.Normal.State{}, pane.normal);
- try std.testing.expect(pane.append_at == null);
- try std.testing.expectEqual(@as(i32, -1), pane.sticky_col);
+ try std.testing.expect(!pane.body.msel.active);
+ try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
+ try std.testing.expect(!pane.body.select);
+ try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
+ try std.testing.expect(!pane.body.restore_cursor);
+ try std.testing.expectEqual(@as(i32, -1), pane.body.sticky_col);
for (pane.sel) |selection| try std.testing.expectEqual(.none, selection.state);
for (pane.pointer_selections) |selection| try std.testing.expect(selection == null);
}
fn selected(pane: *const Pane) []const u8 {
- if (!pane.vsel.active or pane.cur_row != pane.vsel.row) return "";
- const line = modal.lineSlice(pane.file.?.content, @intCast(pane.cur_row));
- const lo: usize = @intCast(@min(pane.cur_col, pane.vsel.col));
- const hi: usize = @intCast(@max(pane.cur_col, pane.vsel.col));
+ if (!pane.body.vsel.active or pane.body.cur_row != pane.body.vsel.row) return "";
+ const line = modal.lineSlice(pane.file.?.content, @intCast(pane.body.cur_row));
+ const lo: usize = @intCast(@min(pane.body.cur_col, pane.body.vsel.col));
+ const hi: usize = @intCast(@max(pane.body.cur_col, pane.body.vsel.col));
return line[lo..modal.nextGrapheme(line, hi)];
}
@@ -4359,29 +5025,29 @@ const LookResetTests = struct {
const pane = try p.setTestFile("alpha\nbravo\ncharlie\nneedle\n");
try seed(pane, "/test.txt:3:2");
// This operand is released by Look's selection cleanup.
- p.lookAt(0, pane.pointer_selections[0].?.raw_text.?);
+ pardes.look.lookAt(p, 0, pane.pointer_selections[0].?.raw_text.?);
try cleared(pane);
try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(@as(i32, 2), pane.cur_row);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_col);
- try std.testing.expect(!pane.vsel.active);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
+ try std.testing.expect(!pane.body.vsel.active);
try seed(pane, "/test.txt:2:2-4");
- p.lookAt(0, pane.pointer_selections[0].?.raw_text.?);
+ pardes.look.lookAt(p, 0, pane.pointer_selections[0].?.raw_text.?);
try cleared(pane);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
try std.testing.expectEqualStrings("rav", selected(pane));
p.gpa.free(pane.file.?.path);
pane.file.?.path = try p.gpa.dupe(u8, "/tmp/look-selection-source.txt");
try seed(pane, "needle");
- p.lookAt(0, pane.pointer_selections[0].?.raw_text.?);
+ pardes.look.lookAt(p, 0, pane.pointer_selections[0].?.raw_text.?);
try cleared(pane);
- try std.testing.expectEqual(@as(i32, 3), pane.cur_row);
+ try std.testing.expectEqual(@as(i32, 3), pane.body.cur_row);
try std.testing.expectEqualStrings("needle", selected(pane));
}
- test "Look clears both source and existing destination selections before focus" {
+ test "Look clears the source's click highlight, not its dot, and the destination's selections before focus" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 30 });
defer p.deinit();
const source = try p.setTestFile("source\nlines\n");
@@ -4398,18 +5064,21 @@ const LookResetTests = struct {
p.active = 0;
try seed(source, if (range) "/look-destination.txt:2:2-4" else "/look-destination.txt:3:2");
try seed(destination, "previous destination");
- p.lookAt(0, source.pointer_selections[0].?.raw_text.?);
+ pardes.look.lookAt(p, 0, source.pointer_selections[0].?.raw_text.?);
try std.testing.expectEqual(id, p.active);
- try cleared(source);
+ // The source keeps its dot (acme's look leaves it); the click's
+ // highlight goes.
+ for (source.sel) |selection| try std.testing.expectEqual(.none, selection.state);
+ for (source.pointer_selections) |selection| try std.testing.expect(selection == null);
+ try std.testing.expect(source.body.vsel.active);
try cleared(destination);
- try std.testing.expect(!source.vsel.active);
if (range) {
- try std.testing.expectEqual(@as(i32, 1), destination.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), destination.body.cur_row);
try std.testing.expectEqualStrings("rav", selected(destination));
} else {
- try std.testing.expectEqual(@as(i32, 2), destination.cur_row);
- try std.testing.expectEqual(@as(i32, 1), destination.cur_col);
- try std.testing.expect(!destination.vsel.active);
+ try std.testing.expectEqual(@as(i32, 2), destination.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 1), destination.body.cur_col);
+ try std.testing.expect(!destination.body.vsel.active);
}
}
}
@@ -4418,3 +5087,47 @@ const LookResetTests = struct {
test {
_ = LookResetTests;
}
+
+test "a terminal keeps its tag and two body rows through a squeeze, a drag and a smaller window; a text pane does not" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 30 });
+ defer p.deinit();
+ p.presentation.enabled = false;
+ p.sync();
+ while (p.nextEffect()) |_| {}
+ const term = for (p.panes, 0..) |slot, i| {
+ if (slot) |pane| if (pane.isTerminal()) break i;
+ } else return error.NoTerminal;
+ p.newScratchBelow(term);
+ p.sync();
+ while (p.nextEffect()) |_| {}
+ const col = layout.findPane(p, term).?.col;
+ const floor = p.panes[term].?.tag_rows + layout.min_body_rows;
+ // Squeezed by the weights: the others give it its floor.
+ p.panes[term].?.vweight = 0.01;
+ for (p.col_panes[col][0..p.col_n[col]]) |k| if (k != term) {
+ p.panes[k].?.vweight = 1000;
+ };
+ p.sync();
+ try std.testing.expectEqual(floor, p.rects[term].h);
+ var rows: ?u16 = null;
+ while (p.nextEffect()) |effect| if (effect == .resize_pty and effect.resize_pty.pane == term) {
+ rows = effect.resize_pty.rows;
+ };
+ try std.testing.expectEqual(@as(?u16, layout.min_body_rows), rows);
+ // A drag of the grip under it up to its tag stops at the floor; one
+ // the other way takes a text pane down to its tag alone.
+ const k = layout.findPane(p, term).?.idx;
+ if (k + 1 < p.col_n[col]) {
+ layout.applyRowSplit(p, col, k, p.rects[term].y);
+ p.sync();
+ try std.testing.expectEqual(floor, p.rects[term].h);
+ const text = p.col_panes[col][k + 1];
+ layout.applyRowSplit(p, col, k, p.screen_h);
+ p.sync();
+ try std.testing.expect(p.rects[text].h <= p.panes[text].?.tag_rows);
+ }
+ // A window too short for all: the terminal keeps its floor still.
+ p.update(.{ .resize = .{ .cols = 100, .rows = 10 } });
+ p.sync();
+ try std.testing.expect(p.rects[term].h >= p.panes[term].?.tag_rows + layout.min_body_rows);
+}