summaryrefslogtreecommitdiff
path: root/src/panes.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-05 19:44:08 -0300
committerGabriel Schneider <[email protected]>2026-11-05 22:03:21 -0300
commit1a1ce29051ea6aa3be4754074f6a00b905d6b208 (patch)
tree7f432c87aba2a4c21c5bf8eeeee1d873c2247adb /src/panes.zig
parent69e809f64a30b09d9bd5ab56a3a80e94fc3f99c3 (diff)
downloadpardes-1a1ce29051ea6aa3be4754074f6a00b905d6b208.tar.gz
pardes-1a1ce29051ea6aa3be4754074f6a00b905d6b208.zip
split pardes.zig by noun, panes: the session's pane slots move into src/panes.zig, beside the Pane they hold: making a pane (installPane, newShell, emitSpawn, newCommand, newDocPane, the scratches, openTutorView and its tutor text, setTestFile), finding one (freeSlot, paneBySerial, paneIdOf, anyPane, neighbourPane, standIn, paneDir), closing one (removePane, retirePane, teardownPane, reapPanes, deinitPane, detachCwds) and a pane's prompt (startPrompt, promptTarget); the session keeps ten as declaration aliases, the eight called from everywhere (freeSlot, paneBySerial, setTestFile, newShell, newDocPane, newScratchBelow, removePane, paneDir) and the two dump.zig calls (emitSpawn, installPane), so the persistence agent's file is untouched; the rest are panes.x(p, ...) in their callers (21 files, test/panes.zig and test/pdf.zig through pardes.panes); helpers they reach in the session are pub (noteClosed, besideColumn, parkPendingWrite, dropPendingWrite, RetiredPanes.retire); tests moved with them, by name: owned cwd preserves long paths aliases and failed updates; owned cwd close copies are transactional across inherited chains; owned cwd column close allocates every copy before removing any pane; owned cwd EOF failure retains the pane and Del retries its close; owned cwd restore either copies the directory or preserves the old core; owned cwd Save promotion releases the former directory; the Tutor pane is named +Tutor in the session's directory, never a bare path at the root; New opens an empty scratch below the caller, inheriting its directory; a prompt chip is a band with its caret, still on the grid, and only the chip swallows a click; a prompt is typed on its own line in the notice band and leaves the tag row alone; a pure move, no field touched, a dump and the wire as they were; gates: tui core-test 960/960, behaviour-test 238/238, pane-test 171/172 (1 skipped), gui unit-test 1518/1519 (1 skipped)
Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/panes.zig')
-rw-r--r--src/panes.zig769
1 files changed, 768 insertions, 1 deletions
diff --git a/src/panes.zig b/src/panes.zig
index 73a0fc9e..8786de2b 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -3,7 +3,24 @@ const pardes = @import("pardes.zig");
const views = @import("views.zig");
const config = @import("config.zig");
const modal = @import("modal.zig");
-const limits = @import("memory.zig").limits;
+const limits = memory.limits;
+const panes = @This();
+const Pardes = pardes.Pardes;
+const exec = @import("exec.zig");
+const look = @import("look.zig");
+const layout = @import("layout.zig");
+const tagline = @import("tagline.zig");
+const tape = @import("tape.zig");
+const dump = @import("dump.zig");
+const memory = @import("memory.zig");
+const ctlfs = @import("ninep/tree.zig");
+const Pipe = @import("Pipe.zig");
+const Key = pardes.Key;
+const Cell = pardes.Cell;
+const BOX_H = pardes.BOX_H;
+const MAX_PANES = pardes.MAX_PANES;
+const effect_path_cap = pardes.effect_path_cap;
+const pdf_enabled = Pdf.enabled;
/// An owned editable buffer and the absolute surface row of its first line.
/// Files use row zero; terminal overlays may begin anywhere in scrollback.
@@ -722,3 +739,753 @@ test {
_ = Pdf;
_ = terminal;
}
+
+// ---- the session's pane slots: making, finding, closing and freeing panes, and their prompts ----
+
+const tutor_text = @embedFile("tutor.txt");
+
+pub fn detachCwds(p: *Pardes, parents: []const *Pane) !void {
+ var copies: [MAX_PANES]?[]u8 = @splat(null);
+ errdefer for (copies) |copy| if (copy) |bytes| p.gpa.free(bytes);
+ for (p.panes, 0..) |slot, id| {
+ const pane = slot orelse continue;
+ const source = switch (pane.cwd) {
+ .inherited => |parent| parent,
+ else => continue,
+ };
+ for (parents) |parent| if (source == parent) {
+ copies[id] = try p.gpa.dupe(u8, paneDir(source));
+ break;
+ };
+ }
+ for (copies, 0..) |copy, id| if (copy) |bytes| {
+ p.panes[id].?.cwd = .{ .owned = bytes };
+ };
+}
+
+// The slot closes now; allocation teardown waits one frame. Caller clears panes[id].
+pub fn deinitPane(p: *Pardes, pane: *Pane) !void {
+ try detachCwds(p, &.{pane});
+ retirePane(p, pane);
+}
+
+pub fn retirePane(p: *Pardes, pane: *Pane) void {
+ // Closed, a file is remembered with its dot: Recent and a jump back
+ // to it reopen it there.
+ p.noteClosed(pane);
+ panes.Output.dropUnsaved(p, pane);
+ // A query pane's places, in whatever panes it fed, go with it.
+ if (pane.query != null) panes.Query.release(p, pane);
+ if (pane.file) |*file| panes.File.leaveTwins(p, file);
+ const watched = (if (pane.file) |f| f.output == null else false) or pane.hasPdf();
+ for (p.panes, 0..) |slot, id| if (slot == pane) {
+ if (watched) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = false } });
+ if (pane.isTerminal()) p.emit(.{ .close_pty = .{ .pane = @intCast(id) } });
+ // Its pty's end and its emulator are the authority's: a replica's
+ // speculation that closes a terminal waits for it.
+ if (pane.terminal != null) tape.poison("close a terminal");
+ ctlfs.events.noteRetire(p, pane);
+ // ...and so do bytes still queued for the pty it no longer has.
+ p.dropPendingWrite(id);
+ };
+ if (look.lookHoverPane(p)) |h| if (h < p.panes.len and p.panes[h] == pane) look.cancelLookHover(p);
+ p.retired_panes.retire(pane);
+}
+
+// Retired panes keep their payloads until the following frame or core teardown.
+pub fn teardownPane(p: *Pardes, pane: *Pane) void {
+ if (look.lookHoverPane(p)) |hovered| {
+ if (hovered < p.panes.len and p.panes[hovered] == pane)
+ look.cancelLookHover(p);
+ }
+ p.shell_rows.dropPane(pane);
+ for (0..pane.pointer_selections.len) |slot| pane.clearPointerSelection(slot);
+ panes.terminal.deinitPendingCommand(pane);
+ if (pane.command) |line| p.gpa.free(line);
+ if (pane.shell) |bin| p.gpa.free(bin);
+ if (pane.image) |*iv| {
+ iv.deinit(p.image_gpa);
+ }
+ if (comptime pdf_enabled) if (pane.pdf) |pv| panes.Pdf.deinitPane(p, pane, pv);
+ if (pane.file) |*file| panes.File.deinit(p, pane, file);
+ if (pane.ovl) |o| p.gpa.free(o.text);
+ views.tornDown(p, pane);
+ pane.body.deinit(p.gpa);
+ pane.tag.deinit(p.gpa);
+ pane.input.deinit(p.gpa);
+ pane.jump.deinit(p.gpa);
+ pane.places.deinit(p.gpa);
+ if (pane.query) |q| {
+ q.deinit(p.gpa);
+ p.gpa.destroy(q);
+ pane.query = null;
+ }
+ panes.terminal.deinitEmulator(pane, p.gpa);
+ pane.clearCwd();
+ pane.fs.deinit(p.gpa);
+ p.gpa.destroy(pane);
+}
+
+pub fn reapPanes(p: *Pardes) void {
+ var reaped = false;
+ for (&p.retired_panes.previous) |*slot| if (slot.*) |pane| {
+ teardownPane(p, pane);
+ slot.* = null;
+ reaped = true;
+ };
+ if (reaped) memory.trim();
+ p.retired_panes.previous = p.retired_panes.current;
+ p.retired_panes.current = @splat(null);
+}
+
+pub fn installPane(p: *Pardes, id: usize, pane: *Pane) void {
+ std.debug.assert(p.panes[id] == null);
+ p.next_serial += 1;
+ pane.serial = p.next_serial;
+ p.rects[id] = .{};
+ p.panes[id] = pane;
+ views.installed(p, pane);
+ panes.terminal.adoptSettings(p, pane);
+ // /log hears of it once the update that made it ends, when it has
+ // its file, name and place (`ctlfs.events.announce`).
+ pane.fs.unannounced = true;
+}
+
+pub fn newShell(p: *Pardes, id: usize, cwd: []const u8) !*Pane {
+ std.debug.assert(p.panes[id] == null);
+ if (cwd.len > limits.host_path_cap) return error.PathTooLong;
+ const pane = try panes.terminal.create(p.gpa, p.screen_w, p.screen_h);
+ // Named by the directory it is started in from the first, so the
+ // shell saying it is there is no rename (`new N /` then `rename`);
+ // out of memory for it, the shell names it when it says.
+ if (cwd.len > 0) pane.setOwnedCwd(cwd) catch {};
+ panes.terminal.armShellSpawn(pane);
+ p.installPane(id, pane);
+ p.emitSpawn(id, pane.serial, cwd);
+ return pane;
+}
+
+/// A child for pane `id` in `cwd`: a directory up to PATH_MAX, the ones
+/// past the effect's inline buffer kept here for perform to give.
+pub fn emitSpawn(p: *Pardes, id: usize, serial: u32, cwd: []const u8) void {
+ // A new shell has not said anything yet (setCwd's guard), whatever
+ // the one it replaces said.
+ if (p.panes[id]) |pane| pane.shell_spoke = false;
+ if (p.spawn_dirs[id]) |old| p.gpa.free(old);
+ p.spawn_dirs[id] = null;
+ if (cwd.len > effect_path_cap) p.spawn_dirs[id] = p.gpa.dupe(u8, cwd) catch null;
+ p.emit(.{ .spawn = .{ .pane = @intCast(id), .serial = serial, .cwd = .from(if (cwd.len > effect_path_cap) "" else cwd) } });
+}
+
+/// A command pane: a terminal whose child is `$SHELL -c line` rather
+/// than an interactive shell, left showing its output and `exit N` when
+/// it is done (exec.zig runCommand).
+pub fn newCommand(p: *Pardes, id: usize, cwd: []const u8, line: []const u8) !*Pane {
+ std.debug.assert(p.panes[id] == null);
+ if (cwd.len > limits.host_path_cap) return error.PathTooLong;
+ const owned = try p.gpa.dupe(u8, line);
+ errdefer p.gpa.free(owned);
+ const pane = try panes.terminal.create(p.gpa, p.screen_w, p.screen_h);
+ pane.command = owned;
+ pane.command_pty = true;
+ pane.body.mode = .tty;
+ // Its directory is the one it was run for, and says which of the
+ // directory's commands reuse it; the child's own cd does not move it.
+ pane.setOwnedCwd(cwd) catch {};
+ p.installPane(id, pane);
+ p.emitSpawn(id, pane.serial, cwd);
+ return pane;
+}
+
+pub fn newDocPane(p: *Pardes, id: usize) !*Pane {
+ std.debug.assert(p.panes[id] == null);
+ const pane = try panes.terminal.createDoc(p.gpa, p.screen_w, p.screen_h);
+ p.installPane(id, pane);
+ return pane;
+}
+
+pub fn newScratch(p: *Pardes, from_id: usize, free: usize, kind: exec.NewPane) !*Pane {
+ // None asking (an empty window): the session's, as pane/new's is.
+ const src_or = p.panes[from_id];
+ const content = try p.gpa.dupe(u8, "");
+ errdefer p.gpa.free(content);
+ // A terminal that has not said where it is yet (the boot layout's)
+ // has no directory: the scratch is the session's, <cwd>/+New. So is
+ // 9P's pane/new, and a New from a column's or the workspace's tag:
+ // no pane asked for it, whichever last had the keyboard (acme's new
+ // window has acme's directory).
+ const src = if (kind != .fs and !p.exec_header) src_or else null;
+ const dir = if (src) |s| paneDir(s) else "";
+ const np = try panes.Output.open(p, free, if (dir.len == 0) p.sessionDir() else dir, .{ .cmd = .New }, "", content);
+ if (src) |s| np.cwd = .{ .inherited = s };
+ np.body.cur_pinned = true;
+ return np;
+}
+
+/// New: an empty scratch in `from_id`'s directory, placed as exec.placeNew
+/// places it.
+pub fn newScratchBelow(p: *Pardes, from_id: usize) void {
+ newScratchFor(p, from_id, .scratch);
+}
+
+/// A scratch for New (`.scratch`) or 9P's pane/new (`.fs`).
+pub fn newScratchFor(p: *Pardes, from_id: usize, kind: exec.NewPane) void {
+ const free = p.freeSlot() orelse return p.reportError(from_id, "New", error.NoPaneSlots);
+ _ = newScratch(p, from_id, free, kind) catch return;
+ exec.placeNew(p, from_id, from_id, free, kind);
+}
+
+pub fn freeSlot(p: *Pardes) ?usize {
+ return for (p.panes, 0..) |slot, i| {
+ if (slot == null and !p.reserved_slots[i]) break i;
+ } else null;
+}
+
+/// The slot holding the pane with this serial, if it is still open.
+pub fn paneBySerial(p: *Pardes, serial: u32) ?usize {
+ return for (p.panes, 0..) |slot, i| {
+ if (slot) |pane| if (pane.serial == serial) break i;
+ } else null;
+}
+
+/// The pane a session word runs with in an empty window.
+pub fn standIn(p: *Pardes) ?*Pane {
+ if (p.stand_in == null) p.stand_in = panes.terminal.createDoc(p.gpa, p.screen_w, p.screen_h) catch null;
+ return p.stand_in;
+}
+
+pub fn paneIdOf(p: *const Pardes, pane: *const Pane) ?usize {
+ return std.mem.findScalar(?*const Pane, &p.panes, pane);
+}
+
+pub fn openTutorView(p: *Pardes, id: usize) !*Pane {
+ const content = try p.gpa.dupe(u8, tutor_text);
+ errdefer p.gpa.free(content);
+ // A generated pane, named as every one is: `+` in the session's
+ // directory, never a bare path Save could write at the root.
+ const path = try std.fs.path.join(p.gpa, &.{ p.sessionDir(), "+Tutor" });
+ errdefer p.gpa.free(path);
+ const history = try panes.File.History.create(p.gpa);
+ errdefer p.gpa.destroy(history);
+ const pane = try p.newDocPane(id);
+ pane.file = .{ .path = path, .content = content, .history = history };
+ pane.body.cur_pinned = true;
+ return pane;
+}
+
+pub fn setTestFile(p: *Pardes, content: []const u8) !*Pane {
+ const copy = try p.gpa.dupe(u8, content);
+ errdefer p.gpa.free(copy);
+ const path = try p.gpa.dupe(u8, "/test.txt");
+ errdefer p.gpa.free(path);
+ const history = try panes.File.History.create(p.gpa);
+ errdefer p.gpa.destroy(history);
+ const pane = try panes.terminal.createDoc(p.gpa, p.screen_w, p.screen_h);
+ errdefer p.gpa.destroy(pane);
+ try deinitPane(p, p.panes[0].?);
+ p.panes[0] = null;
+ pane.file = .{ .path = path, .content = copy, .history = history };
+ p.installPane(0, pane);
+ pane.body.cur_pinned = true;
+ p.active = 0;
+ p.sync();
+ return pane;
+}
+
+pub fn paneDir(pane: *const Pane) []const u8 {
+ switch (pane.cwd) {
+ .inherited => |src| return paneDir(src),
+ .owned => |cwd| return cwd,
+ .none => {},
+ }
+ if (pane.file) |f| return panes.Dir.ofName(f.path);
+ if (comptime pdf_enabled) if (pane.pdf) |pv|
+ return std.fs.path.dirname(pv.path) orelse "/";
+ if (pane.image) |iv| return std.fs.path.dirname(iv.path) orelse "/";
+ return pane.cwdSlice();
+}
+
+/// Close a pane; its rows go to `to`, or where layout.absorbVWeight
+/// sends them when that is null. Focus on it follows its rows to the
+/// pane that grew into them. A column outlives its panes, as acme's
+/// does (cols.c:186): closing its last one leaves it empty, the keyboard
+/// on its tag; only Delcol takes a column away. The session's last pane
+/// closing ends the session. Every route that closes a pane comes
+/// through here or removeColumn, so none picks focus for itself, and
+/// none by recency.
+pub fn removePane(p: *Pardes, id: usize, to: ?usize) error{OutOfMemory}!void {
+ const pane = p.panes[id] orelse return;
+ // What is attached to it closes with it, first, each giving its rows
+ // back to it: then its rows, theirs among them, go where a pane's go.
+ for (0..p.panes.len) |k| if (p.panes[k]) |other| if (k != id and other.attached_to == pane.serial) {
+ if (layout.ownerOf(p, k) != id) continue;
+ try p.removePane(k, id);
+ layout.compute(p);
+ };
+ // An attachment's rows go back to its owner and nobody else.
+ const owner = layout.ownerOf(p, id);
+ const place = layout.findPane(p, id);
+ const emptied = if (place) |f| (if (p.col_n[f.col] == 1) f.col else null) else null;
+ // What it was and where, for Panes to bring back (Store.zig).
+ const kept = p.store.keep(p, id);
+ errdefer if (kept) |k| k.free(p.recentGpa());
+ // Before anything is torn down, so a failure here changes nothing.
+ try deinitPane(p, pane);
+ const gainer = layout.absorbVWeight(p, id, owner orelse to);
+ const beside = if (emptied) |c| p.besideColumn(c, p.rects[id]) else null;
+ layout.removePane(p, id);
+ p.panes[id] = null;
+ if (kept) |k| p.store.close(p, k, gainer);
+ // The finder's last pane takes the column with it.
+ const finder_gone = if (emptied) |c| p.finder.emptied(p, c) else false;
+ if (p.active != id) return;
+ // No pane left: the session is over.
+ p.active = gainer orelse beside orelse anyPane(p) orelse {
+ p.quit = true;
+ return p.emit(.quit);
+ };
+ if (emptied) |c| if (!finder_gone and !p.header_focus) tagline.enterHeader(p, c);
+}
+
+/// The pane Last should fall back to when the jumplist has nothing: the
+/// one below in this column, wrapping to the top, and any other live pane
+/// failing that. A pane that opened beside this one and was never focused
+/// -- the text pane the bare tty layout puts under the shell -- is not on
+/// the jumplist, and alternating with it is exactly what Last is for.
+pub fn neighbourPane(p: *Pardes, from: usize) ?usize {
+ if (layout.findPane(p, from)) |at| {
+ const n = p.col_n[at.col];
+ if (n > 1) return p.col_panes[at.col][(at.idx + 1) % n];
+ }
+ for (p.panes, 0..) |slot, id| {
+ if (slot != null and id != from) return id;
+ }
+ return null;
+}
+
+/// Any live pane: the last resort when nothing took the closed one's place.
+pub fn anyPane(p: *const Pardes) ?usize {
+ for (p.panes, 0..) |slot, k| if (slot != null) return k;
+ return null;
+}
+
+/// Open a prompt on `pane`'s notice band answering for `t`: the body,
+/// the pane's tag, or the header that has the keyboard.
+pub fn startPrompt(p: *Pardes, pane: *Pane, t: *Text, request: union(enum) {
+ search: []const u8,
+ pipe: modal.Normal.PipeBehavior,
+ save,
+}) void {
+ // Nobody is at the keyboard to answer a command a script wrote to a
+ // ctl file: the write fails instead (src/ninep/ctl.zig).
+ if (p.fs.no_prompt) {
+ p.fs.refused = true;
+ // A failure like any other: the builtin's announcement goes.
+ p.fs.failures +%= 1;
+ return;
+ }
+ // Asked for over 9P (Save from an exec on a terminal): a question
+ // the log says, `ask <serial> save path`, answered on the pane's
+ // ctl with `answer <path>` or `answer -`; asked again, the one
+ // already open stands, not a second on top of it.
+ if (request == .save and p.fs.serving) {
+ if (pane.prompt == .save) return;
+ var rec: [32]u8 = undefined;
+ ctlfs.events.notePath(p, "ask", std.fmt.bufPrint(&rec, "{d} save path", .{pane.serial}) catch "");
+ }
+ const marker = switch (request) {
+ .search => |marker| marker,
+ .save => config.save_marker,
+ .pipe => |how| pipe: {
+ // A body is piped only when it is a file that saves; a tag's
+ // or a header's text is its own.
+ if (t.what == .body) {
+ const file = pane.file orelse return;
+ if (!panes.Output.fileTraits(file.output).saves) return;
+ }
+ break :pipe Pipe.pipeMarker(how);
+ },
+ };
+ // Save asks for a path, so its answer starts out as the pane's own
+ // directory for the name to be typed onto.
+ const dir = if (request == .save) paneDir(pane) else "";
+ const slash: []const u8 = if (request == .save and (dir.len == 0 or dir[dir.len - 1] != '/')) "/" else "";
+ const answer = std.mem.concat(p.gpa, u8, &.{ marker, dir, slash }) catch return;
+ // The keyboard comes back to the text answered for; a prompt for
+ // the body takes it out of a tag or header.
+ switch (t.what) {
+ .body => {
+ pane.focus = .body;
+ if (p.panes[p.active] == pane) tagline.exitHeader(p);
+ },
+ .tag => pane.focus = .tag,
+ .column, .workspace, .input => {},
+ }
+ // Not closePrompt: an s/S snapshot was taken for this very prompt.
+ if (pane.input.own) |old| p.gpa.free(old);
+ pane.prompt = switch (request) {
+ .search => .search,
+ .pipe => |how| .{ .pipe = how },
+ .save => .save,
+ };
+ pane.prompt_for = t.what;
+ pane.input = .{ .what = .input, .own = answer, .mode = .insert, .cur_pinned = true, .cur_col = @intCast(answer.len) };
+ // Whatever mode the text was in, it is in normal mode once the
+ // prompt is answered or dropped.
+ t.mode = .normal;
+ t.normal.clear();
+}
+
+/// The text `pane`'s open prompt answers for, if it is still there.
+pub fn promptTarget(p: *Pardes, pane: *Pane) ?*Text {
+ return switch (pane.prompt_for) {
+ .body => &pane.body,
+ .tag => &pane.tag,
+ .column, .workspace => if (tagline.focusedHeader(p)) |h| (if (h.what == pane.prompt_for) h else null) else null,
+ .input => null,
+ };
+}
+
+test "owned cwd preserves long paths aliases and failed updates" {
+ var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(allocator.allocator(), .{ .tty_only = true });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ var path: [3072]u8 = @splat('d');
+ path[0] = '/';
+ for (1..12) |i| path[i * 256] = '/';
+ p.setCwd(0, &path);
+ try std.testing.expectEqualStrings(&path, pane.cwdSlice());
+ try std.testing.expect(pane.cwdSlice().ptr != &path);
+ const original = pane.cwdSlice();
+ try pane.setOwnedCwd(original);
+ try std.testing.expectEqualStrings(&path, pane.cwdSlice());
+ // A terminal's directory may be as long as a path is (PATH_MAX): one
+ // past the effect's buffer goes out of line (spawn_dirs); only one past
+ // the host's path limit is too long.
+ const free = p.freeSlot().?;
+ _ = try p.newShell(free, path[0..]);
+ try std.testing.expectEqualStrings(&path, p.spawn_dirs[free].?);
+ try p.removePane(free, null);
+ while (p.nextEffect()) |_| {}
+ var too_long: [limits.host_path_cap + 1]u8 = @splat('d');
+ too_long[0] = '/';
+ try std.testing.expectError(error.PathTooLong, p.newShell(free, &too_long));
+ try std.testing.expect(p.panes[free] == null);
+ const effects = p.effects_len;
+ exec.saveTo(p, 0, "file.txt");
+ try std.testing.expectEqual(effects, p.effects_len);
+ try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "path too long") != null);
+
+ const current = pane.cwdSlice();
+ allocator.fail_index = allocator.alloc_index;
+ p.setCwd(0, "/replacement");
+ try std.testing.expectEqual(current.ptr, pane.cwdSlice().ptr);
+ try std.testing.expectEqualStrings(&path, pane.cwdSlice());
+ try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "out of memory") != null);
+ allocator.fail_index = std.math.maxInt(usize);
+ p.setCwd(0, "/replacement");
+ try std.testing.expectEqualStrings("/replacement", pane.cwdSlice());
+ const allocations = allocator.allocations;
+ p.setCwd(0, "/replacement");
+ try std.testing.expectEqual(allocations, allocator.allocations);
+ pane.clearCwd();
+ try std.testing.expect(pane.cwd == .none);
+ try std.testing.expectEqualStrings("", pane.cwdSlice());
+}
+
+test "owned cwd close copies are transactional across inherited chains" {
+ for (0..2) |failed_copy| {
+ var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(allocator.allocator(), .{ .tty_only = true });
+ defer p.deinit();
+ const parent = try p.setTestFile("body\n");
+ p.gpa.free(parent.file.?.path);
+ parent.file.?.path = try p.gpa.dupe(u8, "/work/project/source.zig");
+ p.newScratchBelow(0);
+ const first_id = p.active;
+ const first = p.panes[first_id].?;
+ p.newScratchBelow(0);
+ const second = p.panes[p.active].?;
+ p.newScratchBelow(first_id);
+ const grandchild = p.panes[p.active].?;
+ p.sync();
+ while (p.nextEffect()) |_| {}
+ p.parkPendingWrite(0, "queued");
+ const pending = p.pending_write[0].?.bytes;
+ const columns = p.col_panes;
+ const counts = p.col_n;
+ const active = p.active;
+ const live_bytes = allocator.allocated_bytes - allocator.freed_bytes;
+ allocator.fail_index = allocator.alloc_index + failed_copy;
+ try std.testing.expectError(error.OutOfMemory, p.removePane(0, null));
+ try std.testing.expectEqual(parent, p.panes[0].?);
+ try std.testing.expectEqual(parent, first.cwd.inherited);
+ try std.testing.expectEqual(parent, second.cwd.inherited);
+ try std.testing.expectEqual(first, grandchild.cwd.inherited);
+ try std.testing.expectEqualDeep(columns, p.col_panes);
+ try std.testing.expectEqualDeep(counts, p.col_n);
+ try std.testing.expectEqual(active, p.active);
+ try std.testing.expectEqual(@as(usize, 0), p.effects_len);
+ try std.testing.expectEqual(pending.ptr, p.pending_write[0].?.bytes.ptr);
+ try std.testing.expectEqual(live_bytes, allocator.allocated_bytes - allocator.freed_bytes);
+
+ allocator.fail_index = std.math.maxInt(usize);
+ try p.removePane(0, null);
+ try std.testing.expect(p.panes[0] == null);
+ try std.testing.expect(first.cwd == .owned and second.cwd == .owned);
+ try std.testing.expectEqual(first, grandchild.cwd.inherited);
+ try std.testing.expect(first.cwdSlice().ptr != second.cwdSlice().ptr);
+ try p.removePane(first_id, null);
+ try std.testing.expect(grandchild.cwd == .owned);
+ p.sync();
+ p.sync();
+ try std.testing.expectEqualStrings("/work/project", Pardes.paneDir(second));
+ try std.testing.expectEqualStrings("/work/project", Pardes.paneDir(grandchild));
+ }
+}
+
+test "owned cwd column close allocates every copy before removing any pane" {
+ var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(allocator.allocator(), .{ .shells = 3, .cols = 100, .rows = 30 });
+ defer p.deinit();
+ p.setCwd(0, "/first");
+ p.setCwd(1, "/second");
+ const first_child = try p.newDocPane(3);
+ const second_child = try p.newDocPane(4);
+ first_child.cwd = .{ .inherited = p.panes[0].? };
+ second_child.cwd = .{ .inherited = p.panes[1].? };
+ while (p.nextEffect()) |_| {}
+ const before = p.panes;
+ const columns = p.col_panes;
+ const counts = p.col_n;
+ allocator.fail_index = allocator.alloc_index + 1;
+ try std.testing.expectError(error.OutOfMemory, p.removeColumn(0));
+ for (before, p.panes) |old, current| try std.testing.expectEqual(old, current);
+ try std.testing.expectEqualDeep(columns, p.col_panes);
+ try std.testing.expectEqualDeep(counts, p.col_n);
+ try std.testing.expectEqual(@as(usize, 0), p.effects_len);
+ try std.testing.expect(first_child.cwd == .inherited and second_child.cwd == .inherited);
+ allocator.fail_index = std.math.maxInt(usize);
+ try p.removeColumn(0);
+ try std.testing.expect(p.panes[0] == null and p.panes[1] == null);
+ p.sync();
+ p.sync();
+ try std.testing.expectEqualStrings("/first", first_child.cwdSlice());
+ try std.testing.expectEqualStrings("/second", second_child.cwdSlice());
+}
+
+test "owned cwd EOF failure retains the pane and Del retries its close" {
+ var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(allocator.allocator(), .{ .tty_only = true });
+ defer p.deinit();
+ p.setCwd(0, "/exited");
+ const parent = p.panes[0].?;
+ p.newScratchBelow(0);
+ const child = p.panes[p.active].?;
+ p.sync();
+ while (p.nextEffect()) |_| {}
+ allocator.fail_index = allocator.alloc_index;
+ p.update(.{ .eof = .{ .pane = 0 } });
+ try std.testing.expectEqual(parent, p.panes[0].?);
+ try std.testing.expectEqual(parent, child.cwd.inherited);
+ try std.testing.expectEqual(Text.Mode.normal, parent.body.mode);
+ try std.testing.expect(std.mem.indexOf(u8, parent.msg[0..parent.msg_len], "Del retries close") != null);
+ try std.testing.expectEqual(@as(usize, 0), p.effects_len);
+ allocator.fail_index = std.math.maxInt(usize);
+ try std.testing.expect(p.executeBuiltinLine(0, "Del"));
+ try std.testing.expect(p.panes[0] == null);
+ p.sync();
+ p.sync();
+ try std.testing.expectEqualStrings("/exited", child.cwdSlice());
+}
+
+test "owned cwd restore either copies the directory or preserves the old core" {
+ // No terminal: ghostty 1.4's snapshot decode leaks when an allocation
+ // inside it fails, and this fails every allocation of a Restore in turn
+ // (what pardes's own load made is freed, src/walk.zig rollback).
+ var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(allocator.allocator(), .{ .tty_only = true, .file = "/nonexistent/pardes-owned-cwd" });
+ defer p.deinit();
+ p.newScratchBelow(0);
+ const id = p.active;
+ try p.panes[id].?.setOwnedCwd("/retained/terminal/directory");
+ try dump.dumpState(p);
+ const original = p.panes[id].?;
+ var completed = false;
+ for (0..256) |failure| {
+ allocator.has_induced_failure = false;
+ allocator.fail_index = allocator.alloc_index + failure;
+ const replacement = dump.restore(p, p.dump_out.?, "test") catch {
+ try std.testing.expect(allocator.has_induced_failure);
+ try std.testing.expectEqual(original, p.panes[id].?);
+ try std.testing.expectEqualStrings("/retained/terminal/directory", original.cwdSlice());
+ continue;
+ };
+ defer replacement.deinit();
+ try std.testing.expectEqualStrings("/retained/terminal/directory", replacement.panes[id].?.cwdSlice());
+ try std.testing.expectEqual(original, p.panes[id].?);
+ if (!allocator.has_induced_failure) {
+ completed = true;
+ break;
+ }
+ }
+ allocator.fail_index = std.math.maxInt(usize);
+ try std.testing.expect(completed);
+}
+
+test "owned cwd Save promotion releases the former directory" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ p.newScratchBelow(0);
+ const id = p.active;
+ const pane = p.panes[id].?;
+ try pane.setOwnedCwd("/old/directory");
+ exec.saveTo(p, id, "saved.txt");
+ // Named once the write is done (a failed one changes nothing).
+ try std.testing.expect(pane.file.?.output != null);
+ while (p.nextEffect()) |effect| p.perform(effect);
+ try std.testing.expect(pane.cwd == .none);
+ try std.testing.expect(pane.file.?.output == null);
+ try std.testing.expectEqualStrings("/old/directory/saved.txt", pane.file.?.path);
+ try std.testing.expectEqualStrings("/old/directory", Pardes.paneDir(pane));
+}
+
+test "the Tutor pane is named +Tutor in the session's directory, never a bare path at the root" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ const session = "/project/src";
+ @memcpy(p.session_dir[0..session.len], session);
+ p.session_dir_len = session.len;
+ const tutor = try openTutorView(p, 1);
+ try std.testing.expectEqualStrings("/project/src/+Tutor", tutor.file.?.path);
+ // Its bare Save writes no file named +Tutor: it asks for a path.
+ while (p.nextEffect()) |_| {}
+ try std.testing.expect(p.executeBuiltinLine(1, "Save"));
+ try std.testing.expect(tutor.prompt == .save);
+ while (p.nextEffect()) |e| try std.testing.expect(e != .save_file);
+}
+
+test "New opens an empty scratch below the caller, inheriting its directory" {
+ const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+
+ const source: usize = 2; // the right column; active starts in the left
+ p.setCwd(source, "/tmp/pardes-scratch-dir");
+ const source_col = layout.findPane(p, source).?.col;
+
+ try std.testing.expect(p.executeBuiltinLine(source, "New"));
+ // no shell IO: the scratch is created in-core, focused, below the caller
+ while (p.nextEffect()) |_| {}
+ const id = p.active;
+ try std.testing.expect(id != source);
+ try std.testing.expectEqual(source_col, layout.findPane(p, id).?.col);
+ const np = p.panes[id].?;
+ try std.testing.expect(np.file.?.output != null); // an output buffer, empty
+ try std.testing.expectEqual(@as(usize, 0), np.file.?.content.len);
+ // its directory is a LIVE link to the opener, not a snapshot taken at New
+ try std.testing.expectEqualStrings("/tmp/pardes-scratch-dir", Pardes.paneDir(np));
+ p.setCwd(source, "/tmp/pardes-moved");
+ try std.testing.expectEqualStrings("/tmp/pardes-moved", Pardes.paneDir(np));
+ try p.removePane(source, null);
+ p.sync();
+ try std.testing.expect(np.cwd == .owned);
+ try std.testing.expectEqualStrings("/tmp/pardes-moved", Pardes.paneDir(np));
+ p.sync();
+ try std.testing.expectEqualStrings("/tmp/pardes-moved", Pardes.paneDir(np));
+}
+
+test "a prompt chip is a band with its caret, still on the grid, and only the chip swallows a click" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const id = p.active;
+ const pane = p.panes[id].?;
+ p.sync();
+ var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer frame.deinit();
+
+ // The caret sits AFTER the prompt text the moment the prompt opens, and
+ // the chip ends at the pane's right edge -- so this is the frame that
+ // used to put it one column past the pane, off the grid and past what the
+ // detached wire will encode.
+ startPrompt(p, pane, &pane.body, .{ .search = "/" });
+ _ = try p.render(frame.allocator());
+ const r = p.rects[id];
+ const cursor = p.surface.cursor orelse return error.MissingPromptCursor;
+ const row = p.bodyTop(pane, r);
+ try std.testing.expectEqual(@as(u8, 1), pane.notices.len);
+ try std.testing.expectEqual(row, cursor.y);
+ try std.testing.expect(cursor.x < r.x + r.w);
+ try std.testing.expect(cursor.x < p.surface.cols);
+ // A pixel shell draws the prompt from its band, in the tagline's pitch,
+ // with the caret right after the marker's last glyph.
+ const band = for (p.surface.tagLayers()) |*layer| {
+ if (layer.rows != 0 and layer.kind == .notice) break layer;
+ } else return error.NoPromptBand;
+ try std.testing.expectEqual(row, band.viewport.y);
+ const caret = band.cursor orelse return error.MissingBandCaret;
+ try std.testing.expect(caret.bar);
+ try std.testing.expectEqualStrings("/", band.cells[caret.x - 1].grapheme());
+
+ // The chip covers only its own columns. Left of it is ordinary body, and
+ // a sweep there still selects.
+ const left = pane.notices.left[0];
+ try std.testing.expect(left > r.x + config.GUTTER + 2);
+ p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = left - 3, .row = row } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .drag, .col = left - 1, .row = row } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = left - 1, .row = row } });
+ try std.testing.expect(pane.sel[0].state != .none);
+ try std.testing.expect(pane.sel[0].r0 >= BOX_H); // the body, not the tag
+
+ // Inside it is chrome: mapped as body it would land on Sel row 0, which is
+ // the TAG row, so a sweep there would highlight the tagline instead.
+ // The sweep closed the prompt, and its chip with it: open it again.
+ pane.clearPointerSelection(0);
+ pane.sel[0] = .{};
+ startPrompt(p, pane, &pane.body, .{ .search = "/" });
+ p.sync();
+ try std.testing.expectEqual(left, pane.notices.left[0]);
+ p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = r.x + r.w - 3, .row = row } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .drag, .col = r.x + r.w - 2, .row = row } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = r.x + r.w - 2, .row = row } });
+ for (pane.sel) |selection| try std.testing.expect(selection.state == .none);
+}
+
+test "a prompt is typed on its own line in the notice band and leaves the tag row alone" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = try p.setTestFile("one two\n");
+ var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ const tag_before = try std.testing.allocator.dupe(Cell, p.surface.tag_layers[0].cells);
+ defer std.testing.allocator.free(tag_before);
+
+ // `s` keeps a prompt on the band (a text's `/` is its query pane's
+ // line 1 now, Query.zig).
+ p.update(.{ .key = .{ .cp = 's' } });
+ p.update(.{ .key = .{ .cp = 't', .text = "tw" } });
+ p.update(.{ .key = .{ .cp = Key.left } });
+ try std.testing.expect(pane.prompt == .search and pane.focus == .body);
+ try std.testing.expectEqualStrings(config.select_marker ++ "tw", pane.promptText().?);
+ _ = frame.reset(.retain_capacity);
+ _ = try p.render(frame.allocator());
+ // The tagline is exactly what it was: nothing of the prompt is in it.
+ try std.testing.expectEqual(tag_before.len, p.surface.tag_layers[0].cells.len);
+ for (tag_before, p.surface.tag_layers[0].cells) |was, is| try std.testing.expect(was.visuallyEqual(&is));
+ try std.testing.expect(p.surface.tag_layers[0].cursor == null);
+ // The band carries the answer and the caret, one cell back from its end.
+ const band = for (p.surface.tagLayers()) |*layer| {
+ if (layer.rows != 0 and layer.kind == .notice) break layer;
+ } else return error.NoPromptBand;
+ const caret = band.cursor orelse return error.MissingBandCaret;
+ try std.testing.expectEqualStrings("t", band.cells[caret.x - 1].grapheme());
+ try std.testing.expectEqualStrings("w", band.cells[caret.x].grapheme());
+ const grid = p.surface.cursor orelse return error.MissingPromptCursor;
+ try std.testing.expectEqual(p.bodyTop(pane, p.rects[0]), grid.y);
+
+ // Submitting searches for what was typed and gives the prompt its line back.
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ try std.testing.expect(pane.prompt == .none and pane.input.own == null);
+}