summaryrefslogtreecommitdiff
path: root/src/File.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/File.zig')
-rw-r--r--src/File.zig46
1 files changed, 23 insertions, 23 deletions
diff --git a/src/File.zig b/src/File.zig
index 82661c6d..90711c9a 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -1245,20 +1245,20 @@ pub fn restoreSnap(pane: *Pane, f: *State, snap: Text.Place) void {
/// An undo step's edge, made before an edit (Text.Journal.mark): the edits
/// after it are one step back to the pane's place now.
-pub fn pushUndo(p: *Pardes, pane: *Pane) void {
+pub fn pushUndo(p: *Pardes, pane: *Pane) error{OutOfMemory}!void {
const f = if (pane.file) |*file| file else return;
- f.history.journal.mark(p.gpa, f.content, placeOf(pane, f));
+ try f.history.journal.mark(p.gpa, f.content, placeOf(pane, f));
}
/// Undo (back) or redo one step: its edits turned round in the text, and the
/// place and name it began at (or, redone, was undone from) back.
-pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) void {
+pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) error{OutOfMemory}!void {
const f = if (pane.file) |*file| file else return;
const j = &f.history.journal;
if (if (back) j.done == 0 else j.done == j.steps.items.len) return;
const at = if (back) j.done - 1 else j.done;
const now = placeOf(pane, f);
- if (!turn(p, f, at, back)) return;
+ if (!turn(p, f, at, back)) return error.OutOfMemory;
const s = &j.steps.items[at];
if (back) {
s.after = now;
@@ -1439,8 +1439,8 @@ pub fn changed(p: *Pardes, id: u8, bytes: []const u8) void {
// Logged as the dirty case is, with what became of it.
var rec: [32]u8 = undefined;
pardes.ctlfs.events.notePath(p, "changed", std.fmt.bufPrint(&rec, "{d} reloaded", .{pane.serial}) catch unreachable); // a u32 fits 32
+ pushUndo(p, pane) catch |err| return p.reportError(id, "reload", err);
const new = p.gpa.dupe(u8, bytes) catch |err| return p.reportError(id, "reload", err);
- pushUndo(p, pane);
setContent(p, f, new);
f.saved_revision = f.revision;
restoreSnap(pane, f, .{ .cur_row = pane.body.cur_row, .cur_col = pane.body.cur_col, .vsel = pane.body.vsel });
@@ -2515,7 +2515,7 @@ test "undo and redo walk back and forth through every step of random edits, join
for (0..80) |_| {
const was = j.done;
try texts.append(gpa, try gpa.dupe(u8, f.content));
- pushUndo(p, pane);
+ try pushUndo(p, pane);
// A step that changed nothing goes on, its edge where it was.
if (j.done == was) gpa.free(texts.pop().?);
// Up to six edits: most where the last ended, as typing goes on.
@@ -2535,11 +2535,11 @@ test "undo and redo walk back and forth through every step of random edits, join
var k = texts.items.len - 1;
while (k > 0) {
k -= 1;
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts.items[k], f.content);
}
for (texts.items[1..]) |t| {
- undoStep(p, pane, false);
+ try undoStep(p, pane, false);
try std.testing.expectEqualStrings(t, f.content);
}
}
@@ -2559,42 +2559,42 @@ test "a text replaced whole keeps its old buffer for its undo, swapped back and
defer for (texts) |t| gpa.free(t);
setContent(p, f, try gpa.dupe(u8, texts[0]));
const first = f.content.ptr;
- pushUndo(p, pane);
+ try pushUndo(p, pane);
setContent(p, f, try gpa.dupe(u8, texts[1]));
// The old buffer itself, kept: no byte of it copied, none counted.
const e = j.entries.items[j.entries.items.len - 1];
try std.testing.expect(e.swap and e.removed.ptr == first);
try std.testing.expectEqual(@as(usize, @sizeOf(Text.Entry)), j.bytes);
const second = f.content.ptr;
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expect(f.content.ptr == first);
try std.testing.expectEqualStrings(texts[0], f.content);
- undoStep(p, pane, false);
+ try undoStep(p, pane, false);
try std.testing.expect(f.content.ptr == second);
try std.testing.expectEqualStrings(texts[1], f.content);
// A third and a fourth: two swaps kept, the steps before them gone, said.
for (texts[2..4]) |t| {
- pushUndo(p, pane);
+ try pushUndo(p, pane);
setContent(p, f, try gpa.dupe(u8, t));
}
try std.testing.expectEqual(@as(usize, 2), j.done);
try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "undo keeps the last two texts replaced whole") != null);
- undoStep(p, pane, true);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
// A body emptied and written again on one open (a shell's >): its undo
// swaps the old text back and folds the step into one swap the other way.
- pushUndo(p, pane);
+ try pushUndo(p, pane);
try std.testing.expect(replace(p, f, 0, f.content.len, ""));
try std.testing.expect(replace(p, f, 0, 0, "fresh\n"));
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
try std.testing.expectEqual(@as(usize, 1), j.steps.items[j.done].n);
- undoStep(p, pane, false);
+ try undoStep(p, pane, false);
try std.testing.expectEqualStrings("fresh\n", f.content);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqualStrings(texts[1], f.content);
}
@@ -2614,10 +2614,10 @@ test "undo keeps its steps within a byte bound, the newest always" {
defer gpa.free(text);
for (0..8) |i| {
@memset(text, 'a' + @as(u8, @intCast(i)));
- pushUndo(p, pane);
+ try pushUndo(p, pane);
try std.testing.expect(replace(p, f, step / 2, step, text));
}
- pushUndo(p, pane);
+ try pushUndo(p, pane);
const j = &f.history.journal;
try std.testing.expect(j.done > 0 and j.done < 8);
try std.testing.expect(j.bytes <= limits.undo_bytes + step + @sizeOf(Text.Entry));
@@ -2627,11 +2627,11 @@ test "undo keeps its steps within a byte bound, the newest always" {
sum += Text.Journal.held(e);
}
try std.testing.expectEqual(sum, j.bytes);
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expectEqual(text[0], f.content[step / 2]);
// Back as far as the bound kept: each step's middle whole again.
while (j.done > 0) {
- undoStep(p, pane, true);
+ try undoStep(p, pane, true);
try std.testing.expect(std.mem.allEqual(u8, f.content[step / 2 ..][0..step], f.content[step / 2]));
}
}