wyag

root.zig (38550B)

---

 const std = @import("std");
 const argparse = @import("argparse.zig");
 const IniFile = @import("inifile.zig");
 const Dir = std.fs.Dir;
 
 // A horrible, buggy, version of git.
 
 pub fn doMain() !void {
     prng = std.rand.DefaultPrng.init(@intCast(std.time.timestamp()));
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
     const a = gpa.allocator();
     var ap = argparse.init(a, "wyag", "Write Yourself A Git: a bad version of git for educational purposes");
     defer ap.deinit();
     var init: argparse.Subcommand = .{ .parent = &ap, .description = "Initialize a new git repository", .name = "init" };
     try ap.addSubcommand(&init);
     var init_path: argparse.Positional = .{ .name = "path", .description = "The directory in which to make a git repository" };
     try init.addPositional(&init_path);
 
     var cat_file: argparse.Subcommand = .{ .parent = &ap, .description = "Read the contents of an object", .name = "cat-file" };
     try ap.addSubcommand(&cat_file);
     var cat_file_kind: argparse.Positional = .{ .name = "type", .description = "The type of the object to be read" };
     try cat_file.addPositional(&cat_file_kind);
     var cat_file_ref: argparse.Positional = .{ .name = "object", .description = "The object reference to read" };
     try cat_file.addPositional(&cat_file_ref);
 
     var hash_object: argparse.Subcommand = .{ .parent = &ap, .description = "Create a blob from a file", .name = "hash-object" };
     try ap.addSubcommand(&hash_object);
     var hash_object_write: argparse.Flag = .{ .long = "write", .short = "w", .description = "Actually write the file to the repository", .hasarg = false };
     try hash_object.addFlag(&hash_object_write);
     var hash_object_input: argparse.Positional = .{ .name = "file", .description = "The file to create a blob from" };
     try hash_object.addPositional(&hash_object_input);
 
     var log: argparse.Subcommand = .{ .parent = &ap, .description = "Log commits", .name = "log" };
     try ap.addSubcommand(&log);
     var log_commit: argparse.Positional = .{ .name = "commit", .description = "The commit to log from" };
     try log.addPositional(&log_commit);
 
     var ls_tree: argparse.Subcommand = .{ .parent = &ap, .description = "List items in a tree", .name = "ls-tree" };
     try ap.addSubcommand(&ls_tree);
     var ls_tree_recursive: argparse.Flag = .{ .long = "recursive", .short = "r", .description = "List contents recursively", .hasarg = false };
     try ls_tree.addFlag(&ls_tree_recursive);
     var ls_tree_ish: argparse.Positional = .{ .name = "tree-ish", .description = "The tree-ish to log the tree for" };
     try ls_tree.addPositional(&ls_tree_ish);
 
     var checkout: argparse.Subcommand = .{ .parent = &ap, .description = "Checkout a commit inside of a directory", .name = "checkout" };
     try ap.addSubcommand(&checkout);
     var checkout_ref: argparse.Positional = .{ .name = "commit", .description = "The ref to checkout (commit id, tag, or branch name" };
     try checkout.addPositional(&checkout_ref);
     var checkout_directory: argparse.Positional = .{ .name = "directory", .description = "The directory to checkout into" };
     try checkout.addPositional(&checkout_directory);
 
     var show_ref: argparse.Subcommand = .{ .parent = &ap, .description = "List references in a local repository", .name = "show-ref" };
     try ap.addSubcommand(&show_ref);
 
     var tag: argparse.Subcommand = .{ .parent = &ap, .description = "Manage tags", .name = "tag" };
     try ap.addSubcommand(&tag);
     var tag_name: argparse.Positional = .{ .name = "name", .description = "name for the new tag" };
     try tag.addPositional(&tag_name);
     var tag_object: argparse.Positional = .{ .name = "object", .description = "the object to add a tag for" };
     try tag.addPositional(&tag_object);
     var tag_annotated: argparse.Flag = .{ .long = "annotate", .short = "a", .description = "whether to create an annotated tag", .hasarg = false };
     try tag.addFlag(&tag_annotated);
 
     if (!try ap.parseOrHelp()) {
         return;
     }
     if (init.wasExecuted) {
         if (init_path.value) |path| {
             var repo = try repoCreate(a, path);
             defer repo.deinit();
         } else {
             std.log.err("No 'path' provided to init", .{});
             return error.InvalidArgs;
         }
     } else if (cat_file.wasExecuted) {
         if (cat_file_ref.value) |ref| {
             if (cat_file_kind.value) |kind_str| {
                 try catFile(a, std.fs.cwd(), kind_str, ref, std.io.getStdOut().writer().any());
             } else {
                 std.log.err("No type provided to cat-file", .{});
                 return error.InvalidArgs;
             }
         } else {
             std.log.err("No ref provided to cat-file", .{});
             return error.InvalidArgs;
         }
     } else if (hash_object.wasExecuted) {
         if (hash_object_input.value) |input| {
             try hashObject(a, std.fs.cwd(), input, hash_object_write.waspresent, std.io.getStdOut().writer().any());
         } else {
             std.log.err("No file supplied to hash-object", .{});
             return error.InvalidArgs;
         }
     } else if (log.wasExecuted) {
         if (log_commit.value) |ref| {
             try gitLog(a, std.fs.cwd(), ref, std.io.getStdOut().writer());
         } else {
             std.log.err("No commit supplied to log", .{});
         }
     } else if (ls_tree.wasExecuted) {
         if (ls_tree_ish.value) |ref| {
             try lsTree(a, std.fs.cwd(), ref, std.io.getStdOut().writer(), ls_tree_recursive.waspresent);
         } else {
             std.log.err("No commit supplied to ls-tree", .{});
         }
     } else if (checkout.wasExecuted) {
         if (checkout_ref.value) |commit_ref| {
             if (checkout_directory.value) |directory| {
                 try doCheckout(a, std.fs.cwd(), commit_ref, directory);
             } else {
                 std.log.err("No directory was supplied to checkout", .{});
             }
         } else {
             std.log.err("No commit supplied to checkout", .{});
         }
     } else if (show_ref.wasExecuted) {
         try doShowRef(a, std.fs.cwd(), std.io.getStdOut().writer());
     } else if (tag.wasExecuted) {
         if (tag_name.value) |tagname| {
             try doAddTag(a, std.fs.cwd(), tagname, tag_object.value, tag_annotated.waspresent);
         } else {
             try doListTags(a, std.fs.cwd(), std.io.getStdOut().writer());
         }
     } else {
         if (ap.excess.items.len > 0) {
             std.log.err("Unsupported sub-command {s}, have you tried implementing it yourself?", .{ap.excess.items[0]});
         } else {
             std.log.err("No sub-command requested", .{});
         }
         return error.InvalidArgs;
     }
 }
 
 fn doListTags(a: std.mem.Allocator, dir: std.fs.Dir, writer: anytype) !void {
     var repo = try repo_find(a, dir);
     defer repo.deinit();
     var refs = try repo.ref_list(a);
     defer {
         // TODO could do with a more convenient wrapper probably, maybe even an arena
         for (refs.keys()) |k| a.free(k);
         refs.deinit();
     }
     for (refs.keys()) |k| {
         const tags_prefix = "refs/tags/";
         if (std.mem.startsWith(u8, k, tags_prefix)) {
             try std.fmt.format(writer, "{s}\n", .{k[tags_prefix.len..]});
         }
     }
 }
 
 fn doAddTag(a: std.mem.Allocator, dir: std.fs.Dir, tagname: []const u8, maybe_ref: ?[]const u8, create_tag_obj: bool) !void {
     var repo = try repo_find(a, dir);
     defer repo.deinit();
     const ref: [20]u8 =
         if (maybe_ref) |rr|
         try repo.resolve(a, rr)
     else
         try repo.head(a);
     var ref_str = std.fmt.bytesToHex(ref, .lower);
 
     if (create_tag_obj) {
         const f = try runEditor(a, repo);
         defer f.close();
 
         var al = std.ArrayList(u8).init(a);
         defer al.deinit();
         const writer = al.writer();
         try std.fmt.format(writer, "object {s}\n", .{&ref_str});
         try std.fmt.format(writer, "type commit\n", .{});
         try std.fmt.format(writer, "tag {s}\n", .{tagname});
         try std.fmt.format(writer, "tagger \"Martin Ashby\"\n", .{});
         try writer.writeByte('\n');
         try pump(f.reader(), writer);
         try writer.writeByte('\n');
         var fbs = std.io.fixedBufferStream(al.items);
         const res = try repo.write_object(a, al.items.len, fbs.reader(), .tag, true);
         defer a.free(res);
         std.mem.copyForwards(u8, &ref_str, res);
     }
 
     const tagfilepath = try std.fs.path.join(a, &.{ "refs", "tags", tagname });
     defer a.free(tagfilepath);
     var tagfile = try repo.gitdir.createFile(tagfilepath, .{});
     defer tagfile.close();
     var wtr = tagfile.writer();
     try wtr.writeAll(&ref_str);
     try wtr.writeByte('\n');
 }
 
 // Caller must close the file
 fn runEditor(a: std.mem.Allocator, repo: GitRepository) !std.fs.File {
     const tempfilepath = try repo.makeTempFilePath(a);
     defer a.free(tempfilepath);
     // check the config, then the EDITOR
     const editor = if (repo.conf.get("core.editor")) |ed| ed else if (std.posix.getenv("EDITOR")) |ed2| ed2 else "nano";
     const args: []const []const u8 = &.{ editor, tempfilepath };
     var env = try std.process.getEnvMap(a);
     defer env.deinit();
     std.log.warn("Launching {s}", .{args});
     var child = std.process.Child.init(args, a);
     child.stdin_behavior = .Inherit;
     child.stdout_behavior = .Inherit;
     child.stderr_behavior = .Inherit;
     child.cwd_dir = repo.gitdir;
     child.env_map = &env;
     try child.spawn();
     const term = try child.wait();
     switch (term) {
         .Exited => |code| {
             if (code != 0) {
                 return error.SubprocessError;
             }
         },
         else => {
             return error.SubprocessError;
         },
     }
     return try repo.gitdir.openFile(tempfilepath, .{});
 }
 
 fn doShowRef(a: std.mem.Allocator, dir: std.fs.Dir, writer: anytype) !void {
     var repo = try repo_find(a, dir);
     defer repo.deinit();
     var refs = try repo.ref_list(a);
     defer {
         var it = refs.iterator();
         while (it.next()) |e| {
             a.free(e.key_ptr.*);
         }
         refs.deinit();
     }
     var it = refs.iterator();
     while (it.next()) |e| {
         try std.fmt.format(writer, "{} {s}\n", .{ std.fmt.fmtSliceHexLower(&(e.value_ptr.*)), e.key_ptr.* });
     }
 }
 
 fn doCheckout(a: std.mem.Allocator, dir: std.fs.Dir, checkout_ref: []const u8, checkout_directory: []const u8) !void {
     var repo = try repo_find(a, dir);
     defer repo.deinit();
     var checkoutDir = try dir.makeOpenPath(checkout_directory, .{ .iterate = true });
     defer checkoutDir.close();
     const ref = try repo.resolve(a, checkout_ref);
     var go = try repo.read_object_sha(a, ref);
     defer go.deinit();
     if (go.kind != .commit) return error.NotACommit;
     var it = checkoutDir.iterate();
     if (try it.next() != null) return error.DirNotEmpty;
 
     var commit = try Commit.parse(a, go.reader());
     defer commit.deinit(a);
     var go2 = try repo.read_object(a, commit.tree);
     defer go2.deinit();
     try doCheckoutInternal(a, &repo, &go2, checkoutDir);
 }
 
 fn doCheckoutInternal(a: std.mem.Allocator, repo: *GitRepository, go: *GitObject, dir: std.fs.Dir) !void {
     if (go.kind != .tree) return error.NotATree;
     var gt = try Tree.parse(a, go.reader());
     defer gt.deinit();
     for (gt.leaves.items) |leaf| {
         var go2 = try repo.read_object_sha(a, leaf.sha);
         defer go2.deinit();
         switch (leaf.filetype) {
             .file => {
                 var f = try dir.createFile(leaf.path, .{ .mode = leaf.mode });
                 defer f.close();
                 try pump(go2.reader(), f.writer());
             },
             .directory => {
                 var subdir = try dir.makeOpenPath(leaf.path, .{});
                 defer subdir.close();
                 try doCheckoutInternal(a, repo, &go2, subdir);
             },
             .symlink => {
                 return error.Unimplemented;
             },
             .submodule => {
                 return error.Unimplemented;
             },
         }
     }
 }
 
 fn lsTree(a: std.mem.Allocator, dir: Dir, ref: []const u8, writer: anytype, recurse: bool) !void {
     var repo = try repo_find(a, dir);
     defer repo.deinit();
     var go = try repo.read_object(a, ref);
     defer go.deinit();
     var go2: ?GitObject = go;
     defer if (go2) |*g| g.deinit();
     if (go.kind == .commit) {
         var gc = try Commit.parse(a, go.reader());
         defer gc.deinit(a);
         go2 = try repo.read_object(a, gc.tree);
     } else if (go.kind != .tree) {
         return error.NotATreeish;
     }
     try lsTreeInternal(a, &repo, &go2.?, writer, recurse, "");
 }
 
 fn lsTreeInternal(a: std.mem.Allocator, repo: *GitRepository, go: *GitObject, writer: anytype, recurse: bool, path_prefix: []const u8) !void {
     if (go.kind != .tree) return error.NotATree;
     var gt = try Tree.parse(a, go.reader());
     defer gt.deinit();
     for (gt.leaves.items) |leaf| {
         const filetype_str = switch (leaf.filetype) {
             .file => "blob",
             .directory => "tree",
             .symlink => "blob",
             .submodule => "submodule",
         };
         const fullpath = try std.fs.path.join(a, &.{ path_prefix, leaf.path });
         defer a.free(fullpath);
         if (recurse and leaf.filetype == .directory) {
             var go2 = try repo.read_object_sha(a, leaf.sha);
             defer go2.deinit();
             try lsTreeInternal(a, repo, &go2, writer, recurse, fullpath);
         } else {
             try std.fmt.format(writer, "{}{o:0>4} {s} {s}    {s}\n", .{ leaf.filetype, leaf.mode, filetype_str, std.fmt.fmtSliceHexLower(&leaf.sha), fullpath });
         }
     }
 }
 
 fn gitLog(a: std.mem.Allocator, dir: Dir, ref: []const u8, writer: anytype) !void {
     var repo = try repo_find(a, dir);
     defer repo.deinit();
     var seen = std.AutoHashMap([20]u8, void).init(a);
     defer seen.deinit();
     var sha: [20]u8 = undefined;
     _ = try std.fmt.hexToBytes(&sha, ref);
     try writer.writeAll("digraph wyaglog{\n");
     try writer.writeAll("  node[shape=rect]\n");
     try logGraphvis(a, repo, sha, &seen, writer.any());
     try writer.writeAll("}");
 }
 
 fn logGraphvis(a: std.mem.Allocator, repo: GitRepository, sha: [20]u8, seen: *std.AutoHashMap([20]u8, void), writer: std.io.AnyWriter) !void {
     const gpr = try seen.getOrPut(sha);
     if (gpr.found_existing) return; // short circuit we've already seen it
 
     var go = try repo.read_object_sha(a, sha);
     defer go.deinit();
     if (go.kind != .commit) return error.NotACommit;
     var commit = try Commit.parse(a, go.reader());
     defer commit.deinit(a);
 
     const ref = std.fmt.bytesToHex(sha, .lower);
     var spl = std.mem.splitScalar(u8, commit.message, '\n');
     const short_msg_bare = std.mem.trim(u8, spl.first(), " ");
 
     const short_msg_1 = try std.mem.replaceOwned(u8, a, short_msg_bare, "\\", "\\\\");
     defer a.free(short_msg_1);
     const short_msg_2 = try std.mem.replaceOwned(u8, a, short_msg_1, "\"", "\\\"");
     defer a.free(short_msg_2);
     try std.fmt.format(writer, "  c_{s} [label=\"{s}: {s}\"]\n", .{ ref, ref[0..7], short_msg_2 });
     for (commit.parents.items) |parent_ref| {
         try std.fmt.format(writer, "  c_{s} -> c_{s};\n", .{ ref, parent_ref });
         var child_sha: [20]u8 = undefined;
         _ = try std.fmt.hexToBytes(&child_sha, parent_ref);
         try logGraphvis(a, repo, child_sha, seen, writer);
     }
 }
 
 fn repoCreate(ca: std.mem.Allocator, path: []const u8) !GitRepository {
     var worktree: Dir = undefined;
     {
         var aa = std.heap.ArenaAllocator.init(ca);
         defer aa.deinit();
         const a = aa.allocator();
         const cwd = std.fs.cwd();
         worktree = try cwd.makeOpenPath(path, .{});
         errdefer worktree.close();
         var gitdir = try worktree.makeOpenPath(".git", .{});
         defer gitdir.close();
         try gitdir.makePath("branches");
         try gitdir.makePath("objects");
         try gitdir.makePath(try std.fs.path.join(a, &.{ "refs", "tags" }));
         try gitdir.makePath(try std.fs.path.join(a, &.{ "refs", "heads" }));
         var headfile = try gitdir.createFile("HEAD", .{});
         defer headfile.close();
         try headfile.writeAll("ref: refs/heads/main\n");
         var configfile = try gitdir.createFile("config", .{});
         defer configfile.close();
         try configfile.writeAll(
             \\[core]
             \\  repositoryformatversion = 0
             \\  filemode = false
             \\  bare = false
         );
     }
     return try GitRepository.init(ca, worktree);
 }
 
 fn catFile(a: std.mem.Allocator, cwd: std.fs.Dir, kind_str: []const u8, ref: []const u8, writer: std.io.AnyWriter) !void {
     const kind = try enumFromString(kind_str, ObjectKind);
     var repo = try repo_find(a, cwd);
     defer repo.deinit();
     var git_object = try repo.read_object(a, ref);
     defer git_object.deinit();
     if (git_object.kind != kind) {
         return error.WrongKind;
     }
     var rdr = git_object.reader();
     var buf = [_]u8{0} ** std.mem.page_size;
     while (true) {
         const sz = try rdr.read(&buf);
         if (sz == 0) break;
         try writer.writeAll(buf[0..sz]);
     }
 }
 
 fn hashObject(a: std.mem.Allocator, cwd: std.fs.Dir, file: []const u8, write: bool, writer: std.io.AnyWriter) !void {
     var repo = try repo_find(a, cwd);
     defer repo.deinit();
     const stat = try cwd.statFile(file);
     var infile = try std.fs.cwd().openFile(file, .{});
     const rdr = infile.reader();
     const sha = try repo.write_object(a, stat.size, rdr, .blob, write);
     defer a.free(sha);
     try writer.writeAll(sha);
     try writer.writeByte('\n');
 }
 
 pub const GitObject = struct {
     const ReadError = std.compress.zlib.Decompressor(std.fs.File.Reader).Error || error{ TooLong, InvalidHash };
 
     kind: ObjectKind,
     len: u64,
     sha1: [20]u8,
 
     _file: std.fs.File,
     _decomp: std.compress.zlib.Decompressor(std.fs.File.Reader),
     _sha1: std.crypto.hash.Sha1,
     _read: u64,
 
     pub fn read(self: *GitObject, buffer: []u8) ReadError!usize {
         const sz = try self._decomp.read(buffer);
         if (self._read + sz > self.len) {
             return error.TooLong;
         }
         self._read += sz;
         if (sz > 0) {
             self._sha1.update(buffer[0..sz]);
         } else {
             const final = self._sha1.finalResult();
             if (!std.mem.eql(u8, &self.sha1, &final)) {
                 return error.InvalidHash;
             }
         }
         return sz;
     }
 
     pub fn reader(self: *GitObject) std.io.Reader(*GitObject, ReadError, GitObject.read) {
         return .{
             .context = self,
         };
     }
 
     pub fn deinit(self: *GitObject) void {
         self._file.close();
     }
 };
 
 pub const GitRepository = struct {
     worktree: Dir,
     gitdir: Dir,
     conf: IniFile,
     _aa: std.heap.ArenaAllocator,
 
     // Note: takes 'ownership' of dir; callers should not use it again (including closing it) after calling
     // this function.
     pub fn init(ca: std.mem.Allocator, dir: Dir) !GitRepository {
         var self: GitRepository = undefined;
         self._aa = std.heap.ArenaAllocator.init(ca);
         errdefer self._aa.deinit();
         const a = self._aa.allocator();
 
         self.worktree = dir;
         errdefer self.worktree.close();
         self.gitdir = try self.worktree.openDir(".git", .{ .iterate = true });
         errdefer self.gitdir.close();
 
         const configcontent = try self.gitdir.readFileAlloc(a, "config", 10_000_000);
         self.conf = try IniFile.parse(a, configcontent);
         return self;
     }
 
     pub fn deinit(self: *GitRepository) void {
         safeclose(&self.gitdir);
         safeclose(&self.worktree);
         self._aa.deinit();
     }
 
     pub fn read_object_sha(self: GitRepository, a: std.mem.Allocator, sha: [20]u8) !GitObject {
         var ref = std.fmt.bytesToHex(sha, .lower);
         return self.read_object(a, &ref);
     }
 
     pub fn read_object(
         self: GitRepository,
         a: std.mem.Allocator,
         ref: []const u8,
     ) !GitObject {
         if (ref.len != 40) {
             return error.InvalidArgs;
         }
         const path = try std.fs.path.join(a, &.{ "objects", ref[0..2], ref[2..] });
         defer a.free(path);
         var file = try self.gitdir.openFile(path, .{});
         errdefer file.close();
         const file_reader = file.reader();
         var decomp = std.compress.zlib.decompressor(file_reader);
         const decomp_reader = decomp.reader();
         var sha1 = std.crypto.hash.Sha1.init(.{});
 
         const thehead = try decomp_reader.readUntilDelimiterAlloc(a, '\x00', 1024);
         defer a.free(thehead);
         sha1.update(thehead);
         sha1.update(&.{'\x00'});
         var spl = std.mem.splitScalar(u8, thehead, ' ');
         const kind_str = spl.first();
         const len_str = spl.rest();
         const kind = try enumFromString(kind_str, ObjectKind);
         const len = try std.fmt.parseInt(u64, len_str, 10);
         var expected_sha1: [20]u8 = undefined;
         _ = try std.fmt.hexToBytes(&expected_sha1, ref);
         return .{
             .kind = kind,
             .len = len,
             .sha1 = expected_sha1,
             ._file = file,
             ._decomp = decomp,
             ._sha1 = sha1,
             ._read = 0,
         };
     }
 
     // Caller must free the result
     pub fn makeTempFilePath(self: GitRepository, a: std.mem.Allocator) ![]const u8 {
         try self.gitdir.makePath("tmp");
         var rndm = prng.random();
         const tmpfilename = try std.fmt.allocPrint(a, "wyag-{}", .{rndm.int(u16)});
         defer a.free(tmpfilename);
         return try std.fs.path.join(a, &.{ "tmp", tmpfilename });
     }
 
     // Caller owns the response
     pub fn write_object(self: GitRepository, ca: std.mem.Allocator, len: u64, reader: anytype, kind: ObjectKind, write: bool) ![]const u8 {
         var aa = std.heap.ArenaAllocator.init(ca); // 3 lines saves many little 'free' calls through this function.
         defer aa.deinit();
         const a = aa.allocator();
         // Write the stuff to a temporary file and calculate the hash
         var sha1 = std.crypto.hash.Sha1.init(.{});
         const tmpfilepath = try self.makeTempFilePath(a);
         defer a.free(tmpfilepath);
         defer self.gitdir.deleteFile(tmpfilepath) catch {}; // not much we can do about this.
         {
             var tmpfile = try self.gitdir.createFile(tmpfilepath, .{});
             defer tmpfile.close();
             const tmpfile_writer = tmpfile.writer();
             var comp = try std.compress.zlib.compressor(tmpfile_writer, .{});
             const comp_writer = comp.writer();
             var comp_and_hash = std.compress.hashedWriter(comp_writer, &sha1);
             const comp_and_hash_writer = comp_and_hash.writer();
 
             try std.fmt.format(comp_and_hash_writer, "{s} {}\x00", .{ @tagName(kind), len }); // header
             var limited = std.io.limitedReader(reader, len);
             var limited_reader = limited.reader();
             var buf = [_]u8{0} ** std.mem.page_size;
             while (true) {
                 const sz = try limited_reader.read(&buf);
                 if (sz == 0) break;
                 try comp_and_hash_writer.writeAll(buf[0..sz]);
             }
             try comp.finish();
         }
 
         const ref = try std.fmt.allocPrint(a, "{s}", .{std.fmt.fmtSliceHexLower(&sha1.finalResult())});
         // now rename it into place once you have the hash
         if (write) {
             const path = try std.fs.path.join(a, &.{ "objects", ref[0..2], ref[2..] });
             const dn = std.fs.path.dirname(path).?;
             try self.gitdir.makePath(dn);
             try self.gitdir.rename(tmpfilepath, path);
         }
         return try ca.dupe(u8, ref);
     }
 
     pub fn head(self: GitRepository, a: std.mem.Allocator) ![20]u8 {
         const ref = try self.gitdir.readFileAlloc(a, "HEAD", 1024);
         defer a.free(ref);
         return try self.resolve(a, ref);
     }
 
     // Accepts
     //  a hexidecimal sha1
     //  or a branch name
     //  or a tag name
     //  or a ref string like "ref: refs/heads/blahh"
     // and returns the binary format sha1 after resolving that reference, following indirections
     // and tags
     pub fn resolve(self: GitRepository, a: std.mem.Allocator, ref: []const u8) ![20]u8 {
         const indirection_prefix = "ref: ";
         const max_ref_file_size = 1024;
 
         var trm = std.mem.trim(u8, ref, &std.ascii.whitespace);
         var obj = self.read_object(a, trm) catch |e| switch (e) {
             error.InvalidArgs, error.FileNotFound => {
                 if (std.mem.startsWith(u8, trm, indirection_prefix)) {
                     trm = trm[indirection_prefix.len..];
                 }
                 if (std.mem.startsWith(u8, trm, "refs/")) {
                     const ref2 = try self.gitdir.readFileAlloc(a, trm, max_ref_file_size);
                     defer a.free(ref2);
                     return try self.resolve(a, ref2);
                 } else {
                     const path1 = try std.fs.path.join(a, &.{ "refs", "heads", trm });
                     defer a.free(path1);
                     if (self.gitdir.readFileAlloc(a, path1, max_ref_file_size)) |ref2| {
                         defer a.free(ref2);
                         return try self.resolve(a, ref2);
                     } else |e2| {
                         if (e2 != error.FileNotFound) {
                             return e2;
                         }
                         const path2 = try std.fs.path.join(a, &.{ "refs", "tags", trm });
                         defer a.free(path2);
                         const ref2 = try self.gitdir.readFileAlloc(a, path2, max_ref_file_size);
                         defer a.free(ref2);
                         return try self.resolve(a, ref2);
                     }
                 }
             },
             else => return e,
         };
 
         defer obj.deinit();
         if (obj.kind == .tag) {
             var tag = try Tag.parse(a, obj.reader());
             defer tag.deinit(a);
             return h2bref(tag.object);
         } else {
             return h2bref(trm);
         }
     }
 
     test "resolve things" {
         const a = std.testing.allocator;
         var repo = try GitRepository.init(a, std.fs.cwd());
         defer repo.deinit();
         _ = try repo.resolve(a, "871ebbae8d66341336b5e29535300d7c284d0fa1");
         _ = try repo.resolve(a, "refs/heads/main");
         _ = try repo.resolve(a, "main");
         _ = try repo.resolve(a, "foo");
         _ = try repo.resolve(a, "ref: foo");
         try std.testing.expectError(error.FileNotFound, repo.resolve(a, "nope"));
     }
 
     // Caller owns the map and the keys to the map.
     pub fn ref_list(self: GitRepository, a: std.mem.Allocator) !std.StringArrayHashMap([20]u8) {
         var res = std.StringArrayHashMap([20]u8).init(a);
         errdefer {
             var it = res.iterator();
             while (it.next()) |e| {
                 a.free(e.key_ptr.*);
             }
             res.deinit();
         }
 
         const ref_dir = try self.gitdir.openDir("refs", .{ .iterate = true });
         var walker = try ref_dir.walk(a);
         defer walker.deinit();
         while (try walker.next()) |we| {
             if (we.kind == .file) {
                 const key = try std.fs.path.join(a, &.{ "refs", we.path });
                 errdefer a.free(key);
                 const indirect_ref = try std.fmt.allocPrint(a, "ref: {s}", .{key});
                 defer a.free(indirect_ref);
                 const ref = try self.resolve(a, indirect_ref);
                 try res.put(key, ref);
             }
         }
         const Srt = struct {
             map: std.StringArrayHashMap([20]u8),
             pub fn lessThan(slf: *@This(), ai: usize, bi: usize) bool {
                 const keys = slf.map.keys();
                 const ka = keys[ai];
                 const kb = keys[bi];
                 return std.mem.lessThan(u8, ka, kb);
             }
         };
         var srt = Srt{ .map = res };
         res.sort(&srt);
         return res;
     }
 };
 
 test "init repo" {
     var gr = try GitRepository.init(std.testing.allocator, std.fs.cwd());
     defer gr.deinit();
 }
 
 // takes ownership of "dir", the variable should not be used
 // by any other code after calling this function.
 fn repo_find(a: std.mem.Allocator, dir: Dir) !GitRepository {
     const stat = dir.statFile(".git") catch |e| switch (e) {
         error.FileNotFound => {
             // try the parent
             var parentdir = dir.openDir("..", .{ .iterate = true }) catch |e2| switch (e2) {
                 error.FileNotFound => return error.NoGitDirFound,
                 else => return e2,
             };
             errdefer parentdir.close();
             return repo_find(a, parentdir);
         },
         else => return e,
     };
     if (stat.kind == .directory) {
         return try GitRepository.init(a, dir);
     } else {
         return error.NoGitDirFound;
     }
 }
 
 // test "repo_find" {
 //     const srcdir = try std.fs.cwd().openDir("src/foo/bar/baz", .{ .iterate = true });
 //     var gr = try repo_find(std.testing.allocator, srcdir);
 //     defer gr.deinit();
 // }
 
 fn safeclose(dir: *Dir) void {
     if (std.fs.cwd().fd != dir.fd) {
         dir.close();
     }
 }
 
 // makes an enum from a string. Ronseal.
 fn enumFromString(str: []const u8, enum_type: type) !enum_type {
     const ti = @typeInfo(enum_type);
     inline for (ti.Enum.fields) |field| {
         if (std.mem.eql(u8, str, field.name)) {
             return @enumFromInt(field.value);
         }
     } else {
         return error.InvalidEnum;
     }
 }
 
 var prng: std.rand.DefaultPrng = undefined;
 
 const ObjectKind = enum {
     commit,
     tree,
     tag,
     blob,
 };
 
 const Kvlm = struct {
     headers: std.StringArrayHashMapUnmanaged(std.ArrayListUnmanaged([]const u8)),
     message: []const u8,
 
     pub fn parse(a: std.mem.Allocator, z_reader: anytype) !Kvlm {
         var cr = std.io.countingReader(z_reader);
         var reader = cr.reader();
 
         var al = std.ArrayList(u8).init(a);
         defer al.deinit();
 
         var headers = std.StringArrayHashMapUnmanaged(std.ArrayListUnmanaged([]const u8)){};
         errdefer {
             var it = headers.iterator();
             while (it.next()) |i| {
                 a.free(i.key_ptr.*);
                 for (i.value_ptr.*.items) |ii| {
                     a.free(ii);
                 }
                 i.value_ptr.*.deinit(a);
             }
             headers.deinit(a);
         }
 
         headers_loop: while (true) {
             const b = try reader.readByte();
             switch (b) {
                 '\n' => {
                     const b2 = try reader.readByte();
                     if (b2 == ' ') {
                         try al.append(b);
                         continue :headers_loop;
                     }
 
                     var spl = std.mem.splitScalar(u8, al.items, ' ');
                     const key = try a.dupe(u8, spl.first());
                     errdefer a.free(key);
                     const val = try a.dupe(u8, spl.rest());
                     errdefer a.free(val);
                     var gpr = try headers.getOrPut(a, key);
                     if (gpr.found_existing) {
                         a.free(key);
                         try gpr.value_ptr.*.append(a, val);
                     } else {
                         gpr.value_ptr.* = .{};
                         try gpr.value_ptr.append(a, val);
                     }
 
                     al.clearRetainingCapacity();
                     if (b2 == '\n') {
                         break :headers_loop;
                     } else {
                         try al.append(b2);
                     }
                 },
                 else => {
                     try al.append(b);
                 },
             }
         }
 
         // And the message is everything else
         try reader.readAllArrayList(&al, 1_000_000);
         const message = try al.toOwnedSlice();
         errdefer a.free(message);
 
         return .{
             .headers = headers,
             .message = message,
         };
     }
 
     pub fn deinit(self: *Kvlm, a: std.mem.Allocator) void {
         var it = self.headers.iterator();
         while (it.next()) |i| {
             a.free(i.key_ptr.*);
             for (i.value_ptr.*.items) |ii| {
                 a.free(ii);
             }
             i.value_ptr.*.deinit(a);
         }
         self.headers.deinit(a);
         a.free(self.message);
     }
 };
 
 const Commit = struct {
     _kvlm: Kvlm,
     tree: []const u8,
     parents: std.ArrayListUnmanaged([]const u8),
     author: []const u8,
     committer: ?[]const u8,
     gpgsig: ?[]const u8,
     message: []const u8,
 
     pub fn parse(a: std.mem.Allocator, z_reader: anytype) !Commit {
         var kvlm = try Kvlm.parse(a, z_reader);
         errdefer kvlm.deinit(a);
         return .{
             ._kvlm = kvlm,
             .tree = if (kvlm.headers.get("tree")) |tree| tree.items[0] else return error.InvalidCommit,
             .parents = kvlm.headers.get("parent") orelse .{},
             .author = if (kvlm.headers.get("author")) |tree| tree.items[0] else return error.InvalidCommit,
             .committer = if (kvlm.headers.get("committer")) |tree| tree.items[0] else null,
             .gpgsig = if (kvlm.headers.get("gpgsig")) |tree| tree.items[0] else null,
             .message = kvlm.message,
         };
     }
 
     pub fn deinit(self: *Commit, a: std.mem.Allocator) void {
         self._kvlm.deinit(a);
     }
 };
 
 const Tag = struct {
     _kvlm: Kvlm,
     object: []const u8,
     tag: []const u8,
     message: []const u8,
     pub fn parse(a: std.mem.Allocator, z_reader: anytype) !Tag {
         var kvlm = try Kvlm.parse(a, z_reader);
         errdefer kvlm.deinit(a);
         return .{
             ._kvlm = kvlm,
             .object = if (kvlm.headers.get("object")) |object| object.items[0] else return error.InvalidTag,
             .tag = if (kvlm.headers.get("tag")) |tag| tag.items[0] else return error.InvalidTag,
             .message = kvlm.message,
         };
     }
     pub fn deinit(self: *Tag, a: std.mem.Allocator) void {
         self._kvlm.deinit(a);
     }
 };
 
 test "parse commit" {
     const commit_str =
         \\tree 29ff16c9c14e2652b22f8b78bb08a5a07930c147
         \\parent 206941306e8a8af65b66eaaaea388a7ae24d49a0
         \\author Thibault Polge <thibault@thb.lt> 1527025023 +0200
         \\committer Thibault Polge <thibault@thb.lt> 1527025044 +0200
         \\gpgsig -----BEGIN PGP SIGNATURE-----
         \\ 
         \\ iQIzBAABCAAdFiEExwXquOM8bWb4Q2zVGxM2FxoLkGQFAlsEjZQACgkQGxM2FxoL
         \\ kGQdcBAAqPP+ln4nGDd2gETXjvOpOxLzIMEw4A9gU6CzWzm+oB8mEIKyaH0UFIPh
         \\ rNUZ1j7/ZGFNeBDtT55LPdPIQw4KKlcf6kC8MPWP3qSu3xHqx12C5zyai2duFZUU
         \\ wqOt9iCFCscFQYqKs3xsHI+ncQb+PGjVZA8+jPw7nrPIkeSXQV2aZb1E68wa2YIL
         \\ 3eYgTUKz34cB6tAq9YwHnZpyPx8UJCZGkshpJmgtZ3mCbtQaO17LoihnqPn4UOMr
         \\ V75R/7FjSuPLS8NaZF4wfi52btXMSxO/u7GuoJkzJscP3p4qtwe6Rl9dc1XC8P7k
         \\ NIbGZ5Yg5cEPcfmhgXFOhQZkD0yxcJqBUcoFpnp2vu5XJl2E5I/quIyVxUXi6O6c
         \\ /obspcvace4wy8uO0bdVhc4nJ+Rla4InVSJaUaBeiHTW8kReSFYyMmDCzLjGIu1q
         \\ doU61OM3Zv1ptsLu3gUE6GU27iWYj2RWN3e3HE4Sbd89IFwLXNdSuM0ifDLZk7AQ
         \\ WBhRhipCCgZhkj9g2NEk7jRVslti1NdN5zoQLaJNqSwO1MtxTmJ15Ksk3QP6kfLB
         \\ Q52UWybBzpaP9HEd4XnR+HuQ4k2K0ns2KgNImsNvIyFwbpMUyUWLMPimaV1DWUXo
         \\ 5SBjDB/V/W2JBFR+XKHFJeFwYhj7DD/ocsGr4ZMx/lgc8rjIBkI=
         \\ =lgTX
         \\ -----END PGP SIGNATURE-----
         \\
         \\Create first draft
     ;
     var fbs = std.io.fixedBufferStream(commit_str);
     const rdr = fbs.reader();
     var commit = try Commit.parse(std.testing.allocator, rdr);
     defer commit.deinit(std.testing.allocator);
 }
 
 pub const Tree = struct {
     pub const Leaf = struct {
         pub const FileType = enum {
             file,
             directory,
             symlink,
             submodule,
 
             pub fn parse(filetype_str: []const u8) !FileType {
                 return if (std.mem.eql(u8, filetype_str, "04")) .directory else if (std.mem.eql(u8, filetype_str, "10")) .file else if (std.mem.eql(u8, filetype_str, "12")) .symlink else if (std.mem.eql(u8, filetype_str, "16")) .submodule else return error.BadFiletype;
             }
             pub fn format(self: FileType, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
                 try writer.writeAll(switch (self) {
                     .file => "10",
                     .directory => "04",
                     .symlink => "12",
                     .submodule => "16",
                 });
             }
         };
         filetype: FileType,
         mode: u32,
         path: []const u8,
         sha: [20]u8,
     };
     aa: std.heap.ArenaAllocator,
     leaves: std.ArrayListUnmanaged(Leaf) = .{},
 
     pub fn parse(ca: std.mem.Allocator, reader: anytype) !Tree {
         var result: Tree = .{
             .aa = std.heap.ArenaAllocator.init(ca),
         };
         errdefer result.aa.deinit();
         const a = result.aa.allocator();
 
         while (try reader.readUntilDelimiterOrEofAlloc(a, '\x00', 1024)) |entry| {
             var spl = std.mem.splitScalar(u8, entry, ' ');
             const mode_str_bare = spl.first();
             const mode_str = try std.fmt.allocPrint(a, "{s:0>6}", .{mode_str_bare});
             const filetype_str = mode_str[0..2];
             const filetype: Leaf.FileType = try Leaf.FileType.parse(filetype_str);
             const path = spl.rest();
             var sha: [20]u8 = undefined;
             _ = try reader.readAll(&sha);
             try result.leaves.append(a, .{
                 .filetype = filetype,
                 .mode = try std.fmt.parseInt(u32, mode_str[2..], 8),
                 .path = path,
                 .sha = sha,
             });
         }
         return result;
     }
 
     pub fn deinit(self: *Tree) void {
         self.aa.deinit();
     }
 };
 
 test "parse tree" {
     const a = std.testing.allocator;
     var fbs = std.io.fixedBufferStream(@embedFile("sample.tree"));
     var tree = try Tree.parse(a, fbs.reader());
     defer tree.deinit();
 }
 
 fn pump(reader: anytype, writer: anytype) !void {
     var buf = [_]u8{0} ** std.mem.page_size;
     while (true) {
         const sz = try reader.read(&buf);
         if (sz == 0) break;
         try writer.writeAll(buf[0..sz]);
     }
 }
 
 fn h2bref(hex: []const u8) ![20]u8 {
     var res: [20]u8 = undefined;
     _ = try std.fmt.hexToBytes(&res, hex);
     return res;
 }