summaryrefslogtreecommitdiff
path: root/src/Output.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-22 09:50:43 -0300
committerGabriel Schneider <[email protected]>2026-10-22 10:03:24 -0300
commita8b457a306a4442975210bcac3f04b56513c61c3 (patch)
tree6e2026ecb15da2fb919a0202f5d8b38e3b36a595 /src/Output.zig
parenta8a1499bdffffc5b6919e24ec957e92fabaf003b (diff)
parent7e9d2c4169245072265b483ffaa6aa05f23f08d3 (diff)
downloadpardes-a8b457a306a4442975210bcac3f04b56513c61c3.tar.gz
pardes-a8b457a306a4442975210bcac3f04b56513c61c3.zip
Merge: Def/Refs, the diff viewer, Helix n/N, Callstack, Zig 0.17, Window mode and the terminal cwd fix onto 0.24
The docs keep both sides: 0.24's Ctrl-i fallbacks and typed ls with this line's Window mode, raw Esc and Helix n/N wording. The CHANGELOG's unreleased entries go above 0.24, Def/Refs and the context rows among them. cheatsheet-a4.pdf rendered again; .scratch/ ignored. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/Output.zig')
-rw-r--r--src/Output.zig169
1 files changed, 135 insertions, 34 deletions
diff --git a/src/Output.zig b/src/Output.zig
index 3bae9ecf..9ed33ebe 100644
--- a/src/Output.zig
+++ b/src/Output.zig
@@ -15,6 +15,8 @@ const build_options = @import("pardes_config");
const lsp = @import("lsp/lsp.zig");
const look = @import("look.zig");
const locations = @import("locations.zig");
+const layout = @import("layout.zig");
+const hunks = @import("hunks.zig");
const Pane = panes.Pane;
const File = panes.File;
@@ -51,13 +53,14 @@ const RowDecoration = struct {
location_end: usize = 0,
prefix_end: usize = 0,
declaration: bool = false,
+ guide_end: usize = 0,
mark_start: usize = 0,
mark_end: usize = 0,
severity: enum { none, err, warning, info, hint } = .none,
/// Nothing in the row is decorated: most rows of most files.
pub fn plain(row: RowDecoration) bool {
- return !row.declaration and row.location_end == 0 and row.prefix_end == 0 and row.mark_end <= row.mark_start;
+ return row.guide_end == 0 and !row.declaration and row.location_end == 0 and row.prefix_end == 0 and row.mark_end <= row.mark_start;
}
/// `chrome` is the theme's own (Pardes.bodyChrome): body paper changes
@@ -66,6 +69,7 @@ const RowDecoration = struct {
/// working it out takes the contrast searches' pow calls.
pub fn styleAt(row: RowDecoration, chrome: *const pardes.ChromeTheme, byte: usize) ?pardes.CellStyle {
if (row.plain()) return null;
+ if (byte < row.guide_end) return .{ .fg = .{ .rgb = chrome.diagnostic_info } };
if (row.declaration or byte < @max(row.location_end, row.prefix_end))
return .{ .fg = .{ .rgb = chrome.lineno } };
if (byte < row.mark_start or byte >= row.mark_end) return null;
@@ -89,32 +93,38 @@ fn rowDecoration(output: ?State, line: []const u8) RowDecoration {
pub fn decorateRow(output: ?State, line: []const u8, metadata: ?locations.Row) RowDecoration {
const origin = (output orelse return .{}).from;
+ const callstack = std.meta.eql(origin, Origin{ .query = .callstack });
+ const prefix = locations.treePrefix(if (callstack) line else "");
+ const trimmed = line[prefix.end..];
+ const indent = prefix.end;
if (!traits(origin).locations) return .{};
- const target = locations.parse(line);
+ const target = if (callstack) locations.parseRaw(trimmed) else locations.parse(trimmed);
const spot = if (metadata) |m| m.at else target.at;
if (spot.line == 0) return .{};
var row: RowDecoration = .{
- .location_end = if (metadata) |m| m.location_end else target.end,
- .prefix_end = if (metadata) |m| m.code_start else target.end,
+ .guide_end = indent,
+ .location_end = if (metadata) |m| m.location_end else indent + target.end,
+ .prefix_end = if (metadata) |m| m.code_start else indent + target.end,
.declaration = if (metadata) |m| m.declaration else false,
};
- const source_start = if (metadata) |m| m.code_start else target.code_start;
+ const source_start = if (metadata) |m| m.code_start else indent + target.code_start;
if (source_start >= line.len) return row;
if (metadata) |m| if (m.kind == .context) return row;
const mark_occurrence = switch (origin) {
.search => true,
.cmd => |cmd| cmd == .Grep,
.query => |kind| switch (kind) {
- .definition, .declaration, .type_definition, .implementation, .references => true,
+ .definition, .declaration, .type_definition, .implementation, .references, .callstack => true,
else => false,
},
else => false,
};
- if (mark_occurrence and spot.col > 0 and spot.end_line == spot.line and
+ if (mark_occurrence and (if (metadata) |m| m.mark_occurrence else !prefix.branch) and spot.col > 0 and spot.end_line == spot.line and
spot.end_col >= spot.col)
{
- row.mark_start = source_start +| (spot.col - 1);
- row.mark_end = @min(line.len, source_start +| spot.end_col);
+ const source_column = if (metadata) |m| m.source_column else 0;
+ row.mark_start = source_start +| ((spot.col - 1) -| source_column);
+ row.mark_end = @min(line.len, source_start +| (spot.end_col -| source_column));
}
const is_diagnostic = switch (origin) {
.query => |kind| kind == .diagnostics or kind == .workspace_diagnostics,
@@ -133,6 +143,25 @@ pub fn decorateRow(output: ?State, line: []const u8, metadata: ?locations.Row) R
return row;
}
+test "callstack guides and Look locations share result decoration" {
+ const from: State = .{ .from = .{ .query = .callstack } };
+ const loc = rowDecoration(from, "└──┬ lib.rs:2:8-10 fn add() {");
+ try std.testing.expectEqual(@as(usize, "└──┬ lib.rs:2:8-10".len), loc.location_end);
+ try std.testing.expect(!loc.declaration);
+ try std.testing.expect(!usesLocationsConfig(from.from));
+ try std.testing.expect(!traits(from.from).jumps);
+ const call_line = " lib.rs:12:12-20 return calculate(value);";
+ const call = rowDecoration(from, call_line);
+ try std.testing.expectEqualStrings("calculate", call_line[call.mark_start..call.mark_end]);
+ const reference = rowDecoration(.{ .from = .{ .query = .references } }, call_line[4..]);
+ try std.testing.expectEqual(reference.mark_start + 4, call.mark_start);
+ try std.testing.expectEqual(reference.mark_end + 4, call.mark_end);
+ try std.testing.expectEqual(reference.location_end + 4, call.location_end);
+ const tab_line = " tab.zig:4:9-11 \treturn run();";
+ const tab_call = rowDecoration(from, tab_line);
+ try std.testing.expectEqualStrings("run", tab_line[tab_call.mark_start..tab_call.mark_end]);
+}
+
test "result decoration follows source byte ranges and diagnostic provenance" {
const row = rowDecoration(.{ .from = .search }, "src/a.rs:3:5-7 let abc = 1;");
try std.testing.expectEqualStrings("abc", "src/a.rs:3:5-7 let abc = 1;"[row.mark_start..row.mark_end]);
@@ -235,6 +264,7 @@ pub fn traits(o: Origin) Traits {
.cmd => |b| builtins.registry.outputTraits(b) orelse unreachable,
.query => |k| switch (k) {
.hover => .{ .name = config.hover_buffer },
+ .callstack => .{ .name = "+Callstack", .steps = true, .locations = true },
// prose: an action list, a diff, a report about the backend
.code_action, .format, .status, .explain => .{ .name = config.lsp_buffer },
.rename => .{ .name = config.search_buffer, .steps = true, .locations = true },
@@ -265,7 +295,8 @@ pub fn usesLocationsConfig(from: Origin) bool {
const tr = traits(from);
return tr.steps and !tr.commands and from != .pdf_links and
!std.meta.eql(from, Origin{ .cmd = .Find }) and
- !std.meta.eql(from, Origin{ .query = .completion });
+ !std.meta.eql(from, Origin{ .query = .completion }) and
+ !std.meta.eql(from, Origin{ .query = .callstack });
}
pub fn fileTraits(out: ?State) Traits {
@@ -531,13 +562,27 @@ pub fn fillResults(p: *Pardes, id: usize, dir: []const u8, from: Origin, arg: []
return;
}
}
- if (usesLocationsConfig(from)) {
- const formatted = try locations.format(p, dir, content, anchor, true);
+ if (usesLocationsConfig(from) or std.meta.eql(from, Origin{ .query = .callstack })) {
+ const formatted = if (std.meta.eql(from, Origin{ .query = .callstack }))
+ try locations.formatCallstack(p, dir, content)
+ else
+ try locations.format(p, dir, content, anchor, true);
p.gpa.free(result_content);
result_content = formatted.content;
result_rows = formatted.rows;
anchor = formatted.anchor;
}
+ _ = try fillRows(p, id, dir, from, arg, result_content, result_rows, anchor);
+}
+
+/// Rows already laid out (`content`, `rows` its metadata, both taken
+/// when it succeeds, the caller's still when it fails) into the pane they
+/// belong in: the one a run of `from` with `arg` in `dir` showed last,
+/// refilled, else a new one placed by pane `id`. Its id.
+pub fn fillRows(p: *Pardes, id: usize, dir: []const u8, from: Origin, arg: []const u8, result_content: []u8, result_rows: []locations.Row, anchor: ?usize) !usize {
+ const pane = p.panes[id] orelse return error.MissingPane;
+ if (arg.len > max_arg) return error.ArgumentTooLong;
+ const by_arg = std.meta.activeTag(from) != .query;
for (p.panes, 0..) |slot, i| {
const rp = slot orelse continue;
const rf = if (rp.file) |*f| f else continue;
@@ -578,7 +623,7 @@ pub fn fillResults(p: *Pardes, id: usize, dir: []const u8, from: Origin, arg: []
pane.search_row = anchor;
look.armLookWalk(p, i);
}
- return;
+ return i;
}
const free = p.freeSlot() orelse return error.NoPaneSlots;
const np = try open(p, free, dir, from, arg, result_content);
@@ -590,6 +635,57 @@ pub fn fillResults(p: *Pardes, id: usize, dir: []const u8, from: Origin, arg: []
pane.search_row = anchor;
look.armLookWalk(p, free);
}
+ return free;
+}
+
+/// Diff: `content`, the diff at `path` (a file, a +Pager), stacked as a
+/// diff viewer shows it (hunks.zig), in a +Diff where its files are found
+/// (hunks.sourceRoot), placed by pane `id`, refilled when it is there. Its
+/// arg names the diff (its base name, or its whole path when the +Diff
+/// stands elsewhere), for Diff to go back to it. The +Diff's id;
+/// NoHunks when there is none in it.
+pub fn openDiff(p: *Pardes, id: usize, path: []const u8, content: []const u8) !usize {
+ const dir = std.fs.path.dirname(path) orelse p.sessionDir();
+ const root = hunks.sourceRoot(p, dir, content);
+ const result = try hunks.format(p, root, content);
+ errdefer {
+ p.gpa.free(result.content);
+ locations.freeRows(p.gpa, result.rows);
+ }
+ var has_hunk = false;
+ for (result.rows) |row| has_hunk = has_hunk or row.kind == .match;
+ if (!has_hunk) return error.NoHunks;
+ const arg = if (std.mem.eql(u8, root, dir) or path.len > max_arg) std.fs.path.basename(path) else path;
+ return fillRows(p, id, root, .{ .cmd = .Diff }, arg, result.content, result.rows, null);
+}
+
+/// Diff on a +Diff: the diff it stacks, as text. A pane holding it
+/// already (the newest: a +Pager folded under its +Diff unfolds) is
+/// shown; else the file is opened as text, whatever DiffLook says.
+pub fn showDiffText(p: *Pardes, id: usize, source: []const u8) void {
+ var newest: ?usize = null;
+ for (p.panes, 0..) |slot, i| {
+ const f = (slot orelse continue).file orelse continue;
+ if (!std.mem.eql(u8, f.path, source)) continue;
+ if (newest == null or p.panes[newest.?].?.serial < slot.?.serial) newest = i;
+ }
+ if (newest) |i| {
+ if (p.panes[i].?.collapsed) layout.toggleCollapse(p, i);
+ p.active = i;
+ return;
+ }
+ p.look_text = true;
+ defer p.look_text = false;
+ look.lookAt(p, id, source);
+}
+
+/// The diff a +Diff stacks (openDiff's arg): its path.
+pub fn diffSource(p: *Pardes, f: *const File.State) ?[]const u8 {
+ const o = f.output orelse return null;
+ if (!std.meta.eql(o.from, Origin{ .cmd = .Diff })) return null;
+ const arg = o.arg();
+ if (arg.len > 0 and arg[0] == '/') return arg;
+ return std.fs.path.join(p.scratch.allocator(), &.{ std.fs.path.dirname(f.path) orelse "", arg }) catch null;
}
pub fn openJumps(p: *Pardes, id: usize) !void {
@@ -685,25 +781,15 @@ pub fn openUnsaved(p: *Pardes, id: usize, content: []u8) void {
p.active = id;
}
-/// `pardes -`'s pane: the one `<dir>/+Pager`, emptied for the next paged
-/// text when it is there (a directory's paged commands refill it, as its
-/// command pane is reused), else made, named so before it is announced,
-/// and placed wherever there is room without taking the keyboard. `dir`
-/// empty (or not absolute): the session's directory. Its id; NoPaneRoom
-/// or NoPaneSlots when it has no room at all.
+/// `pardes -`'s pane: a new `<dir>/+Pager` for each paged text, as each
+/// run of a pager is its own (one already there keeps its page), named so
+/// before it is announced, its colours through Filter, and placed wherever
+/// there is room without taking the keyboard. `dir` empty (or not
+/// absolute): the session's directory. Its id; NoPaneRoom or NoPaneSlots
+/// when it has no room at all.
pub fn openPager(p: *Pardes, from: usize, dir_arg: []const u8) !usize {
const dir = if (dir_arg.len > 0 and dir_arg[0] == '/') dir_arg else p.sessionDir();
const path = try std.fs.path.join(p.gpa, &.{ dir, "+Pager" });
- for (p.panes, 0..) |slot, i| {
- const pane = slot orelse continue;
- const f = if (pane.file) |*file| file else continue;
- if (!std.mem.eql(u8, f.path, path)) continue;
- p.gpa.free(path);
- File.setContent(p, f, try p.gpa.alloc(u8, 0));
- resetBody(p, pane);
- f.saved_revision = f.revision;
- return i;
- }
const free = p.freeSlot() orelse {
p.gpa.free(path);
return error.NoPaneSlots;
@@ -719,6 +805,8 @@ pub fn openPager(p: *Pardes, from: usize, dir_arg: []const u8) !usize {
// The pane owns the name from here.
p.gpa.free(pane.file.?.path);
pane.file.?.path = path;
+ pane.file.?.pager = true;
+ pane.tty_filter = true;
const keyboard = p.active;
exec.placeNew(p, from, null, free, .fs);
if (p.unplaced.isSet(free)) return error.NoPaneRoom;
@@ -807,7 +895,7 @@ pub fn openThemes(p: *Pardes, id: usize) !void {
pub fn isWalkRow(file: *const File.State, row: usize, line: []const u8) bool {
const state = file.output orelse return true;
- if (usesLocationsConfig(state.from)) return isResultRow(file, row);
+ if (usesLocationsConfig(state.from) or std.meta.eql(state.from, Origin{ .query = .callstack })) return isResultRow(file, row);
if (!std.meta.eql(state.from, Origin{ .cmd = .Themes })) return true;
// Section labels are for reading, not stops in the command walk.
return std.mem.startsWith(u8, std.mem.trimStart(u8, line, " \t"), comptime config.Runtime.findAction(.theme).?.word ++ " ");
@@ -845,11 +933,14 @@ fn openStepped(p: *Pardes, id: usize, from: Origin, content: []u8) !void {
fn helpContent(gpa: std.mem.Allocator, prefix: []const u8) ![]u8 {
const full_header = "pardes builtins, and how to run each:\nSPC and its keys, a chord, a button, the\ntopbar - or the name, executed anywhere.\n\n";
const group_header = "pardes builtins under SPC";
+ const calls_help = "\nCallstack: static caller chains,\nwith signatures and clickable call sites.\nCallers / Callees: one direction at a time.\n";
+ const show_calls_help = prefix.len == 0 or std.mem.eql(u8, prefix, "l");
const language_footer =
"\nlanguage keys (motions, not words):\n" ++
"gd gD gy gi gr goto: definition,\n" ++
" declaration, type-def,\n" ++
" implementation, refs\n" ++
+ "gc Callstack\n" ++
"]d [d ]D [D diagnostics: next,\n" ++
" prev, last, first\n" ++
"= format (applies, one\n" ++
@@ -862,6 +953,7 @@ fn helpContent(gpa: std.mem.Allocator, prefix: []const u8) ![]u8 {
full_header.len + language_footer.len
else
group_header.len + prefix.len * 2 + 2;
+ if (show_calls_help) len += calls_help.len;
for (pardes.builtin_rows) |row| {
// a path-less builtin filters as the empty path: in the full listing
// (which starts with nothing) and out of every group
@@ -892,6 +984,10 @@ fn helpContent(gpa: std.mem.Allocator, prefix: []const u8) ![]u8 {
content[at] = '\n';
at += 1;
}
+ if (show_calls_help) {
+ @memcpy(content[at..][0..calls_help.len], calls_help);
+ at += calls_help.len;
+ }
if (prefix.len == 0) {
@memcpy(content[at..][0..language_footer.len], language_footer);
at += language_footer.len;
@@ -907,7 +1003,7 @@ pub fn openHelp(p: *Pardes, id: usize, prefix: []const u8) !void {
return openRead(p, id, .{ .cmd = .Help }, prefix, content);
}
-test "full Help renders every builtin row, then the language keys" {
+test "full Help renders builtin rows, a call hierarchy guide, then language keys" {
const content = try helpContent(std.testing.allocator, "");
defer std.testing.allocator.free(content);
@@ -918,17 +1014,22 @@ test "full Help renders every builtin row, then the language keys" {
for (pardes.builtin_rows) |row|
try std.testing.expectEqualStrings(row.line, lines.next() orelse
return error.MissingBuiltinHelpRow);
- // ...and after the last row, the language-keys section: the one part of
- // the keymap no builtin row can carry, closing the page.
+ // The short call guide disambiguates the three related commands.
+ try std.testing.expectEqualStrings("", lines.next() orelse return error.MissingCallHelp);
+ try std.testing.expectEqualStrings("Callstack: static caller chains,", lines.next() orelse return error.MissingCallHelp);
+ try std.testing.expectEqualStrings("with signatures and clickable call sites.", lines.next() orelse return error.MissingCallHelp);
+ try std.testing.expectEqualStrings("Callers / Callees: one direction at a time.", lines.next() orelse return error.MissingCallHelp);
+ // The language keys close the page.
try std.testing.expectEqualStrings("", lines.next() orelse
return error.MissingLanguageKeys);
try std.testing.expectEqualStrings("language keys (motions, not words):", lines.next() orelse
return error.MissingLanguageKeys);
try std.testing.expect(std.mem.indexOf(u8, body, "\ngd gD gy gi gr goto: definition,\n") != null);
- // the group view stays a pure filter: no footer under a prefix
+ // The language group also explains call commands, without the motion footer.
const group = try helpContent(std.testing.allocator, "l");
defer std.testing.allocator.free(group);
try std.testing.expect(std.mem.indexOf(u8, group, "language keys") == null);
+ try std.testing.expect(std.mem.indexOf(u8, group, "Callstack: static caller chains") != null);
}
pub fn openConfig(p: *Pardes, id: usize) !void {