Skip to content
zit Artifact [23a9fa9c98]
Login

Artifact [23a9fa9c98]

Artifact 23a9fa9c98f211624340d4553b8b17ac223a54f58720a300a3209a4521bcff8e:


const std = @import("std");
const checkout = @import("zit").checkout;
const managed = @import("zit").managed;
const artifact = @import("zit").artifact;
const File = std.Io.File;
const support = @import("support.zig");
const addManaged = support.addManaged;
const appendArtifactAs = support.appendArtifactAs;
const appendDiffManifest = support.appendDiffManifest;
const commitHashDup = support.commitHashDup;
const corruptSection = support.corruptSection;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const fileExists = support.fileExists;
const findF = support.findF;
const freeResult = support.freeResult;
const initRepo = support.initRepo;
const parseCheckin = support.parseCheckin;
const readFile = support.readFile;
const readManagedImage = support.readManagedImage;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const seedCheckout = support.seedCheckout;
const tipHashOf = support.tipHashOf;
const writeFile = support.writeFile;

// ==========================================================================
// `zit diff` end-to-end. The public surface is deliberately a compact
// metadata report, not a text patch: only managed paths participate, compared
// with the checkout's resolved F-set. Each invocation must be read-only.
// ==========================================================================

test "cli diff --by, timeline -F html, ui: static renders land, the ui verb explains itself" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "f", "a\nb\nc\n");
    try addManaged(gpa, io, tmp.dir, &.{"f"});
    var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "first <one>" });
    defer freeResult(gpa, &c1);
    try expectExit(c1.term, 0);
    try writeFile(io, tmp.dir, "f", "a\nB\nc\nd\n");

    // --by writes a page and names it; no terminal, so nothing is opened.
    var by = try runZit(gpa, io, tmp.dir, &.{ "diff", "--by" });
    defer freeResult(gpa, &by);
    try expectExitDiag(by.term, 0, by);
    try std.testing.expect(std.mem.startsWith(u8, by.stdout, "wrote "));
    const page_path = std.mem.trimEnd(u8, by.stdout["wrote ".len..], "\n");
    const page = try std.Io.Dir.cwd().readFileAlloc(io, page_path, gpa, .limited(1 << 20));
    defer gpa.free(page);
    defer std.Io.Dir.cwd().deleteFile(io, page_path) catch {};
    try std.testing.expect(std.mem.indexOf(u8, page, "<table class=\"sbs\">") != null);
    try std.testing.expect(std.mem.indexOf(u8, page, "<tr class=\"chg\">") != null);
    try std.testing.expect(std.mem.indexOf(u8, page, "<tr class=\"ins\">") != null);
    try std.testing.expect(std.mem.indexOf(u8, page, "<h2>f</h2>") != null);

    // -F html: a table on stdout, text escaped.
    var tl = try runZit(gpa, io, tmp.dir, &.{ "timeline", "-F", "html" });
    defer freeResult(gpa, &tl);
    try expectExitDiag(tl.term, 0, tl);
    try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "<table class=\"timeline\">") != null);
    try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "first &lt;one&gt;") != null);
    try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "class=\"current\"") != null);

    // ui: reserved; says whose view it is and exits 1; help is exit 0.
    var ui = try runZit(gpa, io, tmp.dir, &.{"ui"});
    defer freeResult(gpa, &ui);
    try expectExit(ui.term, 1);
    try std.testing.expect(std.mem.indexOf(u8, ui.stderr, "quarry") != null);
    var uh = try runZit(gpa, io, tmp.dir, &.{ "ui", "--help" });
    defer freeResult(gpa, &uh);
    try expectExit(uh.term, 0);
    try std.testing.expect(std.mem.startsWith(u8, uh.stdout, "usage: zit ui"));
}

test "cli diff: PATH operands narrow, --numstat counts, --invert swaps, --checkin and --branch pick the pair" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try tmp.dir.createDirPath(io, "sub");
    try writeFile(io, tmp.dir, "f", "a\nb\n");
    try writeFile(io, tmp.dir, "sub/g", "x\n");
    try addManaged(gpa, io, tmp.dir, &.{ "f", "sub/g" });
    var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c1" });
    defer freeResult(gpa, &c1);
    try expectExit(c1.term, 0);
    try writeFile(io, tmp.dir, "f", "a\nc\nd\n");
    try writeFile(io, tmp.dir, "sub/g", "x\ny\n");
    var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c2" });
    defer freeResult(gpa, &c2);
    try expectExit(c2.term, 0);
    var side = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "side", "--branch", "side", "--allow-empty" });
    defer freeResult(gpa, &side);
    try expectExitDiag(side.term, 0, side);
    try writeFile(io, tmp.dir, "sub/g", "x\ny\nz\n");
    var s2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "s2" });
    defer freeResult(gpa, &s2);
    try expectExit(s2.term, 0);

    // Working tree: one edit; numstat counts it, a PATH operand narrows.
    try writeFile(io, tmp.dir, "f", "q\n");
    var ns = try runZit(gpa, io, tmp.dir, &.{ "diff", "--numstat" });
    defer freeResult(gpa, &ns);
    try expectExitDiag(ns.term, 0, ns);
    try std.testing.expectEqualStrings("1\t3\tf\n", ns.stdout);
    var only_sub = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "sub" });
    defer freeResult(gpa, &only_sub);
    try expectExitDiag(only_sub.term, 0, only_sub);
    try std.testing.expectEqualStrings("", only_sub.stdout);
    var only_f = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "f" });
    defer freeResult(gpa, &only_f);
    try std.testing.expectEqualStrings("M f\n", only_f.stdout);
    try tmp.dir.deleteFile(io, "f");
    var inv = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--invert" });
    defer freeResult(gpa, &inv);
    try std.testing.expectEqualStrings("A f\n", inv.stdout);
    var rv = try runZit(gpa, io, tmp.dir, &.{ "revert", "f" });
    defer freeResult(gpa, &rv);
    try expectExit(rv.term, 0);

    // --checkin V is V against its parent; --branch B is B's tip against its fork point.
    var ck = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "trunk", "--numstat" });
    defer freeResult(gpa, &ck);
    try expectExitDiag(ck.term, 0, ck);
    try std.testing.expectEqualStrings("2\t1\tf\n1\t0\tsub/g\n", ck.stdout);
    var br = try runZit(gpa, io, tmp.dir, &.{ "diff", "--branch", "side", "--numstat" });
    defer freeResult(gpa, &br);
    try expectExitDiag(br.term, 0, br);
    try std.testing.expectEqualStrings("1\t0\tsub/g\n", br.stdout);
    var both = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "trunk", "--branch", "side" });
    defer freeResult(gpa, &both);
    try expectExit(both.term, 2);
}

test "cli diff: an unborn managed regular file is added" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "new.txt", "new\n");
    try addManaged(gpa, io, tmp.dir, &.{"new.txt"});

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 0);
    try std.testing.expectEqualStrings("A new.txt\n", res.stdout);
    try std.testing.expectEqualStrings("", res.stderr);
}

test "cli diff: default output is unified hunks — worktree edits, rev-to-rev, added and deleted files, all through one renderer" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a.txt", "one\ntwo\nthree\n");
    try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
    const c1 = try commitHashDup(gpa, io, tmp.dir, "first");
    defer gpa.free(c1);

    // Worktree hunks: one changed line, three context... file too short for
    // full context — the hunk covers what exists.
    try writeFile(io, tmp.dir, "a.txt", "one\nTWO\nthree\n");
    {
        var res = try runZit(gpa, io, tmp.dir, &.{"diff"});
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings(
            "Index: a.txt\n==================================================================\n--- a.txt\n+++ a.txt\n@@ -1,3 +1,3 @@\n one\n-two\n+TWO\n three\n",
            res.stdout,
        );
    }

    // Rev-to-rev hunks with an added file: /dev/null headers on the new side.
    try writeFile(io, tmp.dir, "b.txt", "born\n");
    try addManaged(gpa, io, tmp.dir, &.{"b.txt"});
    const c2 = try commitHashDup(gpa, io, tmp.dir, "second");
    defer gpa.free(c2);
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2 });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings(
            "Index: a.txt\n==================================================================\n--- a.txt\n+++ a.txt\n@@ -1,3 +1,3 @@\n one\n-two\n+TWO\n three\n" ++
                "Index: b.txt\n==================================================================\n--- /dev/null\n+++ b.txt\n@@ -0,0 +1 @@\n+born\n",
            res.stdout,
        );
    }
    // Reversed: the added file renders as a deletion against /dev/null.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c2, "--to", c1 });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "Index: b.txt\n==================================================================\n--- b.txt\n+++ /dev/null\n@@ -1 +0,0 @@\n-born\n") != null);
    }
}

test "cli diff -w: whitespace-only changes vanish from hunks and from --brief, in both modes" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "ws.txt", "alpha\nbeta\n");
    try writeFile(io, tmp.dir, "real.txt", "keep\n");
    try addManaged(gpa, io, tmp.dir, &.{ "ws.txt", "real.txt" });
    const c1 = try commitHashDup(gpa, io, tmp.dir, "first");
    defer gpa.free(c1);

    // Reindent ws.txt only: a real byte change that is entirely whitespace.
    try writeFile(io, tmp.dir, "ws.txt", "    alpha\nbeta\t\n");

    // Worktree, hunks: visible without -w, gone with it.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{"diff"});
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") != null);
    }
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "-w" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("", res.stdout);
    }
    // Worktree, --brief: the file must not be listed at all under -w, and the
    // long spelling reaches the same path.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") != null);
    }
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--ignore-whitespace" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("", res.stdout);
    }

    // A genuine edit alongside the whitespace one: -w must still report it,
    // and must report ONLY it. This is what stops -w from being "show nothing".
    try writeFile(io, tmp.dir, "real.txt", "changed\n");
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "-w" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "real.txt") != null);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") == null);
    }

    // Rev-to-rev: same two questions across a commit boundary.
    const c2 = try commitHashDup(gpa, io, tmp.dir, "second");
    defer gpa.free(c2);
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2, "-w" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "real.txt") != null);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") == null);
    }
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2, "--brief", "-w" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("M real.txt\n", res.stdout);
    }
    // Without -w the same brief pair lists both files, so the assertions above
    // are about the flag and not about the fixture.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2, "--brief" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "ws.txt") != null);
        try std.testing.expect(std.mem.indexOf(u8, res.stdout, "real.txt") != null);
    }
}

test "cli diff: --from/--to compares two check-ins by name-status, in both directions; a lone flag is a usage error" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a.txt", "one\n");
    try writeFile(io, tmp.dir, "b.txt", "gone later\n");
    try addManaged(gpa, io, tmp.dir, &.{ "a.txt", "b.txt" });
    const c1 = try commitHashDup(gpa, io, tmp.dir, "first");
    defer gpa.free(c1);

    try writeFile(io, tmp.dir, "a.txt", "two\n");
    try writeFile(io, tmp.dir, "c.txt", "new\n");
    try addManaged(gpa, io, tmp.dir, &.{"c.txt"});
    {
        var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "b.txt" });
        defer freeResult(gpa, &rm);
        try expectExit(rm.term, 0);
    }
    const c2 = try commitHashDup(gpa, io, tmp.dir, "second");
    defer gpa.free(c2);

    // Forward: modified, deleted, added — in canonical path order.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--from", c1, "--to", c2 });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("M a.txt\nD b.txt\nA c.txt\n", res.stdout);
    }
    // Reversed operands: A and D swap, M stays.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--from", c2, "--to", c1 });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("M a.txt\nA b.txt\nD c.txt\n", res.stdout);
    }
    // Identical operands: silence.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief", "--from", c1, "--to", c1 });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("", res.stdout);
    }
    // The pair is required together.
    {
        var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1 });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 2);
        try std.testing.expect(std.mem.indexOf(u8, res.stderr, "--from and --to must be given together") != null);
    }
}

test "cli diff: a clean committed file is silent and arbitrary untracked paths are omitted" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "same\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    try writeFile(io, tmp.dir, "untracked.txt", "ignored\n");

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 0);
    try std.testing.expectEqualStrings("", res.stdout);
    try std.testing.expectEqualStrings("", res.stderr);
}

test "cli diff: a changed committed managed file is modified and leaves repository metadata byte-identical" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a.txt", "before\n");
    try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    try writeFile(io, tmp.dir, "a.txt", "after\n");

    const before_zit = try readFile(gpa, io, tmp.dir, ".zit");
    defer gpa.free(before_zit);
    const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(before_managed);

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 0);
    try std.testing.expectEqualStrings("M a.txt\n", res.stdout);
    try std.testing.expectEqualStrings("", res.stderr);

    const after_zit = try readFile(gpa, io, tmp.dir, ".zit");
    defer gpa.free(after_zit);
    const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(after_managed);
    try std.testing.expectEqualSlices(u8, before_zit, after_zit);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
}

test "cli diff: a baseline file removed from management is deleted and mixed changes are path-sorted" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a", "a0\n");
    try writeFile(io, tmp.dir, "b", "b0\n");
    try addManaged(gpa, io, tmp.dir, &.{ "a", "b" });
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    try writeFile(io, tmp.dir, "a", "a1\n");
    try writeFile(io, tmp.dir, "c", "c0\n");
    try addManaged(gpa, io, tmp.dir, &.{"c"});
    var remove = try runZit(gpa, io, tmp.dir, &.{ "rm", "b" });
    defer freeResult(gpa, &remove);
    try expectExit(remove.term, 0);

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 0);
    try std.testing.expectEqualStrings("M a\nD b\nA c\n", res.stdout);
    try std.testing.expectEqualStrings("", res.stderr);
    try std.testing.expect(fileExists(io, tmp.dir, "b")); // `rm` forgets, it does not unlink
}

test "cli diff: a managed filename uses section 4.3 escapes" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    const filename = "a b\tc\\d";
    try writeFile(io, tmp.dir, filename, "new\n");
    // `zit add` refuses a tab or backslash in a new name, but a checkout of a
    // manifest that carries one still tracks it; plant it the way that does.
    {
        var set = try managed.ManagedSet.read(gpa, io, tmp.dir);
        defer set.deinit();
        _ = try set.insert(filename);
        try set.write(io, tmp.dir);
    }

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 0);
    try std.testing.expectEqualStrings("A a\\sb\\tc\\\\d\n", res.stdout);
    try std.testing.expectEqualStrings("", res.stderr);
}

test "cli diff: a lowercase SHA-1 baseline is clean unchanged and modified when altered" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    const original = "same\n";
    try writeFile(io, tmp.dir, "sha1.txt", original);
    try addManaged(gpa, io, tmp.dir, &.{"sha1.txt"});

    const blob = try appendArtifactAs(gpa, io, tmp.dir, .sha1, original);
    defer gpa.free(blob);
    const f = [_]artifact.FCard{.{
        .filename = "sha1.txt",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    var manifest: artifact.Manifest = .{
        .arena_state = std.heap.ArenaAllocator.init(gpa),
        .kind = .manifest,
        .a = null,
        .b = null,
        .c = .{ .comment = "sha1-root" },
        .d = .{ .timestamp = "2020-01-01T00:00:00" },
        .e = null,
        .g = null,
        .h = null,
        .i = null,
        .k = null,
        .l = null,
        .n = null,
        .r = null,
        .u = .{ .login = "u" },
        .z = null,
        .w = null,
        .f = &f,
        .j = &.{},
        .m = &.{},
        .p = &.{},
        .q = &.{},
        .t = &.{},
    };
    defer manifest.deinit();
    const manifest_bytes = try artifact.create(&manifest, gpa);
    defer gpa.free(manifest_bytes);
    const checkin = try appendArtifactAs(gpa, io, tmp.dir, .sha1, manifest_bytes);
    defer gpa.free(checkin);
    try std.testing.expectEqual(@as(usize, 40), checkin.len);
    for (checkin) |ch| try std.testing.expect(std.ascii.isHex(ch) and !std.ascii.isUpper(ch));
    try seedCheckout(io, tmp.dir, checkin, "trunk");

    var clean = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &clean);
    try expectExit(clean.term, 0);
    try std.testing.expectEqualStrings("", clean.stdout);
    try std.testing.expectEqualStrings("", clean.stderr);

    try writeFile(io, tmp.dir, "sha1.txt", "changed\n");
    var changed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &changed);
    try expectExit(changed.term, 0);
    try std.testing.expectEqualStrings("M sha1.txt\n", changed.stdout);
    try std.testing.expectEqualStrings("", changed.stderr);
}

test "cli diff: a managed path replaced by a symlink is deleted without following its target" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "target", "same\n");
    try writeFile(io, tmp.dir, "link", "same\n");
    try addManaged(gpa, io, tmp.dir, &.{"link"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "root" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    try tmp.dir.deleteFile(io, "link");
    try tmp.dir.symLink(io, "target", "link", .{});

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 0);
    try std.testing.expectEqualStrings("D link\n", res.stdout);
    try std.testing.expectEqualStrings("", res.stderr);
}

test "cli diff: executable-bit-only change to a managed regular file is modified" {
    if (comptime !File.Permissions.has_executable_bit) return error.SkipZigTest;

    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);

    const original = "#!/bin/zit\nsame\n";
    try writeFile(io, tmp.dir, "script", original);
    try addManaged(gpa, io, tmp.dir, &.{"script"});
    {
        var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_write });
        defer script.close(io);
        try script.setPermissions(io, File.Permissions.executable_file);
    }
    const blob = try appendArtifactAs(gpa, io, tmp.dir, .sha1, original);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "script",
        .hash = blob,
        .perm = "x",
        .old_name = null,
        .mode = .executable,
    }};
    const baseline = try appendDiffManifest(gpa, io, tmp.dir, "executable-root", null, &files);
    defer gpa.free(baseline);
    var stored_baseline = try parseCheckin(gpa, io, tmp.dir, baseline);
    defer stored_baseline.deinit();
    try std.testing.expectEqual(artifact.FileMode.executable, (findF(stored_baseline.m, "script") orelse return error.MissingFCard).mode);
    try seedCheckout(io, tmp.dir, baseline, "trunk");

    var clean = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &clean);
    try expectExit(clean.term, 0);
    try std.testing.expectEqualStrings("", clean.stdout);
    try std.testing.expectEqualStrings("", clean.stderr);

    {
        var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_write });
        defer script.close(io);
        try script.setPermissions(io, File.Permissions.default_file);
    }
    var changed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &changed);
    try expectExit(changed.term, 0);
    try std.testing.expectEqualStrings("M script\n", changed.stdout);
    try std.testing.expectEqualStrings("", changed.stderr);
}

test "cli diff: a delta checkout resolves inherited managed files through its B-card" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);

    const original = "same\n";
    try writeFile(io, tmp.dir, "inherited.txt", original);
    try addManaged(gpa, io, tmp.dir, &.{"inherited.txt"});
    const blob = try appendArtifactAs(gpa, io, tmp.dir, .sha1, original);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "inherited.txt",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const baseline = try appendDiffManifest(gpa, io, tmp.dir, "full-root", null, &files);
    defer gpa.free(baseline);
    const delta = try appendDiffManifest(gpa, io, tmp.dir, "delta", baseline, &.{});
    defer gpa.free(delta);
    var stored_delta = try parseCheckin(gpa, io, tmp.dir, delta);
    defer stored_delta.deinit();
    try std.testing.expectEqualStrings(baseline, stored_delta.m.b.?.hash);
    try std.testing.expectEqual(@as(usize, 0), stored_delta.m.f.len);
    try seedCheckout(io, tmp.dir, delta, "trunk");

    var clean = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &clean);
    try expectExit(clean.term, 0);
    try std.testing.expectEqualStrings("", clean.stdout);
    try std.testing.expectEqualStrings("", clean.stderr);

    try writeFile(io, tmp.dir, "inherited.txt", "changed\n");
    var changed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &changed);
    try expectExit(changed.term, 0);
    try std.testing.expectEqualStrings("M inherited.txt\n", changed.stdout);
    try std.testing.expectEqualStrings("", changed.stderr);
}

test "cli diff: outside a repository fails with the shared discovery diagnostic" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 1);
    try std.testing.expectEqualStrings("", res.stdout);
    try std.testing.expectEqualStrings(
        "zit: no zit checkout here (looked for .zit-checkout in this directory and its parents)\n" ++
            "if this is a bare repository, name it with -R, or run 'zit open' to create a working tree\n",
        res.stderr,
    );
}

test "cli diff: a corrupt .zit-checkout fails without a partial diff" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    {
        var f = try tmp.dir.createFile(io, checkout.filename, .{});
        defer f.close(io);
        try f.writePositionalAll(io, &.{ 0xff, 0xff, 0xaa }, 0);
    }

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 1);
    try std.testing.expectEqualStrings("", res.stdout);
    try std.testing.expectEqualStrings(
        "zit diff: cannot read checkout state: .zit-checkout is corrupt\n",
        res.stderr,
    );
}

test "cli diff: a corrupt .zit-managed fails without a partial diff" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try corruptSection(io, tmp.dir, .managed);

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 1);
    try std.testing.expectEqualStrings("", res.stdout);
    try std.testing.expectEqualStrings(
        "zit diff: cannot read tracked files: .zit-checkout is corrupt\n",
        res.stderr,
    );
}

test "cli diff: a current delta checkout with an absent B-card baseline fails without a partial diff" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    const absent_baseline = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
    const delta = try appendDiffManifest(gpa, io, tmp.dir, "missing-baseline", absent_baseline, &.{});
    defer gpa.free(delta);
    try seedCheckout(io, tmp.dir, delta, "trunk");

    var res = try runZit(gpa, io, tmp.dir, &.{ "diff", "--brief" });
    defer freeResult(gpa, &res);
    try expectExit(res.term, 1);
    try std.testing.expectEqualStrings("", res.stdout);
    try std.testing.expectEqualStrings("zit diff: cannot resolve baseline\n", res.stderr);
}

test "cli diff: help is the sole option and invalid arguments are usage errors" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    inline for (.{ "--help", "-h" }) |flag| {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        var help = try runZit(gpa, io, tmp.dir, &.{ "diff", flag });
        defer freeResult(gpa, &help);
        try expectExit(help.term, 0);
        try std.testing.expect(std.mem.startsWith(u8, help.stdout, "usage: zit diff [--brief|--numstat|--by|-F json] [-w|-Z] [-c N] [--invert]\n                [-N] [--from CHECKIN --to CHECKIN | --checkin V | --branch B]\n"));
        try std.testing.expect(std.mem.indexOf(u8, help.stdout, "--exit-code") == null);
        try std.testing.expectEqualStrings("", help.stderr);
    }

    {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        var unknown = try runZit(gpa, io, tmp.dir, &.{ "diff", "-x" });
        defer freeResult(gpa, &unknown);
        try expectExit(unknown.term, 2);
        try std.testing.expectEqualStrings("", unknown.stdout);
        try std.testing.expectEqualStrings(
            "zit diff: unknown option '-x'\ntry 'zit diff --help'\n",
            unknown.stderr,
        );
    }

    {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        var positional = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from" }); // a value-less flag; bare words are PATH operands now
        defer freeResult(gpa, &positional);
        try expectExit(positional.term, 2);
        try std.testing.expectEqualStrings("", positional.stdout);
        try std.testing.expectEqualStrings(
            "zit diff: unknown option '--from'\ntry 'zit diff --help'\n",
            positional.stderr,
        );
    }
}

test "cli diff -F json: a two-check-in comparison in Fossil's field names, every kind of change, binary marked" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "n.md", "one\ntwo\n");
    try writeFile(io, tmp.dir, "b.bin", "x\x00y");
    try writeFile(io, tmp.dir, "g.md", "gone\n");
    try addManaged(gpa, io, tmp.dir, &.{ "n.md", "b.bin", "g.md" });
    var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "first" });
    defer freeResult(gpa, &c1);
    try expectExitDiag(c1.term, 0, c1);
    try writeFile(io, tmp.dir, "n.md", "one\nTWO\n");
    try writeFile(io, tmp.dir, "b.bin", "x\x00z");
    var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "g.md" });
    defer freeResult(gpa, &rm);
    try expectExitDiag(rm.term, 0, rm);
    try writeFile(io, tmp.dir, "new.md", "hi\n");
    try addManaged(gpa, io, tmp.dir, &.{"new.md"});
    var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
    defer freeResult(gpa, &c2);
    try expectExitDiag(c2.term, 0, c2);

    var d = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "tip", "-F", "json" });
    defer freeResult(gpa, &d);
    try expectExitDiag(d.term, 0, d);
    var doc = try std.json.parseFromSlice(std.json.Value, gpa, d.stdout, .{});
    defer doc.deinit();
    const root = doc.value.object;
    try std.testing.expectEqual(@as(i64, 1), root.get("schema_version").?.integer);
    try std.testing.expect(root.get("from").? == .string and root.get("to").? == .string);
    const files = root.get("files").?.array.items;
    try std.testing.expectEqual(@as(usize, 4), files.len);
    const want = [_]struct { name: []const u8, state: []const u8, binary: bool, diff: ?[]const u8 }{
        .{ .name = "b.bin", .state = "modified", .binary = true, .diff = null },
        .{ .name = "g.md", .state = "removed", .binary = false, .diff = "@@ -1 +0,0 @@\n-gone\n" },
        .{ .name = "n.md", .state = "modified", .binary = false, .diff = "@@ -1,2 +1,2 @@\n one\n-two\n+TWO\n" },
        .{ .name = "new.md", .state = "added", .binary = false, .diff = "@@ -0,0 +1 @@\n+hi\n" },
    };
    for (files, want) |f, w| {
        const o = f.object;
        try std.testing.expectEqualStrings(w.name, o.get("name").?.string);
        try std.testing.expectEqualStrings(w.state, o.get("state").?.string);
        try std.testing.expectEqual(w.binary, o.get("binary").?.bool);
        if (w.diff) |text| try std.testing.expectEqualStrings(text, o.get("diff").?.string) else try std.testing.expect(o.get("diff").? == .null);
        try std.testing.expectEqual(std.mem.eql(u8, w.state, "removed"), o.get("uuid").? == .null);
        try std.testing.expectEqual(std.mem.eql(u8, w.state, "added"), o.get("parent").? == .null);
    }

    var wt = try runZit(gpa, io, tmp.dir, &.{ "diff", "-F", "json" });
    defer freeResult(gpa, &wt);
    try expectExit(wt.term, 2);
    var mixed = try runZit(gpa, io, tmp.dir, &.{ "diff", "--checkin", "tip", "-F", "json", "--brief" });
    defer freeResult(gpa, &mixed);
    try expectExit(mixed.term, 2);
}

test "cli diff: a version whose content was shunned is refused, never shown as an emptied file" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    var hashes: [3][]u8 = undefined;
    var made: usize = 0;
    defer for (hashes[0..made]) |h| gpa.free(h);
    for ([_][]const u8{ "v1\n", "v2\n", "v3\n" }, 0..) |body, i| {
        try writeFile(io, tmp.dir, "n.md", body);
        if (i == 0) try addManaged(gpa, io, tmp.dir, &.{"n.md"});
        var c = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", body });
        defer freeResult(gpa, &c);
        try expectExitDiag(c.term, 0, c);
        hashes[i] = try tipHashOf(gpa, io, tmp.dir, "trunk");
        made += 1;
    }
    var v2_digest: [32]u8 = undefined;
    std.crypto.hash.sha3.Sha3_256.hash("v2\n", &v2_digest, .{});
    const v2_blob = std.fmt.bytesToHex(v2_digest, .lower);
    var sh = try runZit(gpa, io, tmp.dir, &.{ "shun", "--force", &v2_blob });
    defer freeResult(gpa, &sh);
    try expectExitDiag(sh.term, 0, sh);

    for ([_][2][]const u8{ .{ hashes[0], hashes[1] }, .{ hashes[1], hashes[2] } }) |pair| {
        var d = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", pair[0], "--to", pair[1] });
        defer freeResult(gpa, &d);
        // Exit 8: absent by policy, told apart from damage (exit 1).
        try expectExitDiag(d.term, 8, d);
        try std.testing.expect(std.mem.indexOf(u8, d.stdout, "@@") == null);
        try std.testing.expect(std.mem.indexOf(u8, d.stderr, "is shunned in this repository") != null);
    }
    // Versions on either side of the shunned one still compare.
    var d13 = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", hashes[0], "--to", hashes[2] });
    defer freeResult(gpa, &d13);
    try expectExitDiag(d13.term, 0, d13);
    try std.testing.expect(std.mem.indexOf(u8, d13.stdout, "+v3") != null);
}

test "cli diff -R: the check-in pair works from a bare store, worktree mode still refuses" {
    // Goal: `diff --from A --to B` touches no working tree, so
    // -R serves it from a bare store (hunks and --brief both); the worktree
    // comparison keeps refusing -R with the works-in-a-checkout diagnostic.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "f.txt", "alpha\n");
    try addManaged(gpa, io, tmp.dir, &.{"f.txt"});
    const c1 = try commitHashDup(gpa, io, tmp.dir, "one");
    defer gpa.free(c1);
    try writeFile(io, tmp.dir, "f.txt", "alpha\nbeta\n");
    const c2 = try commitHashDup(gpa, io, tmp.dir, "two");
    defer gpa.free(c2);

    var away = std.testing.tmpDir(.{}); // no checkout anywhere in sight
    defer away.cleanup();
    const cwd = try std.process.currentPathAlloc(io, gpa);
    defer gpa.free(cwd);
    const store_abs = try std.fs.path.join(gpa, &.{ cwd, ".zig-cache", "tmp", &tmp.sub_path });
    defer gpa.free(store_abs);

    var hunks = try runZit(gpa, io, away.dir, &.{ "diff", "-R", store_abs, "--from", c1, "--to", c2 });
    defer freeResult(gpa, &hunks);
    try expectExitDiag(hunks.term, 0, hunks);
    try std.testing.expect(std.mem.indexOf(u8, hunks.stdout, "+beta") != null);

    var brief = try runZit(gpa, io, away.dir, &.{ "diff", "-R", store_abs, "--brief", "--from", c1, "--to", c2 });
    defer freeResult(gpa, &brief);
    try expectExitDiag(brief.term, 0, brief);
    try std.testing.expectEqualStrings("M f.txt\n", brief.stdout);

    // In-checkout from/to with -R agrees byte-for-byte with the plain form.
    var plain = try runZit(gpa, io, tmp.dir, &.{ "diff", "--from", c1, "--to", c2 });
    defer freeResult(gpa, &plain);
    try expectExitDiag(plain.term, 0, plain);
    try std.testing.expectEqualStrings(plain.stdout, hunks.stdout);

    // The worktree comparison refuses -R, naming the remedy.
    var wt = try runZit(gpa, io, away.dir, &.{ "diff", "-R", store_abs });
    defer freeResult(gpa, &wt);
    try expectExit(wt.term, 1);
    try std.testing.expectEqualStrings("", wt.stdout);
    try std.testing.expect(std.mem.indexOf(u8, wt.stderr, "needs --from/--to, --checkin or --branch") != null);
}