╭ Undo.zig ─────────────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯
🬐 🬠 🬞🬂🬏 🬟 🬑 🬟 🬑 ╭9b19321f..╮ 9b19321f.. see-em: 🬋🬋🬋 🬋🬋🬋 🬋 🬋 │files │ commits refs discuss issues new login 🬐 🬠 🬐 🬠 🬑 🬟 🬰 ╰──────────╯ (586) user
╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │http│ ssh │ │ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯
.. Attachment.zig Comment.zig Commits.zig Diff.zig Discussions.zig Events.zig Files.zig Header.zig Issues.zig Patches.zig Refs.zig ╭─────────────────────────────────╮ │Undo.zig │ ╰─────────────────────────────────╯
1 const std = @import("std"); 2 const builtin = @import("builtin"); 3 const ui = @import("../../ui.zig"); 4 const evt = @import("../../event.zig"); 5 const pch = @import("../../patch.zig"); 6 const push = @import("../../push.zig"); 7 const fork = @import("../../fork.zig"); 8 const inp = @import("../input.zig"); 9 const xit = @import("xit"); 10 const rp = xit.repo; 11 const hash = xit.hash; 12 const wgt = xit.xitui.widget; 13 const layout = xit.xitui.layout; 14 const Key = xit.xitui.input.Key; 15 const Grid = xit.xitui.grid.Grid; 16 const Focus = xit.xitui.focus.Focus; 17 const Self = @This(); 18 19 pub const page_size = 20; 20 21 // the action kind xit writes when a transaction is undone 22 const undo_action_kind = @tagName(xit.undo.ActionKind.undo); 23 24 // stands in for the description, as a focusable box that may link somewhere 25 pub const DetailButton = struct { 26 label: []const u8, 27 text: []const u8, 28 link: ?[]const u8 = null, 29 }; 30 31 pub const Item = struct { 32 index: u64, 33 action: []const u8, 34 description: []const u8, 35 timestamp: []const u8, 36 link: []const u8, 37 form: []const u8, 38 buttons: []const DetailButton = &.{}, 39 undone: bool = false, 40 }; 41 42 identity: []const u8, 43 count: u64 = 0, 44 items: []const Item = &.{}, 45 next: ?u64 = null, 46 failure: ?[]const u8 = null, 47 can_undo: bool = false, 48 // the clear-history confirmation stands in for the list 49 clear: bool = false, 50 51 pub fn init(comptime opts: rp.RepoOpts(.xit), arena: *std.heap.ArenaAllocator, repo: *rp.Repo(.xit, opts), haxy_moment: ?evt.AdminDB.HashMap(.read_only), identity: []const u8, selected: ?u64) !Self { 52 const aa = arena.allocator(); 53 const DB = rp.Repo(.xit, opts).DB; 54 const history = try DB.ArrayList(.read_only).init(repo.core.db.rootCursor().readOnly()); 55 const count = try history.count(); 56 if (selected) |index| if (index >= count) return error.NotFound; 57 var items: std.ArrayList(Item) = .empty; 58 var remaining = if (selected) |index| index + 1 else count; 59 var buffer: [opts.max_read_size]u8 = undefined; 60 61 // an undo above the page discards transactions on it, so the walk starts 62 // at the newest transaction. an undo discards everything from the one it 63 // restored to down to the row below itself, so walking down, that row is 64 // all the walk has to carry. the rows it discarded are skipped, since a 65 // discarded undo discards nothing itself 66 var undone_from: ?u64 = null; 67 var scanned = count; 68 while (scanned > remaining) { 69 scanned -= 1; 70 if (undone_from) |from| if (scanned >= from) { 71 scanned = from; 72 continue; 73 }; 74 const record = try xit.undo.read(opts, try repo.core.momentAt(scanned), &buffer); 75 if (try undoneFrom(arena, record)) |from| undone_from = from; 76 } 77 78 while (remaining > 0 and items.items.len < page_size) { 79 remaining -= 1; 80 const moment = try repo.core.momentAt(remaining); 81 const record = try xit.undo.read(opts, moment, &buffer); 82 const row_undone = if (undone_from) |from| remaining >= from else false; 83 if (!row_undone) { 84 if (try undoneFrom(arena, record)) |from| undone_from = from; 85 } 86 const detail = if (record) |value| try eventDetail(opts, arena, &repo.core, haxy_moment, identity, value, moment, remaining) else null; 87 const shown = detail orelse Detail{ 88 .action = if (record) |value| try aa.dupe(u8, value.action_kind) else "unknown", 89 .description = try formatRecord(opts, arena, &repo.core, record), 90 }; 91 const route = ui.RoutablePage.repoUndoRoute(identity, remaining) orelse return error.RouteTooLong; 92 const url = try route.toUrl(arena); 93 try items.append(aa, .{ 94 .index = remaining, 95 .action = shown.action, 96 .description = shown.description, 97 .buttons = shown.buttons, 98 .timestamp = if (record) |value| try formatTimestamp(aa, value.timestamp) else "timestamp unavailable", 99 .link = try std.fmt.allocPrint(aa, "ai:{s}", .{url}), 100 .form = try std.fmt.allocPrint(aa, "form:{s}/undo", .{url}), 101 .undone = row_undone, 102 }); 103 } 104 return .{ .identity = try aa.dupe(u8, identity), .count = count, .items = items.items, .next = if (remaining > 0) remaining - 1 else null }; 105 } 106 107 const Detail = struct { 108 action: []const u8, 109 description: []const u8, 110 buttons: []const DetailButton = &.{}, 111 }; 112 113 // every haxy event transaction shares one action, and the events it wrote are 114 // named by the moment's index rather than by the record 115 fn eventDetail( 116 comptime opts: rp.RepoOpts(.xit), 117 arena: *std.heap.ArenaAllocator, 118 core: *rp.Repo(.xit, opts).Core, 119 haxy_moment: ?evt.AdminDB.HashMap(.read_only), 120 identity: []const u8, 121 record: xit.undo.Record, 122 moment: rp.Repo(.xit, opts).DB.HashMap(.read_only), 123 history_index: u64, 124 ) !?Detail { 125 const aa = arena.allocator(); 126 if (std.mem.eql(u8, record.action_kind, undo_action_kind)) { 127 // an undo names a transaction earlier than itself, so the chain 128 // below always moves down the history and ends 129 const parsed = std.json.parseFromSlice(xit.undo.Undo, arena.child_allocator, record.payload, .{ .ignore_unknown_fields = true }) catch |err| switch (err) { 130 error.OutOfMemory => return err, 131 else => return null, 132 }; 133 defer parsed.deinit(); 134 const button = try undoneButton(opts, arena, core, haxy_moment, identity, parsed.value); 135 return .{ .action = undo_action_kind, .description = button.text, .buttons = try aa.dupe(DetailButton, &.{button}) }; 136 } 137 if (std.mem.eql(u8, record.action_kind, evt.merge_undo_action)) return .{ .action = "merge events", .description = "merged the events ref from a remote" }; 138 if (std.mem.eql(u8, record.action_kind, pch.merge_undo_action)) return .{ .action = "merge patch", .description = "merged a patch into its target branch" }; 139 if (std.mem.eql(u8, record.action_kind, fork.undo_action)) return .{ .action = "fork", .description = "created a fork to draft a patch in" }; 140 if (std.mem.eql(u8, record.action_kind, pch.mergeability_undo_action)) return .{ .action = "mergeability", .description = "rechecked whether the open patches still merge cleanly" }; 141 if (std.mem.eql(u8, record.action_kind, push.undo_action)) { 142 // a push consumes the events it carried in its own transaction 143 var buttons: std.ArrayList(DetailButton) = .empty; 144 if (try pushUser(arena, haxy_moment, record.payload)) |button| try buttons.append(aa, button); 145 const count = try momentEventCount(opts, core, moment, history_index) orelse 0; 146 if (count > 0) try buttons.append(aa, try eventsButton(arena, identity, history_index, count)); 147 try pushRefs(arena, identity, record.payload, &buttons); 148 return .{ .action = "push", .description = "received a push", .buttons = buttons.items }; 149 } 150 if (!std.mem.eql(u8, record.action_kind, evt.undo_action)) return null; 151 152 const count = try momentEventCount(opts, core, moment, history_index) orelse return .{ .action = "events", .description = "updated the event database" }; 153 // a transaction that consumed only merge commits indexed no events of its own 154 if (count == 0) return .{ .action = "events", .description = "merged the event history" }; 155 const buttons = try aa.dupe(DetailButton, &.{try eventsButton(arena, identity, history_index, count)}); 156 return .{ 157 .action = try std.fmt.allocPrint(aa, "events ({d})", .{count}), 158 .description = "updated the event database", 159 .buttons = buttons, 160 }; 161 } 162 163 // xit formats the transactions haxy has no name of its own for 164 fn formatRecord(comptime opts: rp.RepoOpts(.xit), arena: *std.heap.ArenaAllocator, core: *rp.Repo(.xit, opts).Core, record: ?xit.undo.Record) ![]const u8 { 165 const value = record orelse return "no undo record"; 166 var description: std.Io.Writer.Allocating = .init(arena.allocator()); 167 try xit.undo.format(opts, core, arena.child_allocator, value, &description.writer); 168 return description.written(); 169 } 170 171 // the transaction an undo restored, as a button that reads like its own row. 172 // the error set is explicit because this and `eventDetail` call each other 173 fn undoneButton( 174 comptime opts: rp.RepoOpts(.xit), 175 arena: *std.heap.ArenaAllocator, 176 core: *rp.Repo(.xit, opts).Core, 177 haxy_moment: ?evt.AdminDB.HashMap(.read_only), 178 identity: []const u8, 179 undo: xit.undo.Undo, 180 ) anyerror!DetailButton { 181 var buffer: [opts.max_read_size]u8 = undefined; 182 const target = try xit.undo.undoneTarget(opts, core, arena.child_allocator, undo, &buffer); 183 184 // the detail reads the event count out of the transaction's own moment 185 const moment = try core.momentAt(target.index); 186 const detail = if (target.record) |value| try eventDetail(opts, arena, core, haxy_moment, identity, value, moment, target.index) else null; 187 const route = ui.RoutablePage.repoUndoRoute(identity, target.index) orelse return error.RouteTooLong; 188 return .{ 189 .label = if (target.redo) " what was redone " else " what was undone ", 190 .text = if (detail) |value| value.action else try formatRecord(opts, arena, core, target.record), 191 .link = try std.fmt.allocPrint(arena.allocator(), "a:{s}", .{try route.toUrl(arena)}), 192 }; 193 } 194 195 // the page reads the transaction's own moment, so the url names the 196 // transaction rather than the state it produced 197 fn eventsButton(arena: *std.heap.ArenaAllocator, identity: []const u8, history_index: u64, count: u64) !DetailButton { 198 const aa = arena.allocator(); 199 const route = ui.RoutablePage.repoEventsRoute(identity, .active, null, "", history_index) orelse return error.RouteTooLong; 200 return .{ 201 .label = " events ", 202 .text = try std.fmt.allocPrint(aa, "view events ({d})", .{count}), 203 .link = try std.fmt.allocPrint(aa, "a:{s}", .{try route.toUrl(arena)}), 204 }; 205 } 206 207 // a button per ref the push moved, naming what it did to it: a changed branch 208 // links to the commits it added, anything still there to the ref itself 209 fn pushRefs(arena: *std.heap.ArenaAllocator, identity: []const u8, payload: []const u8, buttons: *std.ArrayList(DetailButton)) !void { 210 const head_prefix = "refs/heads/"; 211 const tag_prefix = "refs/tags/"; 212 const Payload = struct { 213 const Ref = struct { name: []const u8, old: []const u8, new: []const u8 }; 214 refs: []const Ref = &.{}, 215 }; 216 const parsed = std.json.parseFromSlice(Payload, arena.child_allocator, payload, .{ .ignore_unknown_fields = true }) catch |err| switch (err) { 217 error.OutOfMemory => return err, 218 else => return, 219 }; 220 defer parsed.deinit(); 221 222 const aa = arena.allocator(); 223 for (parsed.value.refs) |ref| { 224 // anything that is neither a head nor a tag is skipped 225 const head = std.mem.startsWith(u8, ref.name, head_prefix); 226 const prefix = if (head) head_prefix else tag_prefix; 227 if (!std.mem.startsWith(u8, ref.name, prefix)) continue; 228 const name = ref.name[prefix.len..]; 229 230 // a removed ref has nothing left to link to. a branch that was created 231 // has no range to show either: what it added is whatever the other 232 // refs did not already reach, which a base cannot express 233 const removed = ref.new.len == 0; 234 const created = ref.old.len == 0; 235 const route = if (removed) 236 null 237 else if (head and !created) 238 ui.RoutablePage.repoCommitsRoute(identity, .object, ref.new, 0, "", ref.old) orelse continue 239 else 240 ui.RoutablePage.repoFilesRoute(identity, if (head) .branch else .tag, try ui.urlEncodeRef(aa, name), "", 0) orelse continue; 241 242 const action = if (removed) "removed" else if (created) "created" else "changed"; 243 try buttons.append(aa, .{ 244 .label = try std.fmt.allocPrint(aa, " {s} {s} ", .{ if (head) "branch" else "tag", action }), 245 .text = try aa.dupe(u8, name), 246 .link = if (route) |value| try std.fmt.allocPrint(aa, "a:{s}", .{try value.toUrl(arena)}) else null, 247 }); 248 } 249 } 250 251 // the push record stores the email of the user whose key the server accepted. 252 // resolving it names them as they are now, and leaves the email when no user 253 // holds it, which is also what local mode sees with no admin db to read 254 fn pushUser(arena: *std.heap.ArenaAllocator, haxy_moment: ?evt.AdminDB.HashMap(.read_only), payload: []const u8) !?DetailButton { 255 const Payload = struct { author: ?struct { email: []const u8 } = null }; 256 const parsed = std.json.parseFromSlice(Payload, arena.child_allocator, payload, .{ .ignore_unknown_fields = true }) catch |err| switch (err) { 257 error.OutOfMemory => return err, 258 else => return null, 259 }; 260 defer parsed.deinit(); 261 const author = parsed.value.author orelse return null; 262 return switch (try ui.Author.initFromEmail(haxy_moment, arena, author.email)) { 263 .unknown => null, 264 .email => |email| .{ .label = " user ", .text = email }, 265 .user_name => |name| .{ .label = " user ", .text = name, .link = try ui.userLink(arena, name) }, 266 }; 267 } 268 269 // how many events the transaction wrote: zero when it consumed nothing, null 270 // when its state cannot be read at all 271 fn momentEventCount( 272 comptime opts: rp.RepoOpts(.xit), 273 core: *rp.Repo(.xit, opts).Core, 274 moment: rp.Repo(.xit, opts).DB.HashMap(.read_only), 275 history_index: u64, 276 ) !?u64 { 277 const DB = rp.Repo(.xit, opts).DB; 278 const haxy_moment = evt.currentMomentFromRepoMoment(opts.hash, moment) catch return null; 279 const index = try momentIndex(opts, haxy_moment) orelse return null; 280 281 // a transaction that consumed nothing inherits the moment it was cloned 282 // from, whose events belong to the transaction that wrote it 283 inherited: { 284 if (history_index == 0) break :inherited; 285 const previous = evt.currentMomentFromRepoMoment(opts.hash, try core.momentAt(history_index - 1)) catch break :inherited; 286 if (try momentIndex(opts, previous)) |value| if (value == index) return 0; 287 } 288 289 const ids = try evt.momentEventIds(DB, opts.hash, haxy_moment, index) orelse return 0; 290 return try ids.count(); 291 } 292 293 // the oldest transaction `record` discarded, or null when it is not an undo 294 fn undoneFrom(arena: *std.heap.ArenaAllocator, record: ?xit.undo.Record) !?u64 { 295 const value = record orelse return null; 296 if (!std.mem.eql(u8, value.action_kind, undo_action_kind)) return null; 297 const parsed = std.json.parseFromSlice(xit.undo.Undo, arena.child_allocator, value.payload, .{ .ignore_unknown_fields = true }) catch |err| switch (err) { 298 error.OutOfMemory => return err, 299 else => return null, 300 }; 301 defer parsed.deinit(); 302 return parsed.value.index; 303 } 304 305 // the moment's own position in the haxy history 306 fn momentIndex(comptime opts: rp.RepoOpts(.xit), haxy_moment: evt.EventDB(opts.hash).HashMap(.read_only)) !?u64 { 307 const cursor = try haxy_moment.getCursor(hash.hashInt(opts.hash, evt.moment_index_key)) orelse return null; 308 return try cursor.readUint(); 309 } 310 311 pub fn formatTimestamp(aa: std.mem.Allocator, timestamp: i64) ![]const u8 { 312 if (timestamp < 0) return aa.dupe(u8, "timestamp unavailable"); 313 const seconds = std.time.epoch.EpochSeconds{ .secs = @intCast(timestamp) }; 314 const year = seconds.getEpochDay().calculateYearDay(); 315 const month = year.calculateMonthDay(); 316 const day = seconds.getDaySeconds(); 317 const months = [_][]const u8{ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; 318 return std.fmt.allocPrint(aa, "{s} {d}, {d}, {d:0>2}:{d:0>2}:{d:0>2} UTC", .{ months[month.month.numeric() - 1], month.day_index + 1, year.year, day.getHoursIntoDay(), day.getMinutesIntoHour(), day.getSecondsIntoMinute() }); 319 } 320 321 pub fn execute(io: std.Io, allocator: std.mem.Allocator, source: ui.RepoSource, index: u64) !void { 322 if (source.repo_kind != .xit) return error.NotFound; 323 var any_repo = try rp.AnyRepo(.xit, .{}).open(io, allocator, source.localInitOpts()); 324 defer any_repo.deinit(io, allocator); 325 switch (any_repo) { 326 inline else => |*repo| try repo.undo(io, index), 327 } 328 } 329 330 // discard every earlier transaction by compacting the database. the patch 331 // revisions events point at are unreachable from the refs, so they are named 332 // as extra roots to survive the collection. 333 pub fn clearHistory(io: std.Io, allocator: std.mem.Allocator, source: ui.RepoSource) !void { 334 if (source.repo_kind != .xit) return error.NotFound; 335 var any_repo = try rp.AnyRepo(.xit, .{}).open(io, allocator, source.localInitOpts()); 336 defer any_repo.deinit(io, allocator); 337 switch (any_repo) { 338 inline else => |*repo| { 339 const opts = repo.self_repo_opts; 340 // a repo that has consumed no events has no revisions to protect 341 const roots = if (evt.currentMoment(opts, repo)) |moment| 342 try evt.PatchRev.gcRoots(rp.Repo(.xit, opts).DB, opts.hash, allocator, moment) 343 else |_| 344 &.{}; 345 defer allocator.free(roots); 346 _ = try repo.garbageCollect(io, allocator, .{ .extra_roots = roots }); 347 }, 348 } 349 } 350 351 // keep action failures on the current tab without rebuilding a stale route. 352 pub fn handleRequest(allocator: std.mem.Allocator, session: *ui.Session, target: ui.RoutablePage.RepoUndoRoute) void { 353 perform(allocator, session, target) catch |err| { 354 session.data.undo_failure = @errorName(err); 355 return; 356 }; 357 session.data.undo_failure = null; 358 } 359 360 // both terminal hosts resolve and authorize the request afresh before opening 361 // the repository; the web handler uses its matching http authorization path. 362 pub fn perform(allocator: std.mem.Allocator, session: *ui.Session, target: ui.RoutablePage.RepoUndoRoute) !void { 363 const identity = target.name.slice(); 364 const index = if (target.clear) null else target.index orelse return error.InvalidHistoryIndex; 365 const source = try authorizedSource(session, identity) orelse return error.Forbidden; 366 const io = session.io orelse return error.NotFound; 367 if (index) |value| try execute(io, allocator, source, value) else try clearHistory(io, allocator, source); 368 try session.navigate(ui.RoutablePage.repoUndoRoute(identity, null) orelse return error.RouteTooLong); 369 } 370 371 // the repo an owner may act on, or null when they may not 372 fn authorizedSource(session: *ui.Session, identity: []const u8) !?ui.RepoSource { 373 if (try session.authorize(identity, .owner) == null) return null; 374 if (session.local) |local| return local; 375 const admin_repo = session.admin_repo orelse return error.NotFound; 376 const moment = try evt.currentMoment(evt.admin_repo_opts, admin_repo); 377 const pair = ui.RoutablePage.RepoIdentity.parse(identity) orelse return error.NotFound; 378 const found = try evt.Repo.readByOwnerAndName(evt.AdminDB, evt.admin_repo_opts.hash, moment, session.page_arena, pair.owner, pair.name) orelse return error.NotFound; 379 const hex = std.fmt.bytesToHex(found.event_id, .lower); 380 return .{ .path = try std.fs.path.join(session.page_arena.allocator(), &.{ session.repos_dir orelse return error.NotFound, &hex }), .repo_kind = .xit }; 381 } 382 383 pub const View = struct { 384 box: wgt.Box(ui.Widget), 385 data: *const Self, 386 session: *ui.Session, 387 detailed_index: ?usize = null, 388 shown_failure: ?[]const u8 = null, 389 390 const list_max_width = 20; 391 const detail_min_width = 40; 392 const header_index = 0; 393 const content_index = 1; 394 // the undo button and the timestamp; everything below them is rebuilt 395 const fixed_rows = 2; 396 397 pub fn init(allocator: std.mem.Allocator, data: *const Self, session: *ui.Session) !View { 398 var outer = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .vert }); 399 errdefer outer.deinit(allocator); 400 401 // the sub header carries the tab's only action 402 { 403 var header = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .horiz }); 404 errdefer header.deinit(allocator); 405 const route = ui.RoutablePage.repoUndoClearRoute(data.identity) orelse return error.RouteTooLong; 406 const link = try std.fmt.allocPrint(session.page_arena.allocator(), "a:{s}", .{try route.toUrl(session.page_arena)}); 407 try addText(allocator, &header, "clear undo history", link, .single); 408 header.getFocus().child_id = header.children.keys()[0]; 409 // a row taller than the header, leaving a blank line beneath it 410 try outer.children.put(allocator, header.getFocus().id, .{ .widget = .{ .box = header }, .rect = null, .min_size = .{ .width = null, .height = 4 } }); 411 } 412 413 if (data.clear) { 414 var center = try initClearForm(allocator, data, session); 415 errdefer center.deinit(allocator); 416 try outer.children.put(allocator, center.getFocus().id, .{ .widget = .{ .center = center }, .rect = null, .min_size = null }); 417 outer.getFocus().child_id = outer.children.keys()[content_index]; 418 return .{ .box = outer, .data = data, .session = session }; 419 } 420 421 var box = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .horiz }); 422 errdefer box.deinit(allocator); 423 { 424 var scroll = blk: { 425 var rows = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .vert, .stretch = true }); 426 errdefer rows.deinit(allocator); 427 for (data.items) |item| { 428 try addText(allocator, &rows, item.action, item.link, .hidden); 429 // a transaction a later undo discarded says so on its border 430 if (item.undone) rows.children.values()[rows.children.count() - 1].widget.text_box.options.bottom_label = "(undone)"; 431 } 432 if (data.next) |next| { 433 const route = ui.RoutablePage.repoUndoRoute(data.identity, next) orelse return error.RouteTooLong; 434 try addText(allocator, &rows, "next →", try std.fmt.allocPrint(session.page_arena.allocator(), "a:{s}", .{try route.toUrl(session.page_arena)}), .hidden); 435 } 436 if (data.items.len == 0) try addText(allocator, &rows, "no undo history", null, .hidden); 437 rows.getFocus().child_id = rows.children.keys()[0]; 438 break :blk try wgt.Scroll(ui.Widget).init(allocator, .{ .box = rows }, .{ .direction = .vert, .web_native = !session.is_terminal, .fill = true }); 439 }; 440 errdefer scroll.deinit(allocator); 441 try box.children.put(allocator, scroll.getFocus().id, .{ .widget = .{ .scroll = scroll }, .rect = null, .min_size = .{ .width = list_max_width, .height = null }, .max_size = .{ .width = list_max_width, .height = null } }); 442 } 443 { 444 var scroll = blk: { 445 var details = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .vert }); 446 errdefer details.deinit(allocator); 447 if (data.items.len > 0) { 448 try addText(allocator, &details, "", null, .single); 449 try addLabeled(allocator, &details, " timestamp ", "", null); 450 details.getFocus().child_id = details.children.keys()[0]; 451 } 452 break :blk try wgt.Scroll(ui.Widget).init(allocator, .{ .box = details }, .{ .direction = .vert, .web_native = !session.is_terminal, .fill = true }); 453 }; 454 errdefer scroll.deinit(allocator); 455 scroll.getFocus().mode = .mouse; 456 try box.children.put(allocator, scroll.getFocus().id, .{ .widget = .{ .scroll = scroll }, .rect = null, .min_size = .{ .width = detail_min_width, .height = null } }); 457 } 458 box.getFocus().child_id = box.children.keys()[0]; 459 try outer.children.put(allocator, box.getFocus().id, .{ .widget = .{ .box = box }, .rect = null, .min_size = null }); 460 outer.getFocus().child_id = outer.children.keys()[content_index]; 461 return .{ .box = outer, .data = data, .session = session }; 462 } 463 464 // the same shape the thread views use to confirm a removal 465 fn initClearForm(allocator: std.mem.Allocator, data: *const Self, session: *ui.Session) !ui.widget.Center { 466 var box = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .rounded_corners = true, .direction = .vert }); 467 errdefer box.deinit(allocator); 468 const route = ui.RoutablePage.repoUndoClearRoute(data.identity) orelse return error.RouteTooLong; 469 box.getFocus().kind = .{ .custom = try std.fmt.allocPrint(session.page_arena.allocator(), "form:{s}", .{try route.toUrl(session.page_arena)}) }; 470 471 var prompt = try wgt.Text.init(allocator, "are you sure?"); 472 errdefer prompt.deinit(allocator); 473 try box.children.put(allocator, prompt.getFocus().id, .{ .widget = .{ .text = prompt }, .rect = null, .min_size = null }); 474 475 var button = try wgt.TextBox.init(allocator, "clear undo history", .{ .border_style = .single, .rounded_corners = true, .wrap_kind = .none }); 476 errdefer button.deinit(allocator); 477 button.getFocus().mode = .all; 478 button.getFocus().kind = if (data.can_undo) .{ .custom = "submit" } else .text_box; 479 try box.children.put(allocator, button.getFocus().id, .{ .widget = .{ .text_box = button }, .rect = null, .min_size = null }); 480 box.getFocus().child_id = button.getFocus().id; 481 482 return ui.widget.Center.init(allocator, .{ .box = box }); 483 } 484 485 fn addText(allocator: std.mem.Allocator, box: *wgt.Box(ui.Widget), text: []const u8, link: ?[]const u8, border: wgt.BorderStyle) !void { 486 var row = try wgt.TextBox.init(allocator, text, .{ .border_style = border, .rounded_corners = true, .wrap_kind = .word }); 487 errdefer row.deinit(allocator); 488 row.getFocus().mode = .all; 489 if (link) |value| row.getFocus().kind = .{ .custom = value }; 490 try box.children.put(allocator, row.getFocus().id, .{ .widget = .{ .text_box = row }, .rect = null, .min_size = null }); 491 } 492 493 // a labeled row below the timestamp, added as the selected action needs it 494 fn addLabeled(allocator: std.mem.Allocator, box: *wgt.Box(ui.Widget), label: []const u8, text: []const u8, link: ?[]const u8) !void { 495 try addText(allocator, box, text, link, .single); 496 box.children.values()[box.children.count() - 1].widget.text_box.options.label = label; 497 } 498 499 // enter counts only on the focused button; a click counts anywhere on it 500 fn activated(root_focus: *Focus, button_id: usize, key: Key) bool { 501 return switch (key) { 502 .enter => root_focus.grandchild_id == button_id, 503 .mouse => |mouse| inp.leftClickOn(root_focus, button_id, mouse), 504 else => false, 505 }; 506 } 507 508 // the terminal hosts run the action after rendering; the web renderer 509 // posts the form instead, and wasm has no repository to act on 510 fn requestUndo(self: *View, route: ui.RoutablePage) void { 511 if (builtin.target.cpu.arch == .wasm32) return; 512 if (!self.session.is_terminal or self.session.host_request != null) return; 513 self.session.host_request = .{ .undo = route.repo_undo }; 514 } 515 516 fn headerBox(self: *View) *wgt.Box(ui.Widget) { 517 return &self.box.children.values()[header_index].widget.box; 518 } 519 fn headerActive(self: *View) bool { 520 return self.box.getFocus().child_id == self.headerBox().getFocus().id; 521 } 522 fn contentBox(self: *View) *wgt.Box(ui.Widget) { 523 return &self.box.children.values()[content_index].widget.box; 524 } 525 fn listScroll(self: *View) *wgt.Scroll(ui.Widget) { 526 return &self.contentBox().children.values()[0].widget.scroll; 527 } 528 fn detailScroll(self: *View) *wgt.Scroll(ui.Widget) { 529 return &self.contentBox().children.values()[1].widget.scroll; 530 } 531 fn selected(self: *View) ?usize { 532 const rows = &self.listScroll().child.box; 533 const index = rows.children.getIndex(rows.getFocus().child_id orelse return null) orelse return null; 534 return if (index < self.data.items.len) index else null; 535 } 536 fn detailActive(self: *View) bool { 537 return self.contentBox().getFocus().child_id == self.detailScroll().getFocus().id; 538 } 539 540 fn refreshDetail(self: *View, allocator: std.mem.Allocator) !void { 541 const index = self.selected() orelse return; 542 const failure = self.session.data.undo_failure orelse self.data.failure; 543 if (self.detailed_index == index and std.meta.eql(self.shown_failure, failure)) return; 544 const details = &self.detailScroll().child.box; 545 while (details.children.count() > fixed_rows) { 546 var entry = details.children.pop() orelse break; 547 entry.value.widget.deinit(allocator); 548 } 549 const item = self.data.items[index]; 550 const enabled = self.data.can_undo and item.index > 0; 551 552 // the fixed rows are filled first, since adding the ones below 553 // invalidates every pointer into the box 554 { 555 const button = &details.children.values()[0].widget.text_box; 556 try button.setContent(allocator, if (item.index == 0) "initial state cannot be undone" else if (item.index == self.data.count - 1) "undo this" else "undo this and all above it"); 557 button.getFocus().kind = if (enabled) .{ .custom = "submit" } else .text_box; 558 } 559 try details.children.values()[1].widget.text_box.setContent(allocator, item.timestamp); 560 561 // some actions put buttons where the description would go 562 if (item.buttons.len == 0) { 563 try addLabeled(allocator, details, " description ", item.description, null); 564 } else for (item.buttons) |detail_button| { 565 try addLabeled(allocator, details, detail_button.label, detail_button.text, detail_button.link); 566 } 567 if (failure) |message| try addText(allocator, details, try std.fmt.allocPrint(self.session.page_arena.allocator(), "error: {s}", .{message}), null, .single); 568 self.shown_failure = failure; 569 details.getFocus().kind = if (enabled) .{ .custom = item.form } else .container; 570 details.getFocus().child_id = details.children.keys()[0]; 571 self.detailScroll().x = 0; 572 self.detailScroll().y = 0; 573 self.detailScroll().getFocus().version +%= 1; 574 self.detailed_index = index; 575 } 576 577 pub fn build(self: *View, allocator: std.mem.Allocator, constraint: layout.Constraint, root_focus: *Focus) !void { 578 self.clearGrid(); 579 if (self.data.clear) return try self.box.build(allocator, constraint, root_focus); 580 try self.refreshDetail(allocator); 581 const rows = &self.listScroll().child.box; 582 if (self.data.items.len == 0) { 583 const failure = self.session.data.undo_failure orelse self.data.failure; 584 if (!std.meta.eql(self.shown_failure, failure)) { 585 const message = if (failure) |name| try std.fmt.allocPrint(self.session.page_arena.allocator(), "error: {s}", .{name}) else "no undo history"; 586 try rows.children.values()[0].widget.text_box.setContent(allocator, message); 587 self.shown_failure = failure; 588 } 589 } 590 for (rows.children.keys(), rows.children.values()) |id, *child| ui.widget.markSelected(&child.widget.text_box, rows.getFocus().child_id == id); 591 const both_fit = if (constraint.max_size.width) |width| width >= list_max_width + detail_min_width else true; 592 self.contentBox().children.values()[0].max_size = if (both_fit) .{ .width = list_max_width, .height = null } else null; 593 const width = if (constraint.max_size.width) |value| if (both_fit) value - list_max_width else value else detail_min_width; 594 self.contentBox().children.values()[1].min_size = .{ .width = width, .height = null }; 595 for (self.detailScroll().child.box.children.values()) |*child| child.max_size = .{ .width = width -| 2, .height = null }; 596 try self.box.build(allocator, constraint, root_focus); 597 } 598 599 pub fn input(self: *View, allocator: std.mem.Allocator, key: Key, root_focus: *Focus) !void { 600 // the sub header sits above whichever content the route selects. 601 // scrolling crosses the boundary the same way the arrow keys do 602 const direction = inp.vertDirection(key); 603 if (self.headerActive()) { 604 if (direction == .down) root_focus.setFocus(self.box.children.values()[content_index].widget.getFocus().id); 605 return; 606 } 607 if (self.data.clear) { 608 if (direction == .up) root_focus.setFocus(self.headerBox().getFocus().id) else try self.clearInput(key, root_focus); 609 return; 610 } 611 if (direction == .up and self.contentAtTop()) { 612 root_focus.setFocus(self.headerBox().getFocus().id); 613 return; 614 } 615 try self.refreshDetail(allocator); 616 if (self.detailActive()) { 617 const details = &self.detailScroll().child.box; 618 if (self.selected()) |index| { 619 if (activated(root_focus, details.children.keys()[0], key) and self.data.can_undo and self.data.items[index].index > 0) { 620 self.requestUndo(ui.RoutablePage.repoUndoRoute(self.data.identity, self.data.items[index].index) orelse return error.RouteTooLong); 621 return; 622 } 623 } 624 if (key == .arrow_left) root_focus.setFocus(self.listScroll().getFocus().id) else if (inp.rowDelta(key, @intCast(details.children.count()))) |delta| ui.widget.moveRowFocus(details, self.detailScroll(), root_focus, delta); 625 } else if (inp.rowDelta(key, @intCast(self.listScroll().child.box.children.count()))) |delta| { 626 ui.widget.moveRowFocus(&self.listScroll().child.box, self.listScroll(), root_focus, delta); 627 } else switch (key) { 628 .arrow_right, .enter => if (self.selected() != null) { 629 root_focus.setFocus(self.detailScroll().getFocus().id); 630 }, 631 else => {}, 632 } 633 } 634 635 // the confirm button submits the form the web renderer posts 636 fn clearInput(self: *View, key: Key, root_focus: *Focus) !void { 637 const center = &self.box.children.values()[content_index].widget.center; 638 const button_id = center.child.box.getFocus().child_id orelse return; 639 if (!activated(root_focus, button_id, key) or !self.data.can_undo) return; 640 self.requestUndo(ui.RoutablePage.repoUndoClearRoute(self.data.identity) orelse return error.RouteTooLong); 641 } 642 643 fn contentAtTop(self: *View) bool { 644 const scroll = if (self.detailActive()) self.detailScroll() else self.listScroll(); 645 const rows = &scroll.child.box; 646 const id = rows.getFocus().child_id orelse return true; 647 return rows.children.getIndex(id) == 0 and scroll.y == 0; 648 } 649 650 // moving up from the sub header returns to the page's tabs 651 pub fn atTop(self: *View) bool { 652 return self.headerActive(); 653 } 654 655 // arriving from the page's tabs lands on the sub header, not the content 656 pub fn focusHeader(self: *View, root_focus: *Focus) bool { 657 root_focus.setFocus(self.headerBox().getFocus().id); 658 return true; 659 } 660 pub fn deinit(self: *View, allocator: std.mem.Allocator) void { 661 self.box.deinit(allocator); 662 } 663 pub fn clearGrid(self: *View) void { 664 self.box.clearGrid(); 665 } 666 pub fn getGrid(self: View) ?Grid { 667 return self.box.getGrid(); 668 } 669 pub fn getFocus(self: *View) *Focus { 670 return self.box.getFocus(); 671 } 672 }; 673