summaryrefslogtreecommitdiff
path: root/src/hunks.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 03:51:15 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commit79a1e816ceb13ef81b712007716c8add2de75434 (patch)
tree1714b1bf19da3a58be2623ffe29e3f8be1b21fe3 /src/hunks.zig
parenta22b579ad2df8d1811f0e194fa1bbc06e2282cf8 (diff)
parentf1af015f01e4e8d42f6224c4d4063f3aea218f5a (diff)
downloadpardes-79a1e816ceb13ef81b712007716c8add2de75434.tar.gz
pardes-79a1e816ceb13ef81b712007716c8add2de75434.zip
integration: the terminal a module of its own, with the plumber whole and the walker's cheaper compile
A merge of term-phase1a and pardes-next, no conflicts. core-test (the core with no terminal) 411 passed, 535 skipped of 946; shell-test (the same tests, the terminal compiled in) 989/989, on tui. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'src/hunks.zig')
-rw-r--r--src/hunks.zig118
1 files changed, 68 insertions, 50 deletions
diff --git a/src/hunks.zig b/src/hunks.zig
index afd2ac9d..2fa86ccd 100644
--- a/src/hunks.zig
+++ b/src/hunks.zig
@@ -601,45 +601,83 @@ fn trimmedWidth(section: []const u8) usize {
// ---- the +Diff in the editor ----
//
-// Its word (Diff), the open and the text it goes back to; and the three
-// hooks the generic code calls, one call each (look.zig's bare look and
-// commit look, ninep/ctl.zig's filled +Pager), which a plumber's rules
-// would replace.
+// Its word (Diff), the open and the text it goes back to, and the
+// restack of a paged diff. A bare look at a .diff, a commit hash and a
+// paged diff are plumbing rules (src/plumbing) that start Diff or ask the
+// edit port to show the diff (Plumb.show).
-/// The `Diff` word (builtins.zig registers it): on a +Diff, the diff it
-/// stacks as text; on a diff, its hunks stacked in a +Diff.
+/// The `Diff` word (builtins.zig registers it). Bare, on a +Diff, the diff
+/// it stacks as text; on a diff, its hunks stacked in a +Diff. With a file
+/// (a .diff, a .patch: relative to the pane's directory), its hunks
+/// stacked so; with a revision (7 to 40 lowercase hex digits, a letter and
+/// a digit among them), `git show` of it, paged into a +Pager that stacks
+/// its hunks (ctl.fillPager), run in the pane's git work tree. A plumbing
+/// rule's Diff that cannot (no hunk, no work tree) declines, saying
+/// nothing (Pardes.plumb_declined), and the look looks itself.
pub fn word(c: pardes.builtins.Ctx) void {
- const f = &c.pane.file.?;
- if (diffSource(c.p, f)) |source| return showDiffText(c.p, c.id, source);
- _ = openDiff(c.p, c.id, f.path, f.content) catch |err| switch (err) {
- error.NoHunks => c.p.reportFailure(c.id, "Diff: no hunk in it"),
- else => c.p.reportError(c.id, "hunks", err),
+ const p = c.p;
+ const arg = std.mem.trim(u8, c.arg orelse "", " \t\r\n");
+ if (arg.len == 0) {
+ if (!shows(c.pane)) return p.reportFailure(c.id, "Diff: only a diff or a +Diff pane takes it");
+ const f = &c.pane.file.?;
+ if (diffSource(p, f)) |source| return showDiffText(p, c.id, source);
+ _ = openDiff(p, c.id, f.path, f.content) catch |err| switch (err) {
+ error.NoHunks => p.reportFailure(c.id, "Diff: no hunk in it"),
+ else => p.reportError(c.id, "hunks", err),
+ };
+ return;
+ }
+ if (isCommitHash(arg)) {
+ var dir = pardes.filesystem.localPath(Pardes.paneDir(c.pane)) orelse return declined(p, c.id, "Diff: not in a git work tree");
+ while (true) {
+ var buf: [4096]u8 = undefined;
+ const dot_git = std.fmt.bufPrint(&buf, "{s}/.git", .{dir}) catch return declined(p, c.id, "Diff: not in a git work tree");
+ if (pardes.exec.kindOf(dot_git) != null) break;
+ dir = std.Io.Dir.path.dirname(dir) orelse return declined(p, c.id, "Diff: not in a git work tree");
+ }
+ // ponytail: a hex word that names no commit leaves git's error in a command pane, not a search; check the object first if that bites.
+ var line: [64]u8 = undefined;
+ const dst = pardes.exec.execute(p, c.id, std.fmt.bufPrint(&line, "git show {s}", .{arg}) catch unreachable) orelse return;
+ if (p.panes[dst]) |cp| cp.command_pages = true;
+ return;
+ }
+ var buf: [4096]u8 = undefined;
+ const path = if (arg[0] == '/') arg else std.fmt.bufPrint(&buf, "{s}/{s}", .{ std.mem.trimEnd(u8, Pardes.paneDir(c.pane), "/"), arg }) catch arg;
+ const bytes = pardes.filesystem.read(p, path) catch |err| {
+ if (p.plumb_declined != null) return declined(p, c.id, "");
+ return p.reportError(c.id, path, err);
+ };
+ defer p.gpa.free(bytes);
+ p.view().active = openDiff(p, c.id, path, bytes) catch |err| switch (err) {
+ error.NoHunks => return declined(p, c.id, "Diff: no hunk in it"),
+ else => {
+ if (p.plumb_declined != null) return declined(p, c.id, "");
+ return p.reportError(c.id, "hunks", err);
+ },
};
}
-/// A pane the word works on: a diff (a .diff, a .patch, a +Pager holding
-/// one) or a +Diff.
-pub fn shows(pane: *const Pane) bool {
- const f = pane.file orelse return false;
- return pane.colorAlgo() == .diff or (f.output != null and std.meta.eql(f.output.?.from, Output.Origin{ .cmd = .Diff }));
+/// A Diff that cannot do what it was asked: a plumbing rule's declines,
+/// saying nothing; one typed says `why`.
+fn declined(p: *Pardes, id: usize, why: []const u8) void {
+ if (p.plumb_declined) |*d| {
+ d.* = true;
+ return;
+ }
+ p.reportFailure(id, why);
}
-/// The hook of a bare look at a .diff or a .patch (look.zig's open): its
-/// hunks stacked in a +Diff, which takes the keyboard as the file would;
-/// false, for look to open it as text, when it is no such file, a place in
-/// one, one with no hunk, or the text is what is asked (showDiffText).
-pub fn lookedAt(p: *Pardes, id: usize, path: []const u8, at: pardes.look.Spot) bool {
- if (p.look_text or at.line != 0 or !(std.mem.endsWith(u8, path, ".diff") or std.mem.endsWith(u8, path, ".patch"))) return false;
- const bytes = pardes.filesystem.read(p, path) catch return false;
- defer p.gpa.free(bytes);
- p.view().active = openDiff(p, id, path, bytes) catch return false;
- return true;
+/// A pane the bare word works on: a diff (a .diff, a .patch, a +Pager
+/// holding one) or a +Diff.
+fn shows(pane: *const Pane) bool {
+ const f = pane.file orelse return false;
+ return pane.colorAlgo() == .diff or (f.output != null and std.meta.eql(f.output.?.from, Output.Origin{ .cmd = .Diff }));
}
-/// The hook of a +Pager filled with a diff (ninep/ctl.zig's fillPager:
-/// `git show`, difftui's patches): its hunks stacked in a +Diff in the
-/// +Pager's place, the +Pager closed. The keyboard stays where it was, as
-/// a page's.
+/// A pane holding a diff (a +Pager filled with one: `git show`, difftui's
+/// patches; the edit port's `showdiff`, Plumb.show): its hunks stacked in
+/// a +Diff in its place, the pane closed. The keyboard stays where it was,
+/// as a page's.
pub fn paged(p: *Pardes, id: usize) void {
const f = &p.panes[id].?.file.?;
const keyboard = p.view().active;
@@ -650,26 +688,6 @@ pub fn paged(p: *Pardes, id: usize) void {
if (p.panes[keyboard] != null) p.view().active = keyboard;
}
-/// The hook of a commit hash (7 to 40 hex digits, a letter and a digit
-/// among them; look.zig's look at a word) looked at inside a git repository: `git show` it, paged into a +Pager,
-/// which stacks its hunks in a +Diff (ctl.fillPager); the command pane
-/// goes when it succeeds (Pane.commandDone).
-// ponytail: a hex word that names no commit leaves git's error in a command pane, not a search; check the object first if that bites.
-pub fn lookedAtCommit(p: *Pardes, id: usize, pane: *Pane, hash: []const u8) bool {
- if (!isCommitHash(hash)) return false;
- var dir = pardes.filesystem.localPath(Pardes.paneDir(pane)) orelse return false;
- while (true) {
- var buf: [4096]u8 = undefined;
- const dot_git = std.fmt.bufPrint(&buf, "{s}/.git", .{dir}) catch return false;
- if (pardes.exec.kindOf(dot_git) != null) break;
- dir = std.Io.Dir.path.dirname(dir) orelse return false;
- }
- var line: [64]u8 = undefined;
- const dst = pardes.exec.execute(p, id, std.fmt.bufPrint(&line, "git show {s}", .{hash}) catch return false) orelse return true;
- if (p.panes[dst]) |c| c.command_pages = true;
- return true;
-}
-
fn isCommitHash(hex: []const u8) bool {
if (hex.len < 7 or hex.len > 40) return false;
var digit = false;