HAXY

▄ ▄▄▄▄▄ ▄ ▄▀ ▄▀▀▀▀▀▀ ▄ ▀▄ ▀▀▀▀▀▀▀▀ ▀▀ ▀▀▄ ▀▀▀▀▀▀▀▀ ▀▀▀ ▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀ ▀▄ ▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▄▄▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▄ ▄▀▀▀▀▀▀▀▀ ▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀ ▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀ ▀▀▀▀ ▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▄▄▀▀▀▄▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▄ ▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▄▄▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

╭ Fork.zig ─────────────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯

╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │http│ ssh │ │ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯

.. Auth/ Fork/ Home/ Repo/ User/ widget/ Auth.zig AuthTab.zig ╭─────────────────────────────────╮ │Fork.zig │ ╰─────────────────────────────────╯ Home.zig Quit.zig Repo.zig Settings.zig SubTitle.zig Title.zig Unauthorized.zig User.zig input.zig widget.zig

1 const std = @import("std"); 2 const evt = @import("../event.zig"); 3 const ui = @import("../ui.zig"); 4 const fork = @import("../fork.zig"); 5 const xit = @import("xit"); 6 const rp = xit.repo; 7 const xitui = xit.xitui; 8 const wgt = xitui.widget; 9 const layout = xitui.layout; 10 const Key = xitui.input.Key; 11 const Grid = xitui.grid.Grid; 12 const Focus = xitui.focus.Focus; 13 const inp = @import("./input.zig"); 14 15 pub const Header = @import("./Fork/Header.zig"); 16 pub const Files = @import("./Repo/Files.zig"); 17 pub const Commits = @import("./Repo/Commits.zig"); 18 pub const Diff = @import("./Repo/Diff.zig"); 19 pub const Patches = @import("./Repo/Patches.zig"); 20 pub const Settings = @import("./Settings.zig"); 21 pub const Auth = @import("./Auth.zig"); 22 pub const Quit = @import("./Quit.zig"); 23 24 header: Header, 25 files: Files, 26 commits: Commits, 27 patch: Patches, 28 diff: Diff, 29 settings: Settings, 30 auth: Auth, 31 quit: Quit, 32 33 const Self = @This(); 34 35 pub fn init(arena: *std.heap.ArenaAllocator, session: *ui.Session, route: ui.RoutablePage) !Self { 36 const io = session.io orelse return error.NotFound; 37 const users_dir = session.users_dir orelse return error.NotFound; 38 const haxy_moment = session.haxy_moment orelse return error.NoMoment; 39 const route_fork = route.forkRoute() orelse return error.UnexpectedRoute; 40 // the route's identity names the forker and the target repo 41 const identity = ui.RoutablePage.RepoIdentity.parse(route_fork.name.slice()) orelse return error.NotFound; 42 const id = evt.parseEventId(route_fork.id.slice()) catch return error.NotFound; 43 const gpa = arena.child_allocator; 44 const forker_id = (try evt.User.readIdByName(evt.AdminDB, evt.admin_repo_opts.hash, haxy_moment, identity.owner)) orelse return error.NotFound; 45 const fork_record = (try evt.readForkById(io, gpa, arena, users_dir, &forker_id, &id)) orelse return error.NotFound; 46 if (fork_record.removed) return error.NotFound; 47 if (fork_record.event.repo_id.len != evt.event_id_size) return error.NotFound; 48 var target_id: [evt.event_id_size]u8 = undefined; 49 @memcpy(&target_id, fork_record.event.repo_id); 50 const owner_id = fork_record.event.repo_user_id[0..evt.event_id_size]; 51 52 const target_record = (try evt.readRepoById(io, gpa, arena, users_dir, owner_id, fork_record.event.repo_id)) orelse return error.NotFound; 53 // a draft is as readable as the repo it targets 54 if (evt.Repo.roleOf(target_record, session.userId()) == .none) return error.NotFound; 55 const owner = (try evt.User.readById(evt.AdminDB, evt.admin_repo_opts.hash, haxy_moment, arena, owner_id)) orelse return error.NotFound; 56 if (!std.mem.eql(u8, target_record.event.name, identity.name)) return error.NotFound; 57 58 const aa = arena.allocator(); 59 const target_identity = try std.fmt.allocPrint(aa, "{s}/{s}", .{ owner.event.name, target_record.event.name }); 60 const id_hex = std.fmt.bytesToHex(id, .lower); 61 const fork_path = try fork.forkPath(aa, users_dir, &forker_id, &id); 62 var fork_repo = try rp.Repo(.xit, .{}).open(io, arena.child_allocator, .{ .path = fork_path, .require_repo_root = true }); 63 defer fork_repo.deinit(io, arena.child_allocator); 64 const fork_moment = try evt.currentMoment(.{}, &fork_repo); 65 const retained_patch = (try evt.Patch.readById(evt.EventDB(.sha1), .sha1, fork_moment, arena, &id)) orelse return error.NotFound; 66 const fork_oid = (try fork_repo.readRef(io, fork.ref)) orelse return error.NotFound; 67 const newest_revision = try evt.PatchRev.readNewest(evt.EventDB(.sha1), .sha1, fork_moment, arena); 68 var commits_base_oid = fork_oid; 69 if (newest_revision) |revision| { 70 if (revision.record.event.base_oid.len != commits_base_oid.len) return error.NotFound; 71 @memcpy(&commits_base_oid, revision.record.event.base_oid); 72 } 73 74 const target_path = try evt.repoPath(aa, users_dir, owner_id, &target_id); 75 const target_source = ui.RepoSource{ .path = target_path, .repo_kind = .xit }; 76 var target_repo_maybe: ?rp.Repo(.xit, .{}) = if (!target_record.removed) 77 rp.Repo(.xit, .{}).open(io, arena.child_allocator, target_source.localInitOpts()) catch null 78 else 79 null; 80 defer if (target_repo_maybe) |*target_repo| target_repo.deinit(io, arena.child_allocator); 81 82 const target_branch = retained_patch.event.target_branch; 83 84 const retained_entry = Patches.PatchWithId{ 85 .id = try aa.dupe(u8, &id_hex), 86 .record = retained_patch, 87 .author = try ui.Author.initFromEmail(haxy_moment, arena, retained_patch.author_email), 88 .draft = fork_record.event.stage == .draft, 89 .revision_oid = try aa.dupe(u8, &fork_oid), 90 .fork_exists = true, 91 .forker = identity.owner, 92 }; 93 var patch_data = try Patches.detailResult(aa, target_identity, retained_entry); 94 95 if (target_repo_maybe) |*target_repo| switch (fork_record.event.stage) { 96 .draft => if (try Patches.loadDraftEntry(.xit, .{}, arena, io, haxy_moment, &fork_repo, target_repo, id, identity.owner)) |entry| { 97 patch_data = try Patches.detailResult(aa, target_identity, entry); 98 patch_data.repo_source = target_source; 99 }, 100 .publish => { 101 patch_data = Patches.init(.xit, .{}, arena, target_repo, io, haxy_moment, session, target_id, target_identity, target_branch, "", "", &id_hex, "", 0, "", .open) catch |err| switch (err) { 102 error.NotFound => patch_data, 103 else => |other| return other, 104 }; 105 if (patch_data.selectedThread() != null) patch_data.repo_source = target_source; 106 }, 107 }; 108 patch_data.repo_id = target_id; 109 110 const requested_ref: ?ui.RoutablePage.RefOrOid = switch (route) { 111 .fork_files => |f| if (f.oid.len == 0) null else .object, 112 .fork_commits => |c| if (c.oid.len == 0) null else .object, 113 else => null, 114 }; 115 const requested_value: []const u8 = switch (route) { 116 .fork_files => |*f| f.oid.slice(), 117 .fork_commits => |*c| c.oid.slice(), 118 else => "", 119 }; 120 const files_path: []const u8 = switch (route) { 121 .fork_files => |*f| f.path.slice(), 122 else => "", 123 }; 124 const files_line: usize = switch (route) { 125 .fork_files => |f| f.line, 126 else => 0, 127 }; 128 const files_find: []const u8 = switch (route) { 129 .fork_files => |*f| f.find.slice(), 130 else => "", 131 }; 132 const commits_content: ui.RoutablePage.RepoCommitsRoute.Content = switch (route) { 133 .fork_commits => |c| c.content, 134 else => .{ .diff = .{} }, 135 }; 136 const location = ui.RoutablePage.RepoLocation{ .fork = .{ 137 .identity = identity.identity, 138 .id = &id_hex, 139 } }; 140 const files = try Files.init(.xit, .{}, arena, &fork_repo, io, arena.child_allocator, location, requested_ref, requested_value, files_path, files_line, files_find); 141 var commits = try Commits.init(.xit, .{}, arena, &fork_repo, io, arena.child_allocator, haxy_moment, location, requested_ref, requested_value, commits_content, &commits_base_oid, "", ""); 142 commits.commit_count = if (newest_revision) |revision| revision.record.commit_count else 0; 143 const diff_start: usize = switch (route) { 144 .fork_diff => |d| d.start, 145 else => 0, 146 }; 147 const diff_path = switch (route) { 148 .fork_diff => |*d| try aa.dupe(u8, d.path.slice()), 149 else => "", 150 }; 151 152 return .{ 153 .header = try Header.init(arena, target_record.event.name, identity.owner, &id_hex, requested_value), 154 .files = files, 155 .commits = commits, 156 .patch = patch_data, 157 .diff = .{ 158 .route = .{ .fork = .{ .identity = try aa.dupe(u8, identity.identity), .id = try aa.dupe(u8, &id_hex) } }, 159 .path = diff_path, 160 .window = try Diff.render(.xit, .{}, io, arena.child_allocator, aa, &fork_repo, &commits_base_oid, fork_oid, diff_start, diff_path), 161 }, 162 .settings = Settings.init(), 163 .auth = Auth.init(), 164 .quit = Quit.init(), 165 }; 166 } 167 168 pub const View = struct { 169 box: wgt.Box(ui.Widget), 170 171 const header_index: usize = 0; 172 const stack_index: usize = 1; 173 174 pub fn init(allocator: std.mem.Allocator, data: *const Self, session: *ui.Session) !View { 175 var box = try wgt.Box(ui.Widget).init(allocator, .{ .border_style = null, .direction = .vert }); 176 errdefer box.deinit(allocator); 177 { 178 var header = try Header.View.init(allocator, &data.header, data.commits.commit_count, session); 179 errdefer header.deinit(allocator); 180 try box.children.put(allocator, header.getFocus().id, .{ .widget = .{ .fork_header = header }, .rect = null, .min_size = null }); 181 } 182 { 183 var stack = try wgt.Stack(ui.Widget).init(allocator); 184 errdefer stack.deinit(allocator); 185 const selected = data.patch.selectedThread() orelse return error.NotFound; 186 var patch_detail = try Patches.Detail.init(allocator, &data.patch, session, selected.*, .{ .actions = data.patch.repo_source != null }); 187 errdefer patch_detail.deinit(allocator); 188 try stack.children.put(allocator, patch_detail.getFocus().id, .{ .repo_patch_detail = patch_detail }); 189 { 190 var diff = try Diff.View.init(allocator, &data.diff, session); 191 errdefer diff.deinit(allocator); 192 try stack.children.put(allocator, diff.getFocus().id, .{ .diff_view = diff }); 193 } 194 { 195 var files = try Files.View.init(allocator, &data.files, session); 196 errdefer files.deinit(allocator); 197 try stack.children.put(allocator, files.getFocus().id, .{ .repo_files = files }); 198 } 199 { 200 var commits = try Commits.View.init(allocator, &data.commits, session); 201 errdefer commits.deinit(allocator); 202 try stack.children.put(allocator, commits.getFocus().id, .{ .repo_commits = commits }); 203 } 204 if (session.data.user_id != null) { 205 var settings = try Settings.View.init(allocator, session); 206 errdefer settings.deinit(allocator); 207 try stack.children.put(allocator, settings.getFocus().id, .{ .home_settings = settings }); 208 } 209 if (session.data.host_kind == .server) { 210 var auth = try Auth.View.init(allocator, &data.auth, session); 211 errdefer auth.deinit(allocator); 212 try stack.children.put(allocator, auth.getFocus().id, .{ .home_auth = auth }); 213 } 214 if (session.is_terminal) { 215 var quit = try Quit.View.init(allocator, session); 216 errdefer quit.deinit(allocator); 217 try stack.children.put(allocator, quit.getFocus().id, .{ .quit = quit }); 218 } 219 try box.children.put(allocator, stack.getFocus().id, .{ .widget = .{ .stack = stack }, .rect = null, .min_size = null }); 220 } 221 // a page opens on its tabs, except that search results open in the 222 // files tab's search box. 223 box.getFocus().child_id = box.children.keys()[if (data.files.find != null) stack_index else header_index]; 224 return .{ .box = box }; 225 } 226 227 pub fn deinit(self: *View, allocator: std.mem.Allocator) void { 228 self.box.deinit(allocator); 229 } 230 231 pub fn build(self: *View, allocator: std.mem.Allocator, constraint: layout.Constraint, root_focus: *Focus) !void { 232 self.clearGrid(); 233 const header = &self.box.children.values()[header_index].widget.fork_header; 234 const stack = &self.box.children.values()[stack_index].widget.stack; 235 if (header.getSelectedIndex()) |index| stack.getFocus().child_id = stack.children.keys()[index]; 236 try self.box.build(allocator, constraint, root_focus); 237 } 238 239 pub fn input(self: *View, allocator: std.mem.Allocator, key: Key, root_focus: *Focus) !void { 240 const stack = &self.box.children.values()[stack_index].widget.stack; 241 const current_id = self.box.getFocus().child_id orelse return; 242 const current_index = self.box.children.getIndex(current_id) orelse return; 243 const child = &self.box.children.values()[current_index].widget; 244 var next_index = current_index; 245 switch (inp.vertDirection(key)) { 246 .up => switch (child.*) { 247 .fork_header => try child.input(allocator, key, root_focus), 248 .stack => if (stack.getSelected()) |selected| { 249 if (selected.atTop(root_focus)) next_index = header_index else try child.input(allocator, key, root_focus); 250 }, 251 else => {}, 252 }, 253 .down => switch (child.*) { 254 .fork_header => { 255 if (stack.getSelected()) |selected| switch (selected.*) { 256 .repo_patch_detail => |*view| if (view.focusFirst(root_focus)) return, 257 .repo_files => |*view| if (view.focusHeader(root_focus)) return, 258 .repo_commits => |*view| if (view.focusHeader(root_focus)) return, 259 else => {}, 260 }; 261 next_index = stack_index; 262 }, 263 .stack => try child.input(allocator, key, root_focus), 264 else => {}, 265 }, 266 .none => try child.input(allocator, key, root_focus), 267 } 268 if (next_index != current_index) root_focus.setFocus(self.box.children.keys()[next_index]); 269 } 270 271 pub fn clearGrid(self: *View) void { 272 self.box.clearGrid(); 273 } 274 275 pub fn getGrid(self: View) ?Grid { 276 return self.box.getGrid(); 277 } 278 279 pub fn getFocus(self: *View) *Focus { 280 return self.box.getFocus(); 281 } 282 }; 283