summaryrefslogtreecommitdiff
path: root/src/recent.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/recent.zig')
-rw-r--r--src/recent.zig252
1 files changed, 252 insertions, 0 deletions
diff --git a/src/recent.zig b/src/recent.zig
new file mode 100644
index 00000000..2e3aabde
--- /dev/null
+++ b/src/recent.zig
@@ -0,0 +1,252 @@
+//! The files opened lately, most recent first, those since closed too, as
+//! `Recent` lists them and a jump to a closed pane reopens them: a path
+//! and where the dot was when it closed. Kept across sessions, and shared
+//! by every window, in the store (Store.zig) when the host gives one: each
+//! change is a record there, and the records other windows wrote are
+//! `note`d here as they are read. acme has nothing like it (its dump and
+//! Load are the nearest): a file closed by accident, its path forgotten,
+//! is found here again.
+
+const std = @import("std");
+
+/// At most this many files are remembered, the oldest dropped first.
+pub const cap = 200;
+
+pub const Entry = struct {
+ path: []u8,
+ /// Where its dot was when it last closed (1-based; 0 none).
+ line: u32 = 0,
+ col: u32 = 0,
+ /// The selection's other end then (its anchor), 0 when there was none.
+ aline: u32 = 0,
+ acol: u32 = 0,
+ /// Open in a pane now (opened, not closed since): never the one the
+ /// cap drops. ponytail: a pane renamed away leaves its old path marked
+ /// open until the session ends; kept rather than tracked by pane.
+ open: bool = false,
+ /// Changed here since the store last heard of it: written out as a
+ /// record at the end of the step (Store.flush).
+ changed: bool = false,
+};
+
+pub const List = struct {
+ entries: std.ArrayList(Entry) = .empty,
+ /// Some entry is `changed`.
+ dirty: bool = false,
+
+ pub fn deinit(l: *List, gpa: std.mem.Allocator) void {
+ for (l.entries.items) |e| gpa.free(e.path);
+ l.entries.deinit(gpa);
+ }
+
+ fn find(l: *const List, path: []const u8) ?usize {
+ for (l.entries.items, 0..) |e, i| if (std.mem.eql(u8, e.path, path)) return i;
+ return null;
+ }
+
+ /// `path` opened: first in the list, once, keeping the dot it closed at.
+ pub fn opened(l: *List, gpa: std.mem.Allocator, path: []const u8) void {
+ if (path.len == 0) return;
+ var entry: Entry = if (l.find(path)) |i| l.entries.orderedRemove(i) else .{
+ .path = gpa.dupe(u8, path) catch return,
+ };
+ entry.open = true;
+ entry.changed = true;
+ l.dropOldest(gpa);
+ l.entries.insert(gpa, 0, entry) catch {
+ gpa.free(entry.path);
+ entry = undefined;
+ return;
+ };
+ l.dirty = true;
+ }
+
+ /// `path` closed with its dot at `line`:`col`: where a reopen lands.
+ /// Its place in the list is its opening's.
+ pub fn closed(l: *List, gpa: std.mem.Allocator, path: []const u8, line: u32, col: u32) void {
+ l.closedSel(gpa, path, line, col, 0, 0);
+ }
+
+ /// `closed`, with the selection's anchor too (0 0 for none).
+ pub fn closedSel(l: *List, gpa: std.mem.Allocator, path: []const u8, line: u32, col: u32, aline: u32, acol: u32) void {
+ const i = l.find(path) orelse found: {
+ l.opened(gpa, path);
+ // Out of memory for it: nothing to note the dot on.
+ break :found l.find(path) orelse return;
+ };
+ l.entries.items[i].line = line;
+ l.entries.items[i].col = col;
+ l.entries.items[i].aline = aline;
+ l.entries.items[i].acol = acol;
+ l.entries.items[i].open = false;
+ l.entries.items[i].changed = true;
+ l.dirty = true;
+ }
+
+ /// Full: the oldest closed file goes, to make room for one more; an
+ /// open one never does.
+ fn dropOldest(l: *List, gpa: std.mem.Allocator) void {
+ if (l.entries.items.len < cap) return;
+ var i = l.entries.items.len;
+ while (i > 0) : (i -= 1) if (!l.entries.items[i - 1].open) {
+ gpa.free(l.entries.orderedRemove(i - 1).path);
+ return;
+ };
+ }
+
+ /// A record read from the store (another window's, or this one's read
+ /// again): `path` was opened or closed there last, at that place. It
+ /// goes first, with that place; whether it is open HERE stays as it
+ /// was, and nothing is changed for the store to hear again.
+ pub fn note(l: *List, gpa: std.mem.Allocator, path: []const u8, line: u32, col: u32, aline: u32, acol: u32) void {
+ if (path.len == 0) return;
+ var entry: Entry = if (l.find(path)) |i| l.entries.orderedRemove(i) else blk: {
+ l.dropOldest(gpa);
+ break :blk .{ .path = gpa.dupe(u8, path) catch return };
+ };
+ entry.line = line;
+ entry.col = col;
+ entry.aline = aline;
+ entry.acol = acol;
+ l.entries.insert(gpa, 0, entry) catch {
+ gpa.free(entry.path);
+ entry = undefined;
+ };
+ }
+
+ /// This window's changes first again, in their order, after others'
+ /// records were noted over them: they are written after those, so
+ /// that is where every window's fold puts them.
+ pub fn changedFirst(l: *List) void {
+ var w: usize = 0;
+ for (0..l.entries.items.len) |i| if (l.entries.items[i].changed) {
+ const e = l.entries.items[i];
+ std.mem.copyBackwards(Entry, l.entries.items[w + 1 .. i + 1], l.entries.items[w..i]);
+ l.entries.items[w] = e;
+ w += 1;
+ };
+ }
+
+ /// A copy, for the session a Restore makes: its files closed until it
+ /// opens them again. Out of memory, what was copied so far.
+ pub fn clone(l: *const List, gpa: std.mem.Allocator) List {
+ var copy: List = .{ .dirty = l.dirty };
+ for (l.entries.items) |e| {
+ const path = gpa.dupe(u8, e.path) catch break;
+ var kept = e;
+ kept.path = path;
+ kept.open = false;
+ copy.entries.append(gpa, kept) catch {
+ gpa.free(path);
+ break;
+ };
+ }
+ return copy;
+ }
+
+ pub fn get(l: *const List, path: []const u8) ?Entry {
+ return l.entries.items[l.find(path) orelse return null];
+ }
+
+ /// One line a file, `<line> <col> <aline> <acol> <path>`, most recent
+ /// first: the old `recent` file, and a store record's body, a line.
+ pub fn write(l: *const List, w: *std.Io.Writer) !void {
+ for (l.entries.items) |e| try writeEntry(e, w);
+ }
+
+ pub fn writeEntry(e: Entry, w: *std.Io.Writer) !void {
+ // A name with a newline in it would read back as two lines: not kept.
+ if (std.mem.indexOfScalar(u8, e.path, '\n') == null)
+ try w.print("{d} {d} {d} {d} {s}\n", .{ e.line, e.col, e.aline, e.acol, e.path });
+ }
+
+ /// The lines `write` wrote (the old `recent` file), each changed for
+ /// the store to hear of; a line that is not one is passed over.
+ pub fn read(l: *List, gpa: std.mem.Allocator, bytes: []const u8) void {
+ var lines = std.mem.splitScalar(u8, bytes, '\n');
+ while (lines.next()) |line| {
+ if (l.entries.items.len >= cap) break;
+ // Numbers, then the path (which starts with `/`): two of them in
+ // a list written before the anchor was kept, four since.
+ var nums: [4]u32 = @splat(0);
+ var n: usize = 0;
+ var rest = line;
+ while (rest.len > 0 and rest[0] != '/' and n < nums.len) : (n += 1) {
+ const sp = std.mem.indexOfScalar(u8, rest, ' ') orelse break;
+ nums[n] = std.fmt.parseInt(u32, rest[0..sp], 10) catch break;
+ rest = rest[sp + 1 ..];
+ }
+ if (n != 2 and n != 4) continue;
+ const path = rest;
+ if (path.len == 0 or path[0] != '/' or l.find(path) != null) continue;
+ const owned = gpa.dupe(u8, path) catch return;
+ l.entries.append(gpa, .{ .path = owned, .line = nums[0], .col = nums[1], .aline = nums[2], .acol = nums[3], .changed = true }) catch {
+ gpa.free(owned);
+ return;
+ };
+ l.dirty = true;
+ }
+ }
+
+ /// One record's body read back: `<line> <col> <aline> <acol> <path>`.
+ pub fn parseLine(line: []const u8) ?struct { nums: [4]u32, path: []const u8 } {
+ var nums: [4]u32 = @splat(0);
+ var rest = line;
+ for (&nums) |*n| {
+ const sp = std.mem.indexOfScalar(u8, rest, ' ') orelse return null;
+ n.* = std.fmt.parseInt(u32, rest[0..sp], 10) catch return null;
+ rest = rest[sp + 1 ..];
+ }
+ if (rest.len == 0 or rest[0] != '/') return null;
+ return .{ .nums = nums, .path = rest };
+ }
+};
+
+test "the list keeps a path once, most recent first, its dot from closing, capped" {
+ const gpa = std.testing.allocator;
+ var l: List = .{};
+ defer l.deinit(gpa);
+ l.opened(gpa, "/a");
+ l.opened(gpa, "/b");
+ l.closed(gpa, "/a", 7, 3);
+ l.opened(gpa, "/a");
+ try std.testing.expectEqualStrings("/a", l.entries.items[0].path);
+ try std.testing.expectEqual(@as(usize, 2), l.entries.items.len);
+ try std.testing.expectEqual(@as(u32, 7), l.get("/a").?.line);
+ var buf: [256]u8 = undefined;
+ var w = std.Io.Writer.fixed(&buf);
+ try l.write(&w);
+ try std.testing.expectEqualStrings("7 3 0 0 /a\n0 0 0 0 /b\n", w.buffered());
+ var again: List = .{};
+ defer again.deinit(gpa);
+ again.read(gpa, w.buffered());
+ again.read(gpa, "junk\n");
+ // A list written before the anchor was kept still reads.
+ again.read(gpa, "4 2 /old\n");
+ try std.testing.expectEqual(@as(u32, 4), again.get("/old").?.line);
+ try std.testing.expectEqual(@as(usize, 3), again.entries.items.len);
+ for (0..cap + 5) |i| {
+ var name: [16]u8 = undefined;
+ const path = std.fmt.bufPrint(&name, "/f{d}", .{i}) catch unreachable;
+ l.opened(gpa, path);
+ l.closed(gpa, path, 1, 1);
+ }
+ try std.testing.expectEqual(@as(usize, cap), l.entries.items.len);
+}
+
+test "the cap drops the oldest closed file, never an open one" {
+ const gpa = std.testing.allocator;
+ var l: List = .{};
+ defer l.deinit(gpa);
+ var name: [16]u8 = undefined;
+ // The oldest is open; the next is closed.
+ l.opened(gpa, "/open");
+ l.opened(gpa, "/shut");
+ l.closed(gpa, "/shut", 1, 1);
+ for (2..cap) |i| l.opened(gpa, std.fmt.bufPrint(&name, "/f{d}", .{i}) catch unreachable);
+ try std.testing.expectEqual(@as(usize, cap), l.entries.items.len);
+ l.opened(gpa, "/new");
+ try std.testing.expectEqual(@as(usize, cap), l.entries.items.len);
+ try std.testing.expect(l.get("/open") != null);
+ try std.testing.expect(l.get("/shut") == null);
+}