╭─────────────╮ │scroll to top│ ╰─────────────╯ ╭ Diff.zig ─────────────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯
🬐 🬠 🬞🬂🬏 🬟 🬑 🬟 🬑 ╭642c6a16..╮ 642c6a16.. see-em: 🬋🬋🬋 🬋🬋🬋 🬋 🬋 │files │ commits refs discuss issues new login 🬐 🬠 🬐 🬠 🬑 🬟 🬰 ╰──────────╯ (572) 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
54 arena: *std.heap.ArenaAllocator, 55 repo: *rp.Repo(repo_kind, repo_opts), 56 io: std.Io, 57 gpa: std.mem.Allocator, 58 route: ui.RoutablePage.RepoDiffRoute, 59 ) !Self { 60 const aa = arena.allocator(); 61 const oid_len = comptime xit.hash.hexLen(repo_opts.hash); 62 const identity = try aa.dupe(u8, route.name.slice()); 63 const base_oid, const head_oid, const diff_route = if (route.patchrev_id.len != 0) blk: { 64 const id = evt.parseEventId(route.patchrev_id.slice()) catch return error.NotFound; 65 const record = (try evt.readFromRepo(evt.PatchRev, repo_kind, repo_opts, io, gpa, arena, repo, &id)) orelse return error.NotFound; 66 if (record.removed) return error.NotFound; 67 if (record.base_tree_oid.len != oid_len or record.head_tree_oid.len != oid_len) return error.NotFound; 68 break :blk .{ 69 record.base_tree_oid[0..oid_len].*, 70 record.head_tree_oid[0..oid_len].*, 71 Route{ .patchrev = .{ .identity = identity, .id = try aa.dupe(u8, route.patchrev_id.slice()) } }, 72 }; 73 } else blk: { 74 const resolved = (try ui.ResolvedRefOrOid(repo_kind, repo_opts).init(repo, io, aa, route.ref_or_oid, route.value.slice())) orelse return error.NotFound; 75 evt.PatchRev.validateOid(repo_opts.hash, &resolved.oid) catch return error.NotFound; 76 evt.PatchRev.validateOid(repo_opts.hash, route.base_oid.slice()) catch return error.NotFound; 77 78 var moment = try repo.core.latestMoment(); 79 const state = rp.Repo(repo_kind, repo_opts).State(.read_only){ .core = &repo.core, .extra = .{ .moment = &moment } }; 80 // peel annotated tags before comparing their trees 81 var tip = try xit.object.Object(repo_kind, repo_opts).initCommit(state, io, gpa, &resolved.oid); 82 defer tip.deinit(); 83 break :blk .{ 84 route.base_oid.slice()[0..oid_len].*, 85 tip.oid, 86 Route{ .repo = .{ 87 .identity = identity, 88 .ref_or_oid = resolved.ref_or_oid, 89 .value = resolved.value, 90 .base_oid = try aa.dupe(u8, route.base_oid.slice()), 91 } }, 92 }; 93 }; 94 const path = try aa.dupe(u8, route.path.slice()); 95 return .{ 96 .route = diff_route, 97 .path = path, 98 .window = try render(repo_kind, repo_opts, io, gpa, aa, repo, if (std.mem.allEqual(u8, &base_oid, '0')) null else &base_oid, head_oid, route.start, path), 99 }; 100 } 101 102 // render a window of the net diff between two commits or trees 103 pub fn render( 104 comptime repo_kind: rp.RepoKind, 105 comptime repo_opts: rp.RepoOpts(repo_kind), 106 io: std.Io, 107 gpa: std.mem.Allocator, 108 arena: std.mem.Allocator, 109 repo: *rp.Repo(repo_kind, repo_opts), 110 base_oid: ?*const [xit.hash.hexLen(repo_opts.hash)]u8, 111 head_oid: [xit.hash.hexLen(repo_opts.hash)]u8, 112 start: usize, 113 path: []const u8, 114 ) !Window { 115 var tree_diff = try repo.treeDiff(io, gpa, base_oid, &head_oid); 116 defer tree_diff.deinit(); 117 118 var file_iter = try repo.filePairs(io, gpa, .{ .tree = .{ .tree_diff = &tree_diff } }); 119 120 var hunks: std.ArrayList(Hunk) = .empty; 121 var index: usize = 0; // running hunk index across all files 122 var has_more = false; 123 124 file_loop: while (try file_iter.next()) |pair_val| { 125 var pair = pair_val; 126 defer pair.deinit(); 127 128 if (path.len != 0 and !std.mem.eql(u8, pair.path, path)) continue; 129 130 var hunk_iter = try df.HunkIterator(repo_kind, repo_opts).init(gpa, &pair.a, &pair.b); 131 defer hunk_iter.deinit(gpa); 132 133 // the path label rides on the first of this file's hunks we actually show. 134 var path_attached = false; 135 while (try hunk_iter.next(gpa)) |hunk_val| { 136 var hunk = hunk_val; 137 defer hunk.deinit(gpa); 138 139 const i = index; 140 index += 1; 141 if (i < start) continue; // before this window 142 if (hunks.items.len >= page_size) { 143 has_more = true; 144 break :file_loop; 145 } 146 try hunks.append(arena, .{ 147 .path = if (path_attached) null else try arena.dupe(u8, pair.path), 148 .text = try renderHunk(repo_kind, repo_opts, arena, &hunk_iter, &hunk), 149 }); 150 path_attached = true; 151 } 152 } 153 154 return .{ .hunks = try hunks.toOwnedSlice(arena), .start = start, .has_more = has_more }; 155 } 156 157 // render edits with right-aligned line numbers 158 fn renderHunk( 159 comptime repo_kind: rp.RepoKind, 160 comptime repo_opts: rp.RepoOpts(repo_kind), 161 arena: std.mem.Allocator, 162 hunk_iter: *df.HunkIterator(repo_kind, repo_opts), 163 hunk: *df.Hunk(repo_kind, repo_opts), 164 ) ![]const u8 { 165 var out: std.Io.Writer.Allocating = .init(arena); 166 defer out.deinit(); 167 var max_num: usize = 1; 168 for (hunk.edits.items) |edit| { 169 const n = editLineNum(edit) + 1; 170 if (n > max_num) max_num = n; 171 } 172 const width = std.fmt.count("{d}", .{max_num}); 173 for (hunk.edits.items, 0..) |edit, i| { 174 const text = switch (edit) { 175 .eql => |e| try hunk_iter.line_iter_b.get(e.new_line.num), 176 .ins => |e| try hunk_iter.line_iter_b.get(e.new_line.num), 177 .del => |e| try hunk_iter.line_iter_a.get(e.old_line.num), 178 }; 179 const prefix: u8 = switch (edit) { 180 .eql => ' ', 181 .ins => '+', 182 .del => '-', 183 }; 184 if (i != 0) try out.writer.writeByte('\n'); 185 const num = editLineNum(edit) + 1; 186 try out.writer.splatByteAll(' ', width - std.fmt.count("{d}", .{num})); 187 try out.writer.print("{d} {c}{s}", .{ num, prefix, text }); 188 } 189 return out.toOwnedSlice(); 190 } 191 192 // the line number to show for an edit: the new-side number for kept and inserted 193 // lines, the old-side number for deletions (0-based in the diff machinery). 194 fn editLineNum(edit: df.Edit) usize { 195 return switch (edit) { 196 .eql => |e| e.new_line.num, 197 .ins => |e| e.new_line.num, 198 .del => |e| e.old_line.num, 199 }; 200 } 201 202 pub fn appendWindow(data: @This(), allocator: std.mem.Allocator, session: *ui.Session, box: *wgt.Box(ui.Widget)) !void { 203 if (data.path.len != 0) { 204 try addLink(allocator, box, data.path, ""); 205 try addLink(allocator, box, "← all files", try data.route.link(session.page_arena, 0, "")); 206 } 207 if (data.window.start > 0) try addLink(allocator, box, "← previous", try data.route.link(session.page_arena, data.window.start -| page_size, data.path)); 208 for (data.window.hunks) |hunk| { 209 if (data.path.len == 0) if (hunk.path) |path| try addLink(allocator, box, path, try data.route.link(session.page_arena, 0, path)); 210 if (hunk.text.len != 0) try addLink(allocator, box, hunk.text, ""); 211 } 212 if (data.window.has_more) try addLink(allocator, box, "next →", try data.route.link(session.page_arena, data.window.start + page_size, data.path)); 213 } 214 215 fn addLink(allocator: std.mem.Allocator, box: *wgt.Box(ui.Widget), text: []const u8, link: []const u8) !void { 216 var tb = try wgt.TextBox.init(allocator, text, .{ .border_style = .single, .rounded_corners = true, .wrap_kind = .none }); 217 errdefer tb.deinit(allocator); 218 tb.getFocus().mode = .all; 219 if (link.len != 0) tb.getFocus().kind = .{ .custom = link }; 220 try box.children.put(allocator, tb.getFocus().id, .{ .widget = .{ .text_box = tb }, .rect = null, .min_size = null, .flex = .shrink }); 221 } 222 223 pub const View = struct { 224 scroll: wgt.Scroll(ui.Widget), 225 session: *ui.Session, 226 227 pub fn initEmpty(allocator: std.mem.Allocator, session: *ui.Session) !View { 228 var box = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .vert }); 229 errdefer box.deinit(allocator); 230 return .{ 231 .scroll = try wgt.Scroll(ui.Widget).init(allocator, .{ .box = box }, .{ .direction = .both, .web_native = !session.is_terminal, .fill = true }), 232 .session = session, 233 }; 234 } 235 236 pub fn init(allocator: std.mem.Allocator, data: *const Self, session: *ui.Session) !View { 237 var view = try initEmpty(allocator, session); 238 errdefer view.deinit(allocator); 239 const box = view.inner(); 240 try data.appendWindow(allocator, session, box); 241 if (box.children.count() == 0) try addLink(allocator, box, "no changes", ""); 242 box.getFocus().child_id = box.children.keys()[0]; 243 return view; 244 } 245 246 pub fn deinit(self: *View, allocator: std.mem.Allocator) void { 247 self.scroll.deinit(allocator); 248 } 249 pub fn build(self: *View, allocator: std.mem.Allocator, constraint: layout.Constraint, root_focus: *Focus) !void { 250 self.clearGrid(); 251 try self.scroll.build(allocator, constraint, root_focus); 252 } 253 pub fn clearGrid(self: *View) void { 254 self.scroll.clearGrid(); 255 } 256 pub fn getGrid(self: View) ?Grid { 257 return self.scroll.getGrid(); 258 } 259 pub fn getFocus(self: *View) *Focus { 260 return self.scroll.getFocus(); 261 } 262 pub fn atTop(self: *View) bool { 263 const box = self.inner(); 264 return self.scroll.y == 0 and (box.children.count() == 0 or box.getFocus().child_id == box.children.keys()[0]); 265 } 266 fn inner(self: *View) *wgt.Box(ui.Widget) { 267 return &self.scroll.child.box; 268 } 269 pub fn input(self: *View, allocator: std.mem.Allocator, key: Key, root_focus: *Focus) !void { 270 _ = allocator; 271 const sc = &self.scroll; 272 switch (key) { 273 // scroll horizontally within the diff 274 .arrow_left => if (!self.moveInRow(root_focus, false) and sc.x > 0) { 275 sc.x -= 1; 276 self.scroll.clampToContent(); 277 }, 278 .arrow_right => if (!self.moveInRow(root_focus, true)) { 279 sc.x += 1; 280 self.scroll.clampToContent(); 281 }, 282 .arrow_up => self.moveDiff(root_focus, -1), 283 .arrow_down => self.moveDiff(root_focus, 1), 284 .page_up => self.pageDiff(root_focus, -10), 285 .page_down => self.pageDiff(root_focus, 10), 286 .home => self.jumpDiff(root_focus, false), 287 .end => self.jumpDiff(root_focus, true), 288 // Enter / a click on a "previous"/"next" row follow its "a:" link in 289 // the host (it reloads the adjacent window), so they don't reach here. 290 .mouse => |mouse| switch (mouse.action) { 291 .scroll => |dir| self.moveDiff(root_focus, if (dir == .up) -1 else 1), 292 else => {}, 293 }, 294 else => {}, 295 } 296 } 297 298 // step across the selected row's boxes, false when the row has none that way. 299 pub fn moveInRow(self: *View, root_focus: *Focus, right: bool) bool { 300 const box = self.inner(); 301 const selected = box.getFocus().child_id orelse return false; 302 return switch ((box.children.getPtr(selected) orelse return false).widget) { 303 .box => |*row| ui.widget.moveInRow(row, root_focus, right), 304 else => false, 305 }; 306 } 307 308 // move one step in `delta` (+ down, - up). in the terminal, `delta` is a 309 // line count unless there is a new hunk visible (in which case it is a 310 // hunk count). on the web `delta` is always a hunk count. 311 fn moveDiff(self: *View, root_focus: *Focus, delta: isize) void { 312 const box = self.inner(); 313 const keys = box.children.keys(); 314 if (keys.len == 0) return; 315 const cur: usize = if (box.getFocus().child_id) |c| (box.children.getIndex(c) orelse 0) else 0; 316 const target = @as(isize, @intCast(cur)) + delta; 317 const in_range = target >= 0 and target < @as(isize, @intCast(keys.len)); 318 319 if (self.session.is_terminal) { 320 if (in_range and self.hunkVisible(@intCast(target))) { 321 root_focus.setFocus(keys[@intCast(target)]); 322 return; 323 } 324 325 const sc = &self.scroll; 326 sc.y += delta * 5; // magnify because it's a line count 327 self.scroll.clampToContent(); 328 if (in_range and self.hunkVisible(@intCast(target))) { 329 root_focus.setFocus(keys[@intCast(target)]); 330 } 331 } else { 332 if (in_range) { 333 root_focus.setFocus(keys[@intCast(target)]); 334 } 335 } 336 } 337 338 // page a fixed number of lines, then focus the leading visible hunk 339 // (bottom-most when paging down, top-most when paging up). in the 340 // terminal, `delta` is a line count, and on the web it's a hunk count. 341 fn pageDiff(self: *View, root_focus: *Focus, delta: isize) void { 342 if (self.session.is_terminal) { 343 const sc = &self.scroll; 344 sc.y += delta * 5; // magnify because it's a line count 345 self.scroll.clampToContent(); 346 self.focusVisible(root_focus, delta > 0); 347 } else { 348 const box = self.inner(); 349 const keys = box.children.keys(); 350 if (keys.len == 0) return; 351 const cur: isize = if (box.getFocus().child_id) |c| @intCast(box.children.getIndex(c) orelse 0) else 0; 352 const target: usize = @intCast(std.math.clamp(cur + delta, 0, @as(isize, @intCast(keys.len - 1)))); 353 root_focus.setFocus(keys[target]); 354 } 355 } 356 357 // jump to the first or last hunk. on the web the browser scrolls to the 358 // focused hunk; on the terminal pin the scroll to the top/bottom too. 359 fn jumpDiff(self: *View, root_focus: *Focus, to_end: bool) void { 360 const box = self.inner(); 361 const keys = box.children.keys(); 362 if (keys.len == 0) return; 363 if (self.session.is_terminal) { 364 const sc = &self.scroll; 365 sc.y = if (to_end) std.math.maxInt(isize) else 0; 366 self.scroll.clampToContent(); 367 } 368 root_focus.setFocus(if (to_end) keys[keys.len - 1] else keys[0]); 369 } 370 371 // whether hunk `index` is at least partly within the diff viewport, per the 372 // last build's layout rects (content space) and the current scroll offset. 373 fn hunkVisible(self: *View, index: usize) bool { 374 const box = self.inner(); 375 const sc = &self.scroll; 376 const vp = sc.grid orelse return false; 377 const r = box.children.values()[index].rect orelse return false; 378 const top = sc.y; 379 const bottom = sc.y + @as(isize, @intCast(vp.size.height - sc.bar_h)); 380 return (r.y + @as(isize, @intCast(r.size.height))) > top and r.y < bottom; 381 } 382 383 // focus the visible hunk at the scroll's leading edge. `prefer_last` picks 384 // the bottom-most visible (for downward motion), else the top-most. 385 fn focusVisible(self: *View, root_focus: *Focus, prefer_last: bool) void { 386 const box = self.inner(); 387 const sc = &self.scroll; 388 const vp = sc.grid orelse return; 389 const top = sc.y; 390 const bottom = sc.y + @as(isize, @intCast(vp.size.height - sc.bar_h)); 391 var chosen: ?usize = null; 392 for (box.children.keys(), box.children.values()) |id, *child| { 393 const r = child.rect orelse continue; // content-space layout rect 394 const r_top = r.y; 395 const r_bot = r.y + @as(isize, @intCast(r.size.height)); 396 if (r_bot <= top or r_top >= bottom) continue; // not visible 397 chosen = id; 398 if (!prefer_last) break; // first visible 399 } 400 if (chosen) |id| root_focus.setFocus(id); 401 } 402 }; 403