1 files changed, 44 insertions, 2 deletions

diff --git a/src/ninep/pane.zig b/src/ninep/pane.zig
index 99acf24b..13381066 100644
--- a/src/ninep/pane.zig
+++ b/src/ninep/pane.zig
@@ -47,6 +47,10 @@ pub const State = struct {
     event_reader: bool = false,
     events: events.Queue = .{},
     nomark: bool = false,
+    /// The revision a truncation of `data`, `xdata` or `body` left: the
+    /// write that follows it at once joins its undo step, so a shell's
+    /// `printf x > data` is one step, as acme's replace is.
+    joined: ?u32 = null,
     noscroll: bool = false,
     tag_snap: std.ArrayList(u8) = .empty,
     /// An open reads pty/data, so output queues for it; a second is refused.
@@ -59,6 +63,9 @@ pub const State = struct {
     lock: ?u32 = null,
     /// The host started a shell it could not teach to mark its prompts.
     unmarked: bool = false,
+    /// The pty's size as pty/ctl's winsize last set it, until the pane's own
+    /// grid resizes and gives the pty its size again.
+    winsize: ?[2]u16 = null,
     /// Installed during this update; /log hears about it once the update ends
     /// and the pane has its file, name and place.
     unannounced: bool = false,
@@ -190,7 +197,9 @@ pub fn spliceBody(p: *Pardes, pane: *Pane, q0: usize, q1: usize, bytes: []const
     @memcpy(new[0..lo], f.content[0..lo]);
     @memcpy(new[lo..][0..take], bytes[0..take]);
     @memcpy(new[lo + take ..], f.content[hi..]);
-    if (!pane.fs.nomark) panes.File.pushUndo(p, pane);
+    const join = pane.fs.joined == f.revision;
+    pane.fs.joined = null;
+    if (!pane.fs.nomark and !join) panes.File.pushUndo(p, pane);
     panes.File.setContent(p, f, new);
     return take;
 }
@@ -516,9 +525,12 @@ fn writeFlag(p: *Pardes, req: Req, pane: *Pane, file: PaneFile) Reply {
             const f = fileOf(pane) orelse return Reply.fail(req.tag, E.INVAL);
             f.saved_revision = if (on) f.revision -% 1 else f.revision;
         },
+        // acme's nomark joins the writes after it into one undo step. The
+        // step starts here: the text as it is now is what Undo brings back,
+        // and turning mark on again only ends it.
         .mark => {
+            if (!on and !pf.nomark) panes.File.pushUndo(p, pane);
             pf.nomark = !on;
-            if (on) panes.File.pushUndo(p, pane);
         },
         .scroll => pf.noscroll = !on,
         else => unreachable,
@@ -611,6 +623,7 @@ pub fn truncate(p: *Pardes, pane: *Pane, file: PaneFile) tree.Status {
     switch (file) {
         .body => if (fileOf(pane) != null) {
             _ = spliceBody(p, pane, 0, bodyOf(pane).len, "") orelse return .err;
+            pf.joined = fileOf(pane).?.revision;
             pf.addr = .{};
             setDot(pane, .{});
         },
@@ -620,6 +633,7 @@ pub fn truncate(p: *Pardes, pane: *Pane, file: PaneFile) tree.Status {
             const q1 = @max(q0, pf.addr.q1);
             const before = dotOf(pane);
             _ = spliceBody(p, pane, q0, q1, "") orelse return .err;
+            pf.joined = fileOf(pane).?.revision;
             setDot(pane, .{ .q0 = shiftOne(before.q0, q0, q1 - q0, 0), .q1 = shiftOne(before.q1, q0, q1 - q0, 0) });
             pf.addr = .{ .q0 = q0, .q1 = q0 };
         },
@@ -906,6 +920,34 @@ test "the flag files read and write the state acme kept behind ctl verbs" {
     try testing.expectEqual(E.INVAL, wr(term, Node.of(serialOf(term), .dirty), "1").errno());
 }
 
+test "a replace through data, truncate then write, is one undo step" {
+    const p = try withFile(testing.allocator, "one two\n");
+    defer p.deinit();
+    const serial = serialOf(p);
+    _ = wr(p, Node.of(serial, .addr), "/two/");
+    _ = call(p, .{ .tag = 1, .op = .setattr, .node = Node.of(serial, .data), .truncate = true });
+    try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .data), "2").reply.status);
+    try testing.expectEqualStrings("one 2\n", rd(p, Node.of(serial, .body), 0, 64).bytes);
+    try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .ctl), "Undo").reply.status);
+    try testing.expectEqualStrings("one two\n", rd(p, Node.of(serial, .body), 0, 64).bytes);
+}
+
+test "writes under mark 0 are one undo step, even with no history before them" {
+    const p = try withFile(testing.allocator, "one\n");
+    defer p.deinit();
+    const serial = serialOf(p);
+    const body = Node.of(serial, .body);
+    try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .mark), "0").reply.status);
+    _ = wr(p, body, "two\n");
+    _ = wr(p, body, "three\n");
+    try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .mark), "1").reply.status);
+    try testing.expectEqualStrings("one\ntwo\nthree\n", rd(p, body, 0, 64).bytes);
+    try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .ctl), "Undo").reply.status);
+    try testing.expectEqualStrings("one\n", rd(p, body, 0, 64).bytes);
+    try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .ctl), "Redo").reply.status);
+    try testing.expectEqualStrings("one\ntwo\nthree\n", rd(p, body, 0, 64).bytes);
+}
+
 test "truncating the tag clears its editable tail" {
     const p = try withFile(testing.allocator, "x\n");
     defer p.deinit();