//! `zit undo` / `zit redo`: single-level undo and redo of the working-file
//! mutators; the two verbs share one body.
const std = @import("std");
const cli = @import("zit").cli;
const update = @import("zit").update;
const diagnostics = @import("../diagnostics.zig");
const help_pages = @import("../help.zig");
const not_a_repo_msg = diagnostics.not_a_repo_msg;
const undo_help = help_pages.undo_help;
const redo_help = help_pages.redo_help;
// ==========================================================================
// `zit undo` / `zit redo` — single-level undo/redo of the working-file mutators
// (contracts/undo.md B-undo-1..21). Thin wiring: parse (help-only, no
// positionals), discover the root BEFORE any journal read (B-undo-19), then
// drive the `update.journal` swap. All format/slot work lives in `undo.zig`;
// restoration reuses the update layer. No log append, no network.
// ==========================================================================
const UndoKind = enum { undo, redo };
/// `zit undo` — reverse the last sheltered working-file mutation.
pub fn runUndo(
gpa: std.mem.Allocator,
io: std.Io,
arena: std.mem.Allocator,
verb_args: []const []const u8,
streams: cli.Streams,
) cli.Exit {
return runUndoRedo(gpa, io, arena, verb_args, streams, .undo);
}
/// `zit redo` — reapply the change a preceding `zit undo` reversed.
pub fn runRedo(
gpa: std.mem.Allocator,
io: std.Io,
arena: std.mem.Allocator,
verb_args: []const []const u8,
streams: cli.Streams,
) cli.Exit {
return runUndoRedo(gpa, io, arena, verb_args, streams, .redo);
}
/// The shared body: the two verbs differ only in name, help text, which journal
/// slot they consume, and the "nothing to …" phrasing (Ousterhout: one
/// mechanism, not two near-identical copies).
fn runUndoRedo(
gpa: std.mem.Allocator,
io: std.Io,
arena: std.mem.Allocator,
verb_args: []const []const u8,
streams: cli.Streams,
kind: UndoKind,
) cli.Exit {
const verb = switch (kind) {
.undo => "undo",
.redo => "redo",
};
const help_text = switch (kind) {
.undo => undo_help,
.redo => redo_help,
};
// Usage errors are exit 2, stderr-only, and read no journal (B-undo-17/18);
// `-h`/`--help` win over any trailing token and print to stdout (B-undo-16).
const parsed = switch (cli.parseUndoArgs(verb_args)) {
.ok => |p| p,
.unknown_option => |tok| return cli.usageError(streams, verb, .unknown_option, tok),
.extra_argument => |tok| return cli.usageError(streams, verb, .extra_argument, tok),
};
if (parsed.help) {
streams.out.writeAll(help_text) catch {};
return .ok;
}
// B-undo-19: the repository check precedes any journal read; absent → the
// standard not-a-zit-repository diagnostic, exit 1 (distinct from exit 2).
const root = (cli.discoverRoot(arena, io) catch {
streams.err.print("zit {s}: out of memory\n", .{verb}) catch {};
return .failure;
}) orelse {
streams.err.writeAll(not_a_repo_msg) catch {};
return .failure;
};
var root_dir = root.dir;
defer root_dir.close(io);
const dir: update.journal.Direction = if (kind == .undo) .undo_dir else .redo_dir;
if (parsed.dry_run) {
// Name what the swap would touch, touching nothing.
const pk = update.journal.peek(arena, io, root_dir, dir) catch |err| return undoFail(streams, verb, err);
for (pk.paths) |path| streams.out.print("{s} would restore {s}\n", .{ verb, path }) catch {};
if (pk.restores_checkout) streams.out.print("{s} would restore the checkout record\n", .{verb}) catch {};
return .ok;
}
const pk = update.journal.peek(arena, io, root_dir, dir) catch |err| return undoFail(streams, verb, err);
(switch (kind) {
.undo => update.journal.undo(gpa, io, root_dir),
.redo => update.journal.redo(gpa, io, root_dir),
}) catch |err| return undoFail(streams, verb, err);
// Fossil's per-file rows, then the confirmation row, all on stdout
// (B-undo-20); diagnostics never share the stream.
const word: []const u8 = if (kind == .undo) "UNDO " else "REDO ";
for (pk.paths) |path| streams.out.print("{s} {s}\n", .{ word, path }) catch {};
streams.out.print("{s}: working tree restored\n", .{verb}) catch {};
return .ok;
}
/// Renders a `JournalError` to stderr and returns `.failure` (exit 1). `Empty`
/// is the nothing-to-undo/redo case (B-undo-9/10); `Corrupt` the damaged
/// journal (B-undo-11); the rest are honest device/allocation faults.
fn undoFail(s: cli.Streams, verb: []const u8, err: update.journal.JournalError) cli.Exit {
switch (err) {
error.Empty => s.err.print("zit {s}: nothing to {s}\n", .{ verb, verb }) catch {},
error.Corrupt => s.err.print("zit {s}: the undo journal is damaged\n", .{verb}) catch {},
error.Storage => s.err.print("zit {s}: cannot restore working tree: input/output error\n", .{verb}) catch {},
error.OutOfMemory => s.err.print("zit {s}: out of memory\n", .{verb}) catch {},
}
return .failure;
}