diff options
Diffstat (limited to 'src/pardes.zig')
| -rw-r--r-- | src/pardes.zig | 653 |
1 files changed, 11 insertions, 642 deletions
diff --git a/src/pardes.zig b/src/pardes.zig index 1e9f1669..8e41d392 100644 --- a/src/pardes.zig +++ b/src/pardes.zig @@ -56,6 +56,12 @@ pub const hit = @import("Event.zig").hit; pub const sel_slot = @import("Event.zig").sel_slot; pub const CellPixels = @import("Event.zig").CellPixels; pub const Event = @import("Event.zig").Event; +/// What goes out (Effect.zig). +pub const PtySignal = @import("Effect.zig").PtySignal; +pub const WatchMode = @import("Effect.zig").WatchMode; +pub const effect_path_cap = @import("Effect.zig").effect_path_cap; +pub const effect_write_cap = @import("Effect.zig").effect_write_cap; +pub const Effect = @import("Effect.zig").Effect; pub const builtins = @import("builtins.zig"); /// Every builtin as JSON, for the docs (tools/gen_builtins_json.zig). pub const builtins_json = @import("builtins_json.zig"); @@ -289,6 +295,7 @@ pub const Loc = struct { test { _ = @import("rollback.zig"); + _ = @import("Effect.zig"); _ = @import("tape.zig"); _ = @import("replica.zig"); _ = @import("echo.zig"); @@ -366,42 +373,6 @@ pub const test_api = if (@import("builtin").is_test) struct { } } else struct {}; -fn drainForSavePath(p: *Pardes, buf: []u8) ?[]const u8 { - var len: ?usize = null; - while (p.nextEffect()) |effect| { - switch (effect) { - .save_text => |st| { - const path = st.path.slice(); - @memcpy(buf[0..path.len], path); - len = path.len; - }, - else => {}, - } - p.perform(effect); - } - return if (len) |n| buf[0..n] else null; -} - -test "Detach asks the host to let its terminal go, and says so when there is nothing to leave" { - if (comptime !can_attach) return; // the word is compiled out elsewhere: see `can_attach` - const gpa = std.testing.allocator; - const p = try Pardes.init(gpa, .{ .tty_only = true }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - try std.testing.expect(p.executeBuiltinLine(0, "Detach")); - const asked = while (p.nextEffect()) |effect| switch (effect) { - .detach => |d| break d, - else => {}, - } else return error.NoDetachAsked; - try std.testing.expectEqual(@as(u8, 0), asked.pane); - - p.perform(.{ .detach = asked }); - const pane = p.panes[0].?; - try std.testing.expectEqualStrings("detach: not attached", pane.msg[0..pane.msg_len]); - try std.testing.expect(!p.quit); -} - test "startup config runs builtin lines in order and isolates bad lines" { const p = try Pardes.init(std.testing.allocator, .{ .startup_config = @@ -1836,328 +1807,6 @@ test "owned cwd Save promotion releases the former directory" { try std.testing.expectEqualStrings("/old/directory", Pardes.paneDir(pane)); } -test "Save on a scratch asks for a path in its inherited dir and makes it a file" { - const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - const source: usize = 2; - p.setCwd(source, "/tmp/pardes-save-dir"); - try std.testing.expect(p.executeBuiltinLine(source, "New")); - const id = p.active; - const np = p.panes[id].?; - p.sync(); // the frame boundary that gives the new pane its geometry - while (p.nextEffect()) |_| {} - - // Save on a scratch arms a PATH input, prefilled with the inherited dir - try std.testing.expect(p.executeBuiltinLine(id, "Save")); - try std.testing.expect(np.prompt == .save); - try std.testing.expectEqualStrings(" Save /tmp/pardes-save-dir/", np.promptText().?); - - // typing the filename and submitting converts it into an ordinary file - edit.insertKey(p, &np.input, .{ .cp = 'n', .text = "note.txt" }); - exec.submitSave(p, id); - // The write asked for, the pane is the file once it is done. - var saved = false; - while (p.nextEffect()) |effect| { - if (effect == .save_text and @as(usize, effect.save_text.pane) == id) saved = true; - p.perform(effect); - } - try std.testing.expect(saved); - try std.testing.expect(np.file.?.output == null); - try std.testing.expectEqualStrings("/tmp/pardes-save-dir/note.txt", np.file.?.path); - try std.testing.expectEqual(np.file.?.revision, np.file.?.saved_revision); -} - -test "Save on a terminal writes its plaintext scrollback and stays a terminal" { - const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 8 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - const pane = p.panes[0].?; - p.setCwd(0, "/tmp/pardes-tty-save"); - p.update(.{ .output = .{ .pane = 0, .bytes = "hello scrollback\r\n" } }); - while (p.nextEffect()) |_| {} - - try std.testing.expect(p.executeBuiltinLine(0, "Save")); - try std.testing.expect(pane.prompt == .save); - edit.insertKey(p, &pane.input, .{ .cp = 'l', .text = "log.txt" }); - exec.submitSave(p, 0); - - // the pane is untouched: still a terminal, no file behind it - try std.testing.expect(pane.isTerminal()); - try std.testing.expect(pane.file == null); - - // the host performs it, reading the scrollback off the pane as it goes - var buf: [256]u8 = undefined; - try std.testing.expectEqualStrings( - "/tmp/pardes-tty-save/log.txt", - drainForSavePath(p, &buf) orelse return error.NoSaveAsked, - ); - const written = p.fallback.get("/tmp/pardes-tty-save/log.txt") orelse return error.NothingWritten; - try std.testing.expect(std.mem.indexOf(u8, written, "hello scrollback") != null); -} - -test "Save on an output buffer writes its rows out and leaves the buffer alone" { - const gpa = std.testing.allocator; - const p = try Pardes.init(gpa, .{ .shells = 3, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - const source: usize = 2; - p.setCwd(source, "/tmp/pardes-output-save"); - try std.testing.expect(p.executeBuiltinLine(source, "Help")); - p.sync(); // the frame boundary that gives the new pane its geometry - while (p.nextEffect()) |_| {} - - const help: panes.Output.Origin = .{ .cmd = .Help }; - const id = blk: { - for (p.panes, 0..) |slot, i| { - const pane = slot orelse continue; - const f = pane.file orelse continue; - const o = f.output orelse continue; - if (std.meta.eql(o.from, help)) break :blk i; - } - return error.MissingHelpBuffer; - }; - const out = p.panes[id].?; - const path = try gpa.dupe(u8, out.file.?.path); - defer gpa.free(path); - const rows = try gpa.dupe(u8, out.file.?.content); - defer gpa.free(rows); - - // Save leads its tagline now, and the path is REQUIRED: a bare Save asks - try std.testing.expectEqualStrings(tagline.file_pane_tail, tagline.curTail(out)); - try std.testing.expect(p.executeBuiltinLine(id, "Save")); - try std.testing.expect(out.prompt == .save); - edit.insertKey(p, &out.input, .{ .cp = 'h', .text = "help.txt" }); - exec.submitSave(p, id); - - // the buffer itself is untouched: same origin, same name, still refillable - // and still walked by n/N, because a saved copy of a list is only a copy - try std.testing.expect(out.file.?.output != null); - try std.testing.expectEqual(help, out.file.?.output.?.from); - try std.testing.expectEqualStrings(path, out.file.?.path); - - var buf: [256]u8 = undefined; - try std.testing.expectEqualStrings( - "/tmp/pardes-output-save/help.txt", - drainForSavePath(p, &buf) orelse return error.NoSaveAsked, - ); - try std.testing.expectEqualStrings( - rows, - p.fallback.get("/tmp/pardes-output-save/help.txt") orelse return error.NothingWritten, - ); -} - -test "Save takes the path as an argument, relative to the pane's own directory" { - const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 8 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - const pane = p.panes[0].?; - p.setCwd(0, "/tmp/pardes-arg-save"); - p.update(.{ .output = .{ .pane = 0, .bytes = "typed and gone\r\n" } }); - while (p.nextEffect()) |_| {} - - var buf: [256]u8 = undefined; - try std.testing.expect(p.executeBuiltinLine(0, "Save session.txt")); - try std.testing.expect(pane.prompt != .save); - try std.testing.expectEqualStrings( - "/tmp/pardes-arg-save/session.txt", - drainForSavePath(p, &buf) orelse return error.NoSaveAsked, - ); - const written = p.fallback.get("/tmp/pardes-arg-save/session.txt") orelse return error.NothingWritten; - try std.testing.expect(std.mem.indexOf(u8, written, "typed and gone") != null); - - // `.` and `..` normalize with it, so this is that same file and not a - // second one spelled differently - try std.testing.expect(p.executeBuiltinLine(0, "Save ./sub/../session.txt")); - try std.testing.expectEqualStrings( - "/tmp/pardes-arg-save/session.txt", - drainForSavePath(p, &buf) orelse return error.NoSaveAsked, - ); - - try std.testing.expect(p.executeBuiltinLine(0, "Save /tmp/pardes-elsewhere/abs.txt")); - try std.testing.expectEqualStrings( - "/tmp/pardes-elsewhere/abs.txt", - drainForSavePath(p, &buf) orelse return error.NoSaveAsked, - ); - try std.testing.expect(pane.isTerminal()); - - p.panes[0].?.clearCwd(); - try std.testing.expect(p.executeBuiltinLine(0, "Save nowhere.txt")); - try std.testing.expect(drainForSavePath(p, &buf) == null); -} - -test "a save the host could not do leaves the pane dirty" { - const gpa = std.testing.allocator; - const Refusing = struct { - fn writeFile(ctx: ?*anyopaque, pane: u8, _: []const u8, _: []const u8) void { - const core: *Pardes = @ptrCast(@alignCast(ctx.?)); - core.saveFailed(pane, "/x/y.txt", error.PermissionDenied); - } - }; - const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - const pane = try p.setTestFile("before\n"); - panes.File.setContent(p, &pane.file.?, try gpa.dupe(u8, "after\n")); - try std.testing.expect(pane.file.?.revision != pane.file.?.saved_revision); - - p.host = .{ .ctx = p, .vtable = &.{ .write_file = Refusing.writeFile } }; - try std.testing.expect(p.executeBuiltinLine(0, "Save")); - while (p.nextEffect()) |effect| p.perform(effect); - try std.testing.expect(pane.file.?.revision != pane.file.?.saved_revision); - - // ...and the same save against a host that CAN write does come clean, so - // the guard above is not simply "never clean". - p.host = .{}; - try std.testing.expect(p.executeBuiltinLine(0, "Save")); - while (p.nextEffect()) |effect| p.perform(effect); - try std.testing.expectEqual(pane.file.?.revision, pane.file.?.saved_revision); - try std.testing.expectEqualStrings("after\n", p.fallback.get("/test.txt").?); -} - -test "Save elsewhere copies a file's bytes and keeps the pane on its own file" { - const gpa = std.testing.allocator; - const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - const pane = try p.setTestFile("before\n"); - panes.File.setContent(p, &pane.file.?, try gpa.dupe(u8, "after\n")); - try std.testing.expect(pane.file.?.revision != pane.file.?.saved_revision); - - var buf: [256]u8 = undefined; - try std.testing.expect(p.executeBuiltinLine(0, "Save /tmp/pardes-copy/other.txt")); - // a copy, never a rename: the pane keeps its file, and that file is still - // unsaved, so the marker stays where it was - try std.testing.expectEqualStrings("/test.txt", pane.file.?.path); - try std.testing.expect(pane.file.?.revision != pane.file.?.saved_revision); - try std.testing.expectEqualStrings( - "/tmp/pardes-copy/other.txt", - drainForSavePath(p, &buf) orelse return error.NoSaveAsked, - ); - try std.testing.expectEqualStrings( - "after\n", - p.fallback.get("/tmp/pardes-copy/other.txt") orelse return error.NothingWritten, - ); - - // its own path, spelled out, is the in-place write — nothing is asked of - // the host but save_file, and the pane comes clean - try std.testing.expect(p.executeBuiltinLine(0, "Save /test.txt")); - try std.testing.expect(drainForSavePath(p, &buf) == null); - try std.testing.expectEqual(pane.file.?.revision, pane.file.?.saved_revision); -} - -test "saves armed in one batch stay with their own panes" { - const gpa = std.testing.allocator; - const p = try Pardes.init(gpa, .{ .shells = 3, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - const tty_id = p.freeSlot() orelse return error.NoPaneSlots; - const shell = try p.newShell(tty_id, "/tmp/pardes-batch"); - p.setCwd(tty_id, "/tmp/pardes-batch"); - p.update(.{ .output = .{ .pane = @intCast(tty_id), .bytes = "shell text\r\n" } }); - const file = try p.setTestFile("file text\n"); - const file_id = p.paneIdOf(file) orelse return error.MissingFilePane; - try std.testing.expect(shell.isTerminal()); - try std.testing.expect(tty_id != file_id); - while (p.nextEffect()) |_| {} - - // both armed before the host drains anything — the path rides inside its - // own effect, so neither can be written with the other pane's text - try std.testing.expect(p.executeBuiltinLine(tty_id, "Save tty.txt")); - try std.testing.expect(p.executeBuiltinLine(file_id, "Save /tmp/pardes-batch/file.txt")); - while (p.nextEffect()) |effect| p.perform(effect); - const tty_bytes = p.fallback.get("/tmp/pardes-batch/tty.txt") orelse return error.NothingWritten; - try std.testing.expect(std.mem.indexOf(u8, tty_bytes, "shell text") != null); - try std.testing.expectEqualStrings( - "file text\n", - p.fallback.get("/tmp/pardes-batch/file.txt") orelse return error.NothingWritten, - ); -} - -test "a save whose pane is gone before the drain writes nothing" { - const gpa = std.testing.allocator; - const p = try Pardes.init(gpa, .{ .shells = 3, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - const doomed = p.freeSlot() orelse return error.NoPaneSlots; - const shell = try p.newShell(doomed, "/tmp/pardes-gone"); - p.update(.{ .output = .{ .pane = @intCast(doomed), .bytes = "doomed text\r\n" } }); - while (p.nextEffect()) |_| {} - try std.testing.expect(shell.isTerminal()); - - // Save, then close the pane, then let the host drain: the bytes are read - // off the pane at drain time, so there are none to read... - try std.testing.expect(p.executeBuiltinLine(doomed, "Save /tmp/pardes-gone/log.txt")); - try std.testing.expect(p.executeBuiltinLine(doomed, "Del")); - while (p.nextEffect()) |effect| p.perform(effect); - try std.testing.expect(p.fallback.get("/tmp/pardes-gone/log.txt") == null); - - // ...and a pane that took the freed slot in the meantime is NOT the pane - // that asked, which is what the serial in the effect is for - try std.testing.expect(p.executeBuiltinLine(0, "Save /tmp/pardes-gone/recycled.txt")); - try std.testing.expect(p.executeBuiltinLine(0, "Del")); - const reused = p.freeSlot() orelse return error.NoPaneSlots; - _ = try p.newShell(reused, "/tmp/pardes-gone"); - while (p.nextEffect()) |effect| p.perform(effect); - try std.testing.expect(p.fallback.get("/tmp/pardes-gone/recycled.txt") == null); -} - -test "Save reaches every tagline with text behind it and no other" { - const gpa = std.testing.allocator; - const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - const out = try p.setTestFile("build.zig:1:1 pub fn main\n"); - out.file.?.output = .{ .from = .search }; - try std.testing.expectEqualStrings(tagline.locations_pane_tail, tagline.curTail(out)); - - // A scratch is an output buffer that wears the FILE tails. - out.file.?.output = .{ .from = .{ .cmd = std.meta.stringToEnum(Builtin, "New").? } }; - try std.testing.expectEqualStrings(" Save Term Collapse Del", tagline.curTail(out)); - - // An image's bytes on disk already are what they are: nothing of the - // pane's own is unwritten, so the word is absent and inert. - const img_id = p.freeSlot().?; - const img = try panes.Image.create(p, img_id, "/tmp/pardes-tag.ppm", &.{}); - try std.testing.expectEqualStrings(" Term Collapse Del", tagline.curTail(img)); - try std.testing.expect(p.executeBuiltinLine(img_id, "Save")); - try std.testing.expect(img.prompt != .save); - var buf: [256]u8 = undefined; - try std.testing.expect(drainForSavePath(p, &buf) == null); -} - -test "a save path that names no file is refused before anything is rewritten" { - const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 }); - defer p.deinit(); - while (p.nextEffect()) |_| {} - - const source: usize = 2; - p.setCwd(source, "/tmp/pardes-refuse"); - try std.testing.expect(p.executeBuiltinLine(source, "New")); - const id = p.active; - const scratch = p.panes[id].?; - p.sync(); - while (p.nextEffect()) |_| {} - - try std.testing.expect(p.executeBuiltinLine(id, "Save")); - try std.testing.expect(scratch.prompt == .save); - exec.submitSave(p, id); - var buf: [256]u8 = undefined; - try std.testing.expect(drainForSavePath(p, &buf) == null); - try std.testing.expect(scratch.file.?.output != null); - try std.testing.expectEqualStrings("/tmp/pardes-refuse/+New", scratch.file.?.path); - - // ...and neither is a multi-line selection chorded onto the word - try std.testing.expect(p.executeBuiltinLine(id, "Save one\ntwo")); - try std.testing.expect(drainForSavePath(p, &buf) == null); - try std.testing.expect(scratch.file.?.output != null); -} - test "a host with no methods at all is a complete in-process pardes" { const gpa = std.testing.allocator; const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 10 }); @@ -2655,87 +2304,6 @@ pub const newer_build_words = "a newer pardes is installed: Upgrade (SPC s U) mo pub const PendingWrite = struct { bytes: []u8, off: usize = 0 }; -/// `command` is Kill's: SIGTERM to the terminal's foreground job, and never -/// to the shell itself when the shell is in the foreground. -pub const PtySignal = enum(u8) { int, term, hup, quit, kill }; - -/// IO the core wants done. Payloads are inline (fixed buffers): effects are -/// queued values with no lifetime ties back into the core. -pub const WatchMode = enum { reconcile, baseline_disk }; -pub const effect_path_cap = 256; -/// The bytes one `write` carries, a pty write in the hosts: as many as a -/// path's, which already size the union, so they cost the ring no room -/// (268 bytes an effect at 64 and at 256). -pub const effect_write_cap = 256; - -pub const Effect = union(enum) { - /// A child for the pane in slot `pane` -- the one whose serial is - /// `serial`: a pane closed and its slot taken before the effect is - /// performed is not the one it was for (perform). - spawn: struct { pane: u8, serial: u32, cwd: Buf(effect_path_cap) }, - write: struct { pane: u8, bytes: Buf(effect_write_cap) }, - resize_pty: struct { pane: u8, cols: u16, rows: u16 }, - /// For the pane whose serial is `serial`, as `spawn` is (perform). - signal_pty: struct { pane: u8, serial: u32, sig: PtySignal }, - /// The terminal pane in this slot is gone: the shell hangs up its pty - /// and ends the shell, rather than leave it running with nobody to read. - close_pty: struct { pane: u8 }, - open_link: Buf(256), - /// write this pane's file content to its path; the shell reads both off - /// the core (content is unbounded, effects are fixed-size values) - save_file: struct { pane: u8 }, - save_text: struct { pane: u8, serial: u32, path: Buf(effect_path_cap), promote: bool = false }, - write_dump, - set_clipboard, - read_clipboard, - /// `arg` up to 128 bytes, or for `explain` the query it explains, - /// `<kind> <arg>`. - lsp: struct { id: u32, kind: lsp.Kind, pane: u8, offset: u32, arg: Buf(160) }, - /// Snapshot the matching request with pipeRequest(id), then run it away - /// from the UI/event loop and answer with pipe_resp. - pipe: struct { id: u32 }, - /// Start the disk search of this generation (Stream.start) on a worker - /// posting into the shell's inbox. - search: struct { gen: u32 }, - /// Carry `handover.bytes`, the dump of handover `seq`, to another - /// window, answering with `handed` (Handover.zig). - hand_over: struct { seq: u32 }, - /// Write what an Edit's `w` took (`Pipe.writes`), in order. - edit_write, - watch: struct { pane: u8, on: bool, mode: WatchMode = .reconcile }, - theme_file: struct { generation: u32, on: bool }, - /// Write the build-time theme ring below the per-user config directory. - /// The pane receives the completion/error message from the native host. - dump_themes: struct { pane: u8 }, - detach: struct { pane: u8 }, - quit, - - fn Buf(comptime n: usize) type { - return struct { - pub const replica = .{ .len = .{.{ "data", "len" }} }; - data: [n]u8 = undefined, - len: u16 = 0, - pub const cap = n; - pub fn slice(b: *const @This()) []const u8 { - return b.data[0..b.len]; - } - pub fn from(text: []const u8) @This() { - var b: @This() = .{}; - std.debug.assert(text.len <= n); - @memcpy(b.data[0..text.len], text); - b.len = @intCast(text.len); - return b; - } - }; - } -}; - -comptime { - // A write is never the union's largest variant, so its bytes cost the - // ring of effects no room (effect_write_cap). - std.debug.assert(@sizeOf(@FieldType(Effect, "write")) <= @sizeOf(@FieldType(Effect, "spawn"))); -} - test "a new column takes width only from the column that created it" { const p = try Pardes.init(std.testing.allocator, .{ .cols = 124, .rows = 24 }); defer p.deinit(); @@ -3359,6 +2927,10 @@ pub const Pardes = struct { /// `p.executeBuiltinLine(...)`; it lives with the rest of exec in exec.zig. pub const executeBuiltinLine = exec.executeBuiltinLine; + /// Performing an effect, called from every host and test as + /// `p.perform(e)`; it lives with the effects in Effect.zig. + pub const perform = @import("Effect.zig").perform; + /// The one construction of a session, empty: its allocators, its column /// and workspace tags, the 9P tree's clock and its mounts. `init` boots /// a layout into it and a dump's restore (dump.initDump) its panes; a @@ -4434,50 +4006,6 @@ pub const Pardes = struct { return f(p.host.ctx, @intCast(id)); } - /// Writes `bytes` to `path` for pane `id`, its directories made first: - /// the pane after it, if it is still the one `serial` names and the - /// write did not fail. A failed write changes nothing: its file goes - /// back to the saved revision `was`, dirty as it was. - fn writeChecked(p: *Pardes, id: u8, serial: u32, path: []const u8, bytes: []const u8, was: u32) ?*Pane { - const failures = p.fs.failures; - // A Save makes the directories its file goes in, and any above them, - // first: one rule, for the pane's own name and `Save path` alike. A - // directory it cannot make leaves the write to fail and say why. - if (filesystem.localPath(path)) |local| filesystem.makeDirs(std.fs.path.dirname(local) orelse "/"); - // The in-process filesystem reports the same way a real host does, - // so an OOM there leaves the pane dirty rather than looking saved. - if (p.host.vtable.write_file) |f| f(p.host.ctx, id, path, bytes) else if (!p.fallback.writeFile(path, bytes)) p.saveFailed(id, path, error.OutOfMemory); - const pane = p.panes[id] orelse return null; - if (pane.serial != serial) return null; - if (p.fs.failures == failures) return pane; - if (pane.file) |*f| f.saved_revision = was; - return null; - } - - /// A write of `path` the host could not do: the pane stays dirty, the - /// message row says `Save <path>: <why>`, and the 9P write that asked - /// for it, waiting on the save, fails with that (`fs.late_failure`). - /// A scratch written to `path` is that file from here on: named, an - /// ordinary file pane, clean, and watched (exec.saveTo). - fn promoteSaved(p: *Pardes, id: u8, path: []const u8) void { - const pane = p.panes[id] orelse return; - const f = if (pane.file) |*file| file else return; - const owned = p.gpa.dupe(u8, path) catch return; - p.gpa.free(f.path); - f.path = owned; - f.output = null; - pane.clearCwd(); - // re-derive the tag as a plain file's - if (pane.tag.own) |own| p.gpa.free(own); - pane.tag.own = null; - f.saved_revision = f.revision; - f.disk_gone = false; - ctlfs.events.noteLog(p, .save, pane); - p.recent.opened(p.recentGpa(), f.path); - if (filesystem.localPath(f.path) != null) - p.emit(.{ .watch = .{ .pane = id, .on = true } }); - } - /// A terminal whose shell could not be started: said, and a run waiting /// on it, or written to it from now on, hears `error shell gone` /// rather than wait for a prompt that never comes. @@ -4607,141 +4135,6 @@ pub const Pardes = struct { }; } - pub fn perform(p: *Pardes, e: Effect) void { - const taped = tape.enter(p, .{ .perform = e }); - defer tape.leave(p, taped); - // A Save performed on one twin is every twin's (File.syncTwins). - defer panes.File.syncTwins(p); - const v = p.host.vtable; - switch (e) { - // The host reads the pane (its command, its shell) as it forks, - // so the slot must still hold the pane the spawn was for. - .spawn => |s| if (if (p.panes[s.pane]) |pane| pane.serial != s.serial else true) {} else if (v.spawn) |f| f(p.host.ctx, s.pane, if (s.cwd.len == 0) (p.spawn_dirs[s.pane] orelse "") else s.cwd.slice()) else { - p.fallback.spawned[s.pane] = true; - }, - // A pane with no child is silent: nothing invents output on its - // screen, and the bytes are dropped rather than transcribed. - .write => |w| if (v.pty_write) |f| f(p.host.ctx, w.pane, w.bytes.slice()), - .resize_pty => |r| if (v.pty_resize) |f| f(p.host.ctx, r.pane, r.cols, r.rows), - // A signal for a pane that closed, its slot retaken in the same - // step, would reach another pane's child. - .signal_pty => |s| if (if (p.panes[s.pane]) |pane| pane.serial != s.serial else true) {} else if (v.pty_signal) |f| f(p.host.ctx, s.pane, s.sig), - .close_pty => |c| if (v.close_pty) |f| f(p.host.ctx, c.pane), - .open_link => |u| if (v.open_link) |f| - f(p.host.ctx, u.slice()) - else - p.fallback.setLink(u.slice()), - .save_file => |sf| { - const pane = p.panes[sf.pane] orelse return; - const f = if (pane.file) |*file| file else return; - const was = f.saved_revision; - f.saved_revision = f.revision; - // A save the host could not do (saveFailed) is its err - // record alone, not a `save`, and changes nothing: a clean - // file stays clean. - const saved_pane = p.writeChecked(sf.pane, pane.serial, f.path, f.content, was) orelse return; - const saved = if (saved_pane.file) |*file| file else return; - // Edited while it was written: what is on disk is not this. - if (saved.saved_revision != saved.revision) return; - saved.disk_gone = false; - ctlfs.events.noteLog(p, .save, saved_pane); - // On disk now, a new file too: Recent has it, open. - if (saved.output == null and recentKeeps(saved.path)) p.recent.opened(p.recentGpa(), saved.path); - if (!saved.watch_after_save) return; - saved.watch_after_save = false; - if (filesystem.localPath(saved.path) != null) - p.emit(.{ .watch = .{ .pane = sf.pane, .on = true } }); - }, - .save_text => |st| { - const pane = p.panes[st.pane] orelse return; - if (pane.serial != st.serial) return; // a recycled slot: not ours - if (pane.file) |*f| { - // Failed, it changes nothing: not the name, not dirty. - const after = p.writeChecked(st.pane, st.serial, st.path.slice(), f.content, f.saved_revision) orelse return; - if (after.file == null) return; - if (st.promote) p.promoteSaved(st.pane, st.path.slice()) else ctlfs.events.noteLogAs(p, .save, after, st.path.slice()); - return; - } - if (!pane.isTerminal()) return; - const text = panes.terminal.screenTextAlloc(pane, p.gpa) catch return; - defer p.gpa.free(text); - if (p.writeChecked(st.pane, st.serial, st.path.slice(), text, 0)) |still| - ctlfs.events.noteLogAs(p, .save, still, st.path.slice()); - }, - .write_dump => { - const out = p.dump_out orelse return; - if (v.write_dump) |f| { - f(p.host.ctx, out); - } else { - _ = p.fallback.writeFile(host_io.Fallback.dump_path, out); - p.setLastDump(host_io.Fallback.dump_path); - } - }, - .set_clipboard => { - const text = p.registers.text(p.gpa, '+') orelse ""; - if (v.set_clipboard) |f| f(p.host.ctx, text) else p.fallback.setClipboard(text); - }, - // No desktop to ask: answer from the in-process clipboard at once, - // which is the same shape as a host answering later. - .read_clipboard => if (v.read_clipboard) |f| - f(p.host.ctx) - else - p.update(.{ .paste = p.fallback.clipboard.items }), - .lsp => |q| if (v.lsp) |f| - f(p.host.ctx, .{ .id = q.id, .kind = q.kind, .pane = q.pane, .offset = q.offset, .arg = q.arg.slice() }) - else - p.update(.{ .lsp_resp = .{ .id = q.id, .rows = "" } }), - .pipe => |q| if (v.pipe) |f| - f(p.host.ctx, q.id) - else - p.update(.{ .pipe_resp = .{ .id = q.id, .success = false, .outputs = &.{} } }), - // No workers here (a test, a board): it runs on the loop. - .search => |q| if (v.search) |f| f(p.host.ctx, q.gen) else Stream.runHere(p, q.gen), - // No windows here (a test, the tty): it stays. - .hand_over => |h| if (v.hand_over) |f| { - if (p.handover.bytes) |bytes| f(p.host.ctx, h.seq, bytes); - } else p.update(.{ .handed = .{ .seq = h.seq, .failure = "no other windows here" } }), - .edit_write => { - // Each write takes the bytes `w` took when it ran: the text - // as it was before the Edit's changes. - var writes = p.pipe.writes; - p.pipe.writes = .empty; - defer { - for (writes.items) |*w| w.deinit(p.gpa); - writes.deinit(p.gpa); - } - for (writes.items) |w| { - const was = if (p.panes[w.pane]) |pane| (if (pane.file) |f| f.saved_revision else 0) else 0; - // Failed, it changes nothing, as save_text's does not. - const pane = p.writeChecked(w.pane, w.serial, w.path, w.bytes, was) orelse continue; - const f = if (pane.file) |*file| file else continue; - if (w.promote) { - p.promoteSaved(w.pane, w.path); - } else if (w.clean != null and w.clean.? == f.revision) { - f.saved_revision = f.revision; - f.disk_gone = false; - ctlfs.events.noteLog(p, .save, pane); - } else ctlfs.events.noteLogAs(p, .save, pane, w.path); - } - }, - .watch => |w| if (v.watch_file) |f| { - // What a watch is about: a real file, or a PDF. - const path: []const u8 = if (p.panes[w.pane]) |pane| (if (pane.file) |file| (if (file.output == null) file.path else "") else pane.pdfPath() orelse "") else ""; - f(p.host.ctx, w.pane, path, w.on, w.mode); - } else { - p.fallback.watched[w.pane] = w.on; - }, - .theme_file => |t| if (v.watch_theme) |f| f(p.host.ctx, t.generation, t.on), - .dump_themes => |d| if (v.dump_themes) |f| f(p.host.ctx, d.pane), - .detach => |d| if (v.detach) |f| - f(p.host.ctx) - else - p.reportError(d.pane, "detach", error.NotAttached), - // the loop's own condition; a host tears down after its own loop - .quit => p.quit = true, - } - } - pub fn pump(p: *Pardes, host: Host) !void { p.host = host; const taped = tape.enter(p, .pump); @@ -7782,30 +7175,6 @@ test "jump history terminal rectangle follows output and clears on reflow" { try std.testing.expectEqual(.none, pane.sel[0].state); } -test "a Save the host could not do logs no save record" { - const th = @import("ninep/testing.zig"); - const p = try th.withFile(std.testing.allocator, "x\n"); - defer p.deinit(); - const Failing = struct { - core: *Pardes, - const vtable: Host.VTable = .{ .write_file = write }; - fn write(ctx: ?*anyopaque, pane: u8, path: []const u8, _: []const u8) void { - const f: *@This() = @ptrCast(@alignCast(ctx.?)); - f.core.saveFailed(pane, path, error.AccessDenied); - } - }; - var host: Failing = .{ .core = p }; - p.host = .{ .ctx = &host, .vtable = &Failing.vtable }; - _ = th.wr(p, ctlfs.Node.of(p.panes[0].?.serial, .body), "more\n"); - p.perform(.{ .save_file = .{ .pane = 0 } }); - try std.testing.expect(!th.logHas(p, "\nsave ")); - try std.testing.expect(p.panes[0].?.file.?.saved_revision != p.panes[0].?.file.?.revision); - // With the host's write done, it is logged. - p.host = .{}; - p.perform(.{ .save_file = .{ .pane = 0 } }); - try std.testing.expect(th.logHas(p, "\nsave ")); -} - test "tagline bands center in their cells and Tagbottom faces the window edge" { const cell_h: u32 = 20; const tagline_h: u32 = 16; |
