summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/CHANGELOG.md6
-rw-r--r--src/File.zig69
-rw-r--r--src/Output.zig90
-rw-r--r--src/builtins.zig49
-rw-r--r--src/config.zig27
-rw-r--r--src/edit_cmd.zig2
-rw-r--r--src/gui/gui.zig69
-rw-r--r--src/hunks.zig808
-rw-r--r--src/locations.zig4
-rw-r--r--src/look.zig12
-rw-r--r--src/main.zig2
-rw-r--r--src/mouse.zig2
-rw-r--r--src/ninep/ctl.zig41
-rw-r--r--src/ninep/tree.zig2
-rw-r--r--src/normal.zig17
-rw-r--r--src/pardes.zig115
-rw-r--r--src/syntax.zig17
-rw-r--r--src/tagline.zig18
-rw-r--r--src/terminal.zig42
19 files changed, 1305 insertions, 87 deletions
diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 6be39c7a..ce2cedc8 100644
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -2,6 +2,12 @@
## 0.23
+- A file a language server speaks for (by its extension) has `Def` and
+ `Refs` in its tag: the definition and the references of the symbol at
+ the cursor, which `gd`, `gr` and a Ctrl-click run too. Chorded 2-1, they
+ ask at the selected symbol instead, its occurrence nearest the cursor.
+- A scroll in the window never moves the tree-sitter context rows: the
+ body glides under them.
- A look at a directory opens a pane listing it, as acme's directory
window does: its entries in columns, a directory's marked `/`. A look at
an entry opens it from there, and `Get` or a look at it again reads it
diff --git a/src/File.zig b/src/File.zig
index 875d0f46..31392ebd 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -154,8 +154,11 @@ pub const State = struct {
/// Its file was deleted on disk: said once (`deleted`) until it is
/// written or found again.
disk_gone: bool = false,
- /// A +Pager pane (`pardes -`) whose text is a diff (`git diff`, `show`,
- /// `log -p`): drawn and looked at as a diff (Pane.colorAlgo).
+ /// A +Pager pane (`pardes -`): no line numbers, its program's colours
+ /// through Filter until it is toggled off.
+ pager: bool = false,
+ /// A +Pager whose text is a diff (`git diff`, `show`, `log -p`): drawn
+ /// and looked at as a diff (Pane.colorAlgo).
pager_diff: bool = false,
/// A +Pager's colours, as its program printed them (pager.zig): drawn
/// over its text by recolorSyntax, never read over 9P. ponytail: any
@@ -562,6 +565,10 @@ pub fn byteAtRowDisplay(pane: *const Pane, row: i32, from_raw: i32, display_col:
pub fn gutterWidth(pane: *const Pane) u16 {
if (pane.file == null) return 0;
const file = &pane.file.?;
+ // A +Pager, and a +Diff (hunks.zig), show no line numbers, as a
+ // pager and delta show none.
+ if (file.pager) return 0;
+ if (file.output) |o| if (std.meta.eql(o.from, Output.Origin{ .cmd = .Diff })) return 0;
var lines = if (file.line_starts.len > 0) file.line_starts.len else lineCount(file.content);
var digits: u16 = 1;
while (lines >= 10) : (lines /= 10) digits += 1;
@@ -1164,7 +1171,7 @@ pub fn setContentSpan(p: *Pardes, f: *State, new: []u8, span_in: ?Span) void {
f.highlights = &.{};
f.highlight_start = 0;
f.syntax_dirty = true;
- if (std.mem.endsWith(u8, f.path, "/+Pager")) f.pager_diff = looksLikeDiff(new[0..@min(new.len, 64 * 1024)]);
+ if (f.pager) f.pager_diff = looksLikeDiff(new[0..@min(new.len, 64 * 1024)]);
for (twins[0..ntwins], 0..) |id, i| {
const t = p.panes[id].?;
const tf = &t.file.?;
@@ -1434,6 +1441,7 @@ test "a +Pager pane holding a diff is drawn and looked at as one; holding other
const f = &pane.file.?;
p.gpa.free(f.path);
f.path = try p.gpa.dupe(u8, "/tmp/+Pager");
+ f.pager = true;
setContent(p, f, try p.gpa.dupe(u8, "commit abc\n\ndiff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n-a\n+b\n"));
try std.testing.expect(pane.colorAlgo() == .diff);
try std.testing.expect(pardes.look.diffLines(p, pane) != null);
@@ -1715,7 +1723,7 @@ fn fillBody(dst: ?[]u8, pane: *Pane, f: *State, width: usize, record_wrap: bool)
var lbuf: [@max(config.PREFIX_W, 32)]u8 = undefined;
const prefix = lbuf[0..prefix_width];
@memset(prefix, ' ');
- if (at == 0) {
+ if (at == 0 and prefix.len > 0) {
var lineno = row + 1;
var digit: usize = prefix.len - 1;
while (true) {
@@ -1790,6 +1798,12 @@ const SynStyle = struct { fg: [3]u8, bold: bool };
pub const DiffTints = struct {
added_bg: [3]u8,
removed_bg: [3]u8,
+ /// The words a changed line changed (hunks.zig), on a stronger ground.
+ added_emph_bg: [3]u8,
+ removed_emph_bg: [3]u8,
+ /// A +Diff line added or removed whole: a faint ground.
+ added_line_bg: [3]u8,
+ removed_line_bg: [3]u8,
added_fg: [3]u8,
removed_fg: [3]u8,
@@ -1804,6 +1818,10 @@ pub const DiffTints = struct {
return .{
.added_bg = added_bg,
.removed_bg = removed_bg,
+ .added_emph_bg = Colors.mixOklab(page, green, 0.28),
+ .removed_emph_bg = Colors.mixOklab(page, red, 0.28),
+ .added_line_bg = Colors.mixOklab(page, green, 0.07),
+ .removed_line_bg = Colors.mixOklab(page, red, 0.07),
.added_fg = legible(green, ink, added_bg),
.removed_fg = legible(red, ink, removed_bg),
};
@@ -1818,9 +1836,9 @@ pub const DiffTints = struct {
/// The row ground and prefix ink for a line's style byte, if it is an
/// added or removed line.
- pub fn forStyle(t: *const DiffTints, style: u8) ?struct { bg: [3]u8, fg: [3]u8 } {
- if (style & syntax.diff_added != 0) return .{ .bg = t.added_bg, .fg = t.added_fg };
- if (style & syntax.diff_removed != 0) return .{ .bg = t.removed_bg, .fg = t.removed_fg };
+ pub fn forStyle(t: *const DiffTints, style: u8) ?struct { bg: [3]u8, fg: [3]u8, emph_bg: [3]u8, line_bg: [3]u8 } {
+ if (style & syntax.diff_added != 0) return .{ .bg = t.added_bg, .fg = t.added_fg, .emph_bg = t.added_emph_bg, .line_bg = t.added_line_bg };
+ if (style & syntax.diff_removed != 0) return .{ .bg = t.removed_bg, .fg = t.removed_fg, .emph_bg = t.removed_emph_bg, .line_bg = t.removed_line_bg };
return null;
}
};
@@ -1855,7 +1873,17 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
const prefix_width = gutterWidth(pane);
const tz_recolor = tracy.zone(@src(), "synRecolor");
defer tz_recolor.end();
- const tints: ?DiffTints = if (pane.colorAlgo() == .diff and highlights.len > 0) DiffTints.of(p) else null;
+ // A diff's rows, and a +Diff's (hunks.zig): their markers coloured.
+ // A diff's whole row is tinted; a +Diff tints only the words a
+ // changed line changed.
+ const algo = pane.colorAlgo();
+ const tints: ?DiffTints = if ((algo == .diff or algo == .locations) and highlights.len > 0) DiffTints.of(p) else null;
+ const row_tint = algo == .diff;
+ var filtered_storage: terminal.FilteredColors = undefined;
+ const filtered: ?*terminal.FilteredColors = if (comptime terminal.enabled) (if (pane.tty_filter and spans.len > 0) blk: {
+ filtered_storage = .init(p, null);
+ break :blk &filtered_storage;
+ } else null) else null;
// indexed start, same as bodyText — an empty tail simply paints nothing
var flines = std.mem.splitScalar(u8, f.content[lineStart(p.gpa, f, f.scroll)..], '\n');
const total = nlines(p.gpa, f);
@@ -1893,7 +1921,11 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
t.forStyle(highlights[base - highlight_start])
else
null else null;
- if (tint) |t| if (prefix_width < tw) tintRow(s, tx + @as(u16, @intCast(prefix_width)), body_y + vr, tx + tw, t.bg);
+ if (tint) |t| if (prefix_width < tw) {
+ // A +Diff line added or removed whole: faintly (hunks.zig).
+ const whole = highlights[base - highlight_start] & syntax.diff_whole != 0;
+ if (row_tint or whole) tintRow(s, tx + @as(u16, @intCast(prefix_width)), body_y + vr, tx + tw, if (row_tint) t.bg else t.line_bg);
+ };
// A +Pager's own colours (pager.zig) on every row but one the diff
// look tints: an added or removed line is drawn as pardes draws a
// diff, and git's red and green on it would only fight the tint.
@@ -1924,6 +1956,11 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
cell.style.bold = ss.bold;
}
}
+ if (tint) |t| if (highlights[hidx] & syntax.diff_emph != 0) {
+ var fill: usize = 0;
+ while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1)
+ s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr).style.bg = .{ .rgb = t.emph_bg };
+ };
}
}
// Results keep their exact live text. Only the location,
@@ -1945,10 +1982,16 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1) {
const cell = s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr);
if (cell.default) continue;
- // A palette colour through the theme's sixteen, as a
- // terminal pane's cell; truecolor as it is.
- if (st.fg != .default) cell.style.fg = if (st.fg == .index) terminal.palColor(p, st.fg.index) else st.fg;
- if (st.bg != .default) cell.style.bg = if (st.bg == .index) terminal.palColor(p, st.bg.index) else st.bg;
+ // As a terminal pane's cell: through Filter, or a
+ // palette colour through the theme's sixteen and
+ // truecolor as it is.
+ if (filtered) |colors| {
+ if (st.fg != .default) cell.style.fg = colors.spanColor(st.fg, false);
+ if (st.bg != .default) cell.style.bg = colors.spanColor(st.bg, true);
+ } else {
+ if (st.fg != .default) cell.style.fg = if (st.fg == .index) terminal.palColor(p, st.fg.index) else st.fg;
+ if (st.bg != .default) cell.style.bg = if (st.bg == .index) terminal.palColor(p, st.bg.index) else st.bg;
+ }
cell.style.bold = cell.style.bold or st.bold;
cell.style.dim = st.dim;
cell.style.italic = st.italic;
diff --git a/src/Output.zig b/src/Output.zig
index 3bae9ecf..9e194615 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;
@@ -538,6 +540,17 @@ pub fn fillResults(p: *Pardes, id: usize, dir: []const u8, from: Origin, arg: []
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 +591,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 +603,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 +749,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 +773,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;
diff --git a/src/builtins.zig b/src/builtins.zig
index 77e1169d..c1424b2f 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -46,6 +46,10 @@ pub const PaneKind = enum {
/// An image pane, or a terminal, whose program's kitty graphics are
/// pictures too.
picture,
+ /// A terminal, or a +Pager: a program's colours.
+ program_colors,
+ /// A text pane showing a diff: a .diff, a .patch, a +Pager holding one.
+ diff,
pub fn has(kind: PaneKind, pane: *const panes.Pane) bool {
return switch (kind) {
@@ -53,6 +57,9 @@ pub const PaneKind = enum {
.pdf => pane.hasPdf(),
.image => pane.image != null,
.picture => pane.image != null or pane.isTerminal(),
+ .program_colors => pane.isTerminal() or (pane.file != null and pane.file.?.pager),
+ .diff => if (pane.file) |f| pane.colorAlgo() == .diff or
+ (f.output != null and std.meta.eql(f.output.?.from, panes.Output.Origin{ .cmd = .Diff })) else false,
};
}
@@ -62,6 +69,8 @@ pub const PaneKind = enum {
.pdf => "a PDF",
.image => "an image",
.picture => "an image or a terminal",
+ .program_colors => "a terminal or a +Pager",
+ .diff => "a diff or a +Diff",
};
}
};
@@ -1336,14 +1345,28 @@ pub const Del = struct {
}
};
-/// Recolour a terminal's program colours to the theme, or show them as sent, flipping between them.
+/// Recolour a terminal's or a +Pager's program colours to the theme, or show them as sent, flipping between them.
pub const Filter = struct {
- pub const needs: PaneKind = .terminal;
+ pub const needs: PaneKind = .program_colors;
pub fn run(c: Ctx) void {
c.pane.tty_filter = !c.pane.tty_filter;
}
};
+/// Stack a diff's hunks as a diff viewer shows them, each under its place and the declarations around it, in a +Diff; on a +Diff, show the diff itself as text.
+pub const Diff = struct {
+ pub const needs: PaneKind = .diff;
+ pub const output: OutputTraits = .{ .name = config.diff_buffer, .steps = true, .locations = true };
+ pub fn run(c: Ctx) void {
+ const f = &c.pane.file.?;
+ if (panes.Output.diffSource(c.p, f)) |source| return panes.Output.showDiffText(c.p, c.id, source);
+ _ = panes.Output.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),
+ };
+ }
+};
+
/// Cycle the pane's input modes: terminals add raw tty mode to normal/insert.
pub const Mode = struct {
pub fn run(c: Ctx) void {
@@ -1851,6 +1874,28 @@ pub const Jumplist = struct {
// ---- the language group ----
+/// Go to the definition of the symbol under the cursor; with an argument
+/// (a 2-1 chord's selection), of that symbol, where it is nearest.
+pub const Def = struct {
+ pub const takes_arg = true;
+ /// Its answer says what it found, a jump or a list or why not; its
+ /// name would only stack above it, as gd never did.
+ pub const quiet = true;
+ pub fn run(c: Ctx) void {
+ c.p.lspRequest(c.id, .definition, std.mem.trim(u8, c.arg orelse "", " \t\r\n"));
+ }
+};
+
+/// List the references to the symbol under the cursor; with an argument
+/// (a 2-1 chord's selection), to that symbol, where it is nearest.
+pub const Refs = struct {
+ pub const takes_arg = true;
+ pub const quiet = true; // as Def
+ pub fn run(c: Ctx) void {
+ c.p.lspRequest(c.id, .references, std.mem.trim(u8, c.arg orelse "", " \t\r\n"));
+ }
+};
+
/// Ask the language server about the symbol under the cursor.
pub const Hover = struct {
pub fn run(c: Ctx) void {
diff --git a/src/config.zig b/src/config.zig
index d6ea7358..c2f51b36 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -32,6 +32,8 @@ pub const leader_path = paths: {
var table = std.EnumArray(Builtin, ?[]const u8).initDefault(@as(?[]const u8, undecided), .{
.Help = &[_]u8{leader_help},
.Hover = "lk",
+ .Def = null, // gd
+ .Refs = null, // gr
.Rename = "lr",
.CodeAction = "la",
.SelectRefs = "lh",
@@ -49,6 +51,7 @@ pub const leader_path = paths: {
.DelAbove = null,
.DelBelow = null,
.Filter = null,
+ .Diff = null,
.Mode = null,
.Togglettymode = null,
.Collapse = null,
@@ -87,6 +90,7 @@ pub const leader_path = paths: {
.BootShell = null,
.LookWord = null,
.DirLook = null,
+ .DiffLook = null,
.Pager = null,
.PagerColor = null,
.TermImages = null,
@@ -301,6 +305,16 @@ pub const topbar_str = "Newcol Joincol Find Grep Help Changelog Tutor Dump Theme
pub const pane_builtins_str = "Tty Collapse Del";
pub const pdf_pane_builtins_str = "Tty PdfSections PdfTint Collapse Del";
pub const file_pane_builtins_str = "Save Tty Collapse Del";
+/// After a file's, on one a language server speaks for.
+pub const lsp_pane_builtins_str = "Def Refs";
+/// A diff's (a .diff, a .patch, a +Pager holding one): Diff.
+pub const diff_pane_builtins_str = "Save Tty Diff Collapse Del";
+/// A +Pager's (`pardes -`): Filter, as a terminal's.
+pub const pager_pane_builtins_str = "Save Tty Filter Collapse Del";
+/// A +Pager holding a diff (`git show`): Diff too.
+pub const pager_diff_pane_builtins_str = "Save Tty Filter Diff Collapse Del";
+/// A +Diff's: Diff again, the diff it stacks as text.
+pub const diff_view_builtins_str = "Save Tty Diff Collapse Del";
pub const terminal_pane_builtins_str = "Tty Save Mode Filter Collapse Del";
pub const command_pane_builtins_str = "Kill Save Collapse Del";
/// A directory pane's (Dir.zig): Get reads it again, as acme's does.
@@ -500,6 +514,7 @@ pub const unsaved_buffer = "+Unsaved";
pub const themes_buffer = "+Themes";
pub const fonts_buffer = "+Fonts";
pub const pdf_sections_buffer = "+PdfSections";
+pub const diff_buffer = "+Diff";
pub const pdf_links_buffer = "+Links";
pub const hover_buffer = "+Hover";
pub const lsp_buffer = "+Lsp";
@@ -794,6 +809,10 @@ pub const Runtime = struct {
/// A directory looked at: `pane`, acme's, a pane listing it (Dir.zig);
/// `terminal`, what pardes did before, `ls` in a terminal there.
dir_look: DirLook = .pane,
+ /// A .diff or .patch looked at (a look, `pardes FILE`, `--wait`):
+ /// `hunks`, a +Diff stacking its hunks (hunks.zig); `text`, the file
+ /// itself, as pardes showed it before. Diff goes from one to the other.
+ diff_look: DiffLook = .hunks,
/// What a terminal's shell pages through (host_io.ChildEnv): `pardes`,
/// PAGER and GIT_PAGER set to `pardes -`, a +Pager pane, where the
/// user's environment set neither; `off`, the environment as it is.
@@ -818,11 +837,12 @@ pub const Runtime = struct {
pub const BootShell = enum { keep, replace };
pub const LookWord = enum { search, list };
pub const DirLook = enum { pane, terminal };
+ pub const DiffLook = enum { hunks, text };
pub const Pager = enum { pardes, off };
pub const TermImages = enum { real, petscii };
pub const JumpScope = enum { file, all };
/// A setting that is one of a few words, each an enum field of Runtime.
- pub const Choice = enum { placement, boot_shell, look_word, dir_look, pager, term_images, jump_scope };
+ pub const Choice = enum { placement, boot_shell, look_word, dir_look, diff_look, pager, term_images, jump_scope };
/// shadow: a soft drop shadow. rim: a light hairline along the top of
/// the focused pane's tag rows. auto: a shadow on a light page; on a
@@ -1088,6 +1108,7 @@ pub const Runtime = struct {
.{ .word = "Placement", .action = .{ .choice = .placement }, .doc = "Where a new pane goes: acme, as makenewwindow does, or pardes, the older rules." },
.{ .word = "BootShell", .action = .{ .choice = .boot_shell }, .doc = "A document dropped where a lone untouched shell stands: keep the shell, or replace it." },
.{ .word = "LookWord", .action = .{ .choice = .look_word }, .doc = "A plain word looked at: search selects its next place in the pane, list lists every place in a +Search." },
+ .{ .word = "DiffLook", .action = .{ .choice = .diff_look }, .doc = "A .diff or .patch looked at: hunks, a +Diff stacking its hunks, or text, the file itself; Diff goes from one to the other." },
.{ .word = "DirLook", .action = .{ .choice = .dir_look }, .doc = "A directory looked at: pane, a pane listing it as acme's directory window, or terminal, ls in a terminal there." },
.{ .word = "Pager", .action = .{ .choice = .pager }, .doc = "What a terminal's commands page through: pardes, a +Pager pane (pardes -), or off, the environment's own; for terminals started after it." },
.{ .word = "PagerColor", .action = .{ .toggle = .pager_color }, .doc = "A +Pager keeps its program's colours, on or off; for the next text paged." },
@@ -1787,6 +1808,7 @@ pub const Runtime = struct {
.boot_shell => "replace",
.look_word => "list",
.dir_look => "terminal",
+ .diff_look => "text",
.pager => "off",
.term_images => "petscii",
.jump_scope => "all",
@@ -1862,6 +1884,7 @@ pub const Runtime = struct {
.boot_shell => "BootShell replace\n",
.look_word => "LookWord list\n",
.dir_look => "DirLook terminal\n",
+ .diff_look => "DiffLook text\n",
.pager => "Pager off\n",
.term_images => "TermImages petscii\n",
.jump_scope => "JumpScope all\n",
@@ -2235,7 +2258,7 @@ const doc_typ = struct {
if (w.end > 0) w.writeByte(' ') catch return false;
w.writeAll(x[0 .. std.mem.indexOfScalar(u8, x, '+') orelse x.len]) catch return false;
}
- const tags = [_][]const u8{ topbar_str, @import("tagline.zig").column_tag_default, pane_builtins_str, pdf_pane_builtins_str, file_pane_builtins_str, terminal_pane_builtins_str, command_pane_builtins_str, dir_pane_builtins_str };
+ const tags = [_][]const u8{ topbar_str, @import("tagline.zig").column_tag_default, pane_builtins_str, pdf_pane_builtins_str, file_pane_builtins_str, diff_pane_builtins_str, pager_pane_builtins_str, pager_diff_pane_builtins_str, diff_view_builtins_str, terminal_pane_builtins_str, command_pane_builtins_str, dir_pane_builtins_str };
for (tags) |d| if (std.mem.eql(u8, d, w.buffered())) return true;
return false;
}
diff --git a/src/edit_cmd.zig b/src/edit_cmd.zig
index ebeae223..d3377e09 100644
--- a/src/edit_cmd.zig
+++ b/src/edit_cmd.zig
@@ -97,7 +97,9 @@ const World = struct {
// A look opens it, or finds it open, where a look would; the
// keyboard stays where the Edit ran.
const was = p.active;
+ p.look_text = true;
look.lookAt(p, w.from, path);
+ p.look_text = false;
if (p.panes[was] != null) p.active = was;
for (p.panes, 0..) |slot, id| {
const pane = slot orelse continue;
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 65b3f926..5a026664 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -1873,6 +1873,7 @@ const Gui = struct {
scroll_rect: pardes.Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 },
scroll_body_y: u16 = 0, // that rect's first BODY row (Tagbottom moves it)
scroll_body_h: u16 = 0, // and its BODY rows, which a taller tag leaves fewer of
+ scroll_held_px: f32 = 0, // its tree-sitter context band, which never moves
scroll_col: u16 = 0, // where the wheel turned: crossed rows are delivered
scroll_row: u16 = 0, // THERE, not wherever the pointer has drifted to since
scroll_delta: f32 = 0, // finite raw distance waiting for the render batch
@@ -5367,7 +5368,7 @@ fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
/// The glide's picture: the pane's body rows moved by the offset, and in
/// the gap it opens the rows that left, as `emitScrollRows` draws a
/// touchpad's fraction.
-fn emitGlideRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground) u32 {
+fn emitGlideRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {
const glide = &g.glide;
for (surface.panelTracks()) |track|
if (track.active() and track.pane == glide.pane) return 0;
@@ -5383,10 +5384,12 @@ fn emitGlideRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *parde
g.scroll_body_h = bh;
var shifted = layout;
shifted.y_off -= glide.offset * layout.h;
+ const kept = holdContext(g, surface, glide.pane, held, bh, layout);
+ shifted.y_off += kept.lift;
const cursor_idx: u32 = if (surface.cursor) |cu| @as(u32, cu.y) * surface.cols + cu.x else std.math.maxInt(u32);
const cursor_bar = if (surface.cursor) |cu| cu.bar else false;
var n: u32 = 0;
- var row = y0;
+ var row = y0 + kept.rows;
while (row < y0 + bh) : (row += 1) {
const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
const row_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
@@ -5400,9 +5403,9 @@ fn emitGlideRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *parde
// The gap: rows past the top while the picture lags a move down, past
// the bottom for one up; as many as it opens.
const gap: u16 = @intFromFloat(@min(@ceil(@abs(glide.offset)), @as(f32, @floatFromInt(bh))));
- const kept = if (glide.offset < 0) glide.nabove else glide.nbelow;
+ const nkept = if (glide.offset < 0) glide.nabove else glide.nbelow;
const rows = if (glide.offset < 0) glide.above else glide.below;
- for (0..@min(gap, kept)) |i| {
+ for (0..@min(gap, nkept)) |i| {
const cells = rows[i * bw ..][0..bw];
// Row -1 - i above the body, or bh + i below it, in grid rows.
const at_row: i32 = if (glide.offset < 0) @as(i32, y0) - 1 - @as(i32, @intCast(i)) else @as(i32, y0) + bh + @as(i32, @intCast(i));
@@ -5560,8 +5563,9 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
if (g.scroll_lag == 0) resetScroll(g);
}
-fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground) u32 {
- if (g.glide.offset != 0) return emitGlideRows(g, instances, base, surface, layout, win_w, win_h, page);
+fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {
+ g.scroll_held_px = 0;
+ if (g.glide.offset != 0) return emitGlideRows(g, instances, base, surface, layout, win_w, win_h, page, held);
const scroll_pane = g.scroll_pane orelse return 0;
if (g.scroll_lag == 0) return 0;
for (surface.panelTracks()) |track|
@@ -5575,10 +5579,12 @@ fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pard
if (x0 + bw > surface.cols or y0 + bh > surface.rows) return 0; // resized under us
var shifted = layout;
shifted.y_off -= g.scroll_lag * layout.h;
+ const kept = holdContext(g, surface, scroll_pane, held, bh, layout);
+ shifted.y_off += kept.lift;
const cursor_idx: u32 = if (surface.cursor) |cu| @as(u32, cu.y) * surface.cols + cu.x else std.math.maxInt(u32);
const cursor_bar = if (surface.cursor) |cu| cu.bar else false;
var n: u32 = 0;
- var row = y0;
+ var row = y0 + kept.rows;
while (row < y0 + bh) : (row += 1) {
const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
const row_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
@@ -5600,12 +5606,52 @@ fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pard
return n;
}
+/// A scrolling body's tree-sitter context rows hold still: the shifted
+/// rows start under them and are clipped below their band, and where a
+/// body layer stacks them at the tagline's height (TreeContextTagStyle)
+/// the rows under them are drawn up to meet them, where the layer has them.
+fn holdContext(g: *Gui, surface: *const pardes.Surface, id: usize, held: u16, bh: u16, layout: CellLayout) struct { rows: u16, lift: f32 } {
+ const rows = @min(held, bh);
+ const layered = id < surface.body_layers.len and surface.body_layers[id].rows != 0 and surface.body_layers[id].context_rows != 0;
+ const row_px = if (layered) std.math.clamp(@as(f32, @floatFromInt(g.tagline_height)), 1, @max(1, layout.h)) else layout.h;
+ g.scroll_held_px = @as(f32, @floatFromInt(rows)) * row_px;
+ return .{ .rows = rows, .lift = @as(f32, @floatFromInt(rows)) * (row_px - layout.h) };
+}
+
+test "a scroll's shifted rows start under the context rows, and its scissor below their band" {
+ var surface: pardes.Surface = .{};
+ var g: Gui = undefined;
+ g.tagline_height = 12;
+ g.scroll_rect = .{ .x = 0, .y = 0, .w = 40, .h = 20 };
+ g.scroll_body_y = 1;
+ g.scroll_body_h = 19;
+ const layout: CellLayout = .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 };
+ // On the grid, three body-high rows are held, and nothing moves up.
+ const grid = holdContext(&g, &surface, 0, 3, 19, layout);
+ try std.testing.expectEqual(@as(u16, 3), grid.rows);
+ try std.testing.expectEqual(@as(f32, 0), grid.lift);
+ const clip = scrollScissor(&g, layout, 400, 400);
+ try std.testing.expectEqual(@as(c_int, 20 + 3 * 20), clip.y);
+ try std.testing.expectEqual(@as(c_int, 16 * 20), clip.h);
+ // In a body layer they are tagline-high: the rows under them move up
+ // by what each is shorter, to where the layer draws them.
+ surface.body_layers[0].rows = 30;
+ surface.body_layers[0].context_rows = 3;
+ const layered = holdContext(&g, &surface, 0, 3, 19, layout);
+ try std.testing.expectEqual(@as(f32, 3 * (12 - 20)), layered.lift);
+ try std.testing.expectEqual(@as(c_int, 20 + 3 * 12), scrollScissor(&g, layout, 400, 400).y);
+ // None held: the whole body moves.
+ surface.body_layers[0].rows = 0;
+ try std.testing.expectEqual(@as(u16, 0), holdContext(&g, &surface, 0, 0, 19, layout).rows);
+ try std.testing.expectEqual(@as(c_int, 20), scrollScissor(&g, layout, 400, 400).y);
+}
+
fn scrollScissor(g: *const Gui, layout: CellLayout, sw: u32, sh: u32) c.SDL_Rect {
const r = g.scroll_rect;
const px = layout.x_off + @as(f32, @floatFromInt(r.x + config.GUTTER)) * layout.w;
- const py = layout.y_off + @as(f32, @floatFromInt(g.scroll_body_y)) * layout.h;
+ const py = layout.y_off + @as(f32, @floatFromInt(g.scroll_body_y)) * layout.h + g.scroll_held_px;
const pw = @as(f32, @floatFromInt(r.w - config.GUTTER)) * layout.w;
- const ph = @as(f32, @floatFromInt(g.scroll_body_h)) * layout.h;
+ const ph = @max(0, @as(f32, @floatFromInt(g.scroll_body_h)) * layout.h - g.scroll_held_px);
const x0 = std.math.clamp(@as(i32, @intFromFloat(@floor(px))), 0, @as(i32, @intCast(sw)));
const y0 = std.math.clamp(@as(i32, @intFromFloat(@floor(py))), 0, @as(i32, @intCast(sh)));
const x1 = std.math.clamp(@as(i32, @intFromFloat(@ceil(px + pw))), x0, @as(i32, @intCast(sw)));
@@ -6426,7 +6472,10 @@ fn renderFrame(
}
for (groups.items[0..groups.len], 0..) |group, index|
std.debug.assert(cell_next[index] == group.cell_start + group.cell_count);
- shifted = emitScrollRows(g, instances, cell_total, surface, layout, win_w, win_h, page);
+ // The body's context rows, which its scroll leaves where they are.
+ const scrolling: ?usize = if (g.glide.offset != 0) g.glide.pane else g.scroll_pane;
+ const held: u16 = if (core) |p| if (scrolling) |id| if (p.panes[id]) |pane| pane.context_rows else 0 else 0 else 0;
+ shifted = emitScrollRows(g, instances, cell_total, surface, layout, win_w, win_h, page, held);
// Over a theme's plaques a see-through cell with no ink blends to
// the plaque under it, so it draws nothing: its quad goes, and the
// cells are drawn unblended (a third of the GPU's frame at 4K)
diff --git a/src/hunks.zig b/src/hunks.zig
new file mode 100644
index 00000000..73c0654a
--- /dev/null
+++ b/src/hunks.zig
@@ -0,0 +1,808 @@
+//! A unified diff (`.diff`, `.patch`, a paged `git show`) stacked as a
+//! diff viewer shows it (Diff): each hunk under its `path:line`, the
+//! declarations around it from tree-sitter as a result's context
+//! (locations.zig), its lines behind their `+`/`-` markers drawn red and
+//! green, coloured as their file, and the words a changed line changed on
+//! a tinted ground as delta emphasises them (its edits.rs and align.rs, here as `inferEdits`
+//! and `Alignment`).
+const std = @import("std");
+const pardes = @import("pardes.zig");
+const diff = @import("diff.zig");
+const syntax = @import("syntax.zig");
+const locations = @import("locations.zig");
+
+const Pardes = pardes.Pardes;
+const Row = locations.Row;
+
+/// The rows `content`, a diff, stacks to, for a pane in `dir`, with each
+/// row's metadata (Output.fillRows). Text and rows are `p.gpa`'s; all else
+/// is the step's scratch.
+pub fn format(p: *Pardes, dir: []const u8, content: []const u8) !locations.Result {
+ const arena = p.scratch.allocator();
+ const styles = try syntax.highlightDiff(arena, content, 0, content.len);
+ var out: Out = .{ .p = p, .text = .init(p.gpa) };
+ errdefer out.deinit();
+ var walk: diff.Walk = .{};
+ var hunk: Hunk = .{};
+ var source: SourceMemo = .{};
+ var at: usize = 0;
+ // The empty text after a last newline is no line.
+ while (at < content.len) {
+ const nl = std.mem.indexOfScalarPos(u8, content, at, '\n') orelse content.len;
+ const raw = content[at..nl];
+ const got = walk.step(raw);
+ const line = std.mem.trimEnd(u8, raw, "\r");
+ switch (got.kind) {
+ .context, .added, .removed => {
+ const skip = @intFromBool(line.len > 0 and std.mem.indexOfScalar(u8, " +-", line[0]) != null);
+ try hunk.lines.append(arena, .{
+ .kind = got.kind,
+ .code = line[skip..],
+ .styles = styles[at + skip ..][0 .. line.len - skip],
+ .old = got.old,
+ .new = got.new,
+ });
+ },
+ // A `\ No newline` belongs to the line above, as delta shows it.
+ .no_newline => {},
+ else => {
+ try flush(&out, &hunk, &source, dir);
+ switch (got.kind) {
+ .hunk => hunk = .{
+ .path = walk.path(),
+ .deleted = walk.deleted(),
+ .old_start = got.old,
+ .new_start = got.new,
+ .header = gitContext(line),
+ },
+ // What is said around the hunks, a mailed patch's
+ // headers, message and diffstat, as it was written.
+ .other => try out.row(line, "", .{ .kind = .context, .at = .{} }),
+ // A section's own words (a new file's mode, a rename,
+ // `Binary files ... differ`), muted; its `diff` and
+ // `index` lines say nothing the labels do not.
+ .meta => if (!std.mem.startsWith(u8, line, "diff ") and !std.mem.startsWith(u8, line, "index "))
+ try out.row(line, "", .{ .kind = .context, .declaration = true, .at = .{} }),
+ else => {},
+ }
+ },
+ }
+ at = nl + 1;
+ }
+ try flush(&out, &hunk, &source, dir);
+ const rows = try out.rows.toOwnedSlice(p.gpa);
+ errdefer locations.freeRows(p.gpa, rows);
+ return .{ .content = try out.text.toOwnedSlice(), .rows = rows, .anchor = null };
+}
+
+const HunkLine = struct {
+ kind: diff.Kind,
+ code: []const u8,
+ /// Its code's style bytes, as the diff pane paints them (syntax.zig
+ /// highlightDiff), the emphasis bit added by `inferEdits`.
+ styles: []u8,
+ old: usize,
+ new: usize,
+ /// Paired with a line it changed (inferEdits): its words show that;
+ /// unpaired, the whole line was added or removed.
+ paired: bool = false,
+};
+
+const Hunk = struct {
+ path: []const u8 = "",
+ deleted: bool = false,
+ old_start: usize = 0,
+ new_start: usize = 0,
+ /// What git wrote after the `@@`'s second marker (its function line).
+ header: []const u8 = "",
+ lines: std.ArrayList(HunkLine) = .empty,
+};
+
+/// `@@ -a,b +c,d @@ fn foo()`: `fn foo()`.
+fn gitContext(line: []const u8) []const u8 {
+ const close = std.mem.indexOfPos(u8, line, 2, "@@") orelse return "";
+ return std.mem.trim(u8, line[close + 2 ..], " \t");
+}
+
+const Out = struct {
+ p: *Pardes,
+ text: std.Io.Writer.Allocating,
+ rows: std.ArrayList(Row) = .empty,
+
+ fn deinit(out: *Out) void {
+ out.text.deinit();
+ for (out.rows.items) |r| {
+ out.p.gpa.free(r.path);
+ out.p.gpa.free(r.colors);
+ }
+ out.rows.deinit(out.p.gpa);
+ }
+
+ const Meta = struct {
+ kind: @FieldType(Row, "kind"),
+ declaration: bool = false,
+ at: @FieldType(Row, "at"),
+ location_end: usize = 0,
+ code_start: usize = 0,
+ colors: []const u8 = &.{},
+ };
+
+ /// One row: its text, a newline, and its metadata.
+ fn row(out: *Out, text: []const u8, path: []const u8, meta: Meta) !void {
+ const gpa = out.p.gpa;
+ try out.text.writer.writeAll(text);
+ try out.text.writer.writeByte('\n');
+ const owned_path = try gpa.dupe(u8, path);
+ errdefer gpa.free(owned_path);
+ const colors = try gpa.dupe(u8, meta.colors);
+ errdefer gpa.free(colors);
+ try out.rows.append(gpa, .{
+ .kind = meta.kind,
+ .declaration = meta.declaration,
+ .path = owned_path,
+ .at = meta.at,
+ .location_end = meta.location_end,
+ .code_start = meta.code_start,
+ .colors = colors,
+ });
+ }
+};
+
+/// The file a diff section names, as found from the pane's directory or
+/// one above it (a patch kept in a subdirectory of its repository).
+const SourceMemo = struct {
+ path: []const u8 = "",
+ /// The name a look from the pane's directory resolves; null when the
+ /// file is nowhere to be found.
+ shown: ?[]const u8 = null,
+ lines: []const []const u8 = &.{},
+ declarations: []const syntax.ContextDeclaration = &.{},
+};
+
+/// Where a +Diff of `content`, a diff in `dir`, stands: the directory its
+/// first file is found from (`dir` or one above it, as `findSource` looks),
+/// so its rows name their files as the diff does; `dir` when none is found.
+pub fn sourceRoot(p: *Pardes, dir: []const u8, content: []const u8) []const u8 {
+ var walk: diff.Walk = .{};
+ var lines = std.mem.splitScalar(u8, content, '\n');
+ const path = while (lines.next()) |line| {
+ if (walk.step(line).kind == .hunk and walk.path().len > 0) break walk.path();
+ } else return dir;
+ var base: []const u8 = dir;
+ for (0..8) |_| {
+ if (locations.sourceText(p, p.scratch.allocator(), base, path) != null) return base;
+ base = std.fs.path.dirname(base) orelse return dir;
+ }
+ return dir;
+}
+
+fn findSource(p: *Pardes, memo: *SourceMemo, dir: []const u8, path: []const u8) !void {
+ if (std.mem.eql(u8, memo.path, path)) return;
+ const arena = p.scratch.allocator();
+ memo.* = .{ .path = path };
+ // ponytail: eight directories up; a repository deeper than that under
+ // its patch is looked for from the patch's own directory only.
+ var base: []const u8 = dir;
+ for (0..8) |_| {
+ if (locations.sourceText(p, arena, base, path)) |text| {
+ memo.shown = if (base.ptr == dir.ptr) path else try std.fs.path.relativePosix(arena, "/", dir, text.path);
+ var lines: std.ArrayList([]const u8) = .empty;
+ var split = std.mem.splitScalar(u8, text.bytes, '\n');
+ while (split.next()) |line| try lines.append(arena, std.mem.trimEnd(u8, line, "\r"));
+ memo.lines = lines.items;
+ var hit = p.locations_cache.get(p.tree_sitter_gpa, text.path, text.bytes, true, false) catch
+ locations.Cache.Hit{ .analysis = syntax.analyzeSource(arena, text.path, text.bytes, true, false) catch .{} };
+ defer hit.deinit(p.tree_sitter_gpa);
+ // The cache's may go at its next use: kept for the section.
+ memo.declarations = try arena.dupe(syntax.ContextDeclaration, hit.analysis.declarations);
+ return;
+ }
+ base = std.fs.path.dirname(base) orelse return;
+ }
+}
+
+/// Which side of the hunk the file on disk holds, the new one (the patch
+/// applied) or the old one, and how far the file has moved it from where
+/// the hunk says (`shift`, lines), as patch finds a hunk in a file edited
+/// since. A file edited inside the hunk too still holds most of its lines:
+/// the place holding the most of them wins (the nearer on a tie) if it
+/// holds at least half. Only some, at the nearest place, could be a sibling
+/// with the same lines (two functions with one signature's tail). The rows
+/// are counted on that side, so moved.
+const Side = enum { new, old, neither };
+const OnDisk = struct { side: Side, shift: i64 = 0 };
+
+/// ponytail: a hunk moved more than this many lines is not looked for;
+/// each try compares the hunk's lines, so a wider search costs that more.
+const max_shift = 200;
+
+fn sideOnDisk(memo: *const SourceMemo, hunk: *const Hunk) OnDisk {
+ if (memo.shown == null) return .{ .side = .neither };
+ var best: OnDisk = .{ .side = .neither };
+ var best_held: usize = 0;
+ var best_of: usize = 1;
+ var shift: i64 = 0;
+ while (shift <= max_shift) : (shift += 1) {
+ for ([2]i64{ shift, -shift }) |by| {
+ inline for (.{ Side.new, Side.old }) |side| {
+ const start: i64 = @as(i64, @intCast((if (side == .new) hunk.new_start else hunk.old_start) -| 1)) + by;
+ if (start >= 0) {
+ const got = heldAt(memo, hunk, side, @intCast(start));
+ if (got.held == got.of) return .{ .side = side, .shift = by };
+ // A larger share only: the nearer keeps a tie.
+ if (got.held * best_of > best_held * got.of) {
+ best = .{ .side = side, .shift = by };
+ best_held = got.held;
+ best_of = got.of;
+ }
+ }
+ }
+ if (shift == 0) break;
+ }
+ }
+ return if (best_held > 0 and best_held * 2 >= best_of) best else .{ .side = .neither };
+}
+
+/// How many of the hunk's `side` lines the file holds from row `start` on,
+/// of how many: blank lines, which match anywhere, count for neither.
+fn heldAt(memo: *const SourceMemo, hunk: *const Hunk, comptime side: Side, start: usize) struct { held: usize, of: usize } {
+ var row = start;
+ var held: usize = 0;
+ var of: usize = 0;
+ for (hunk.lines.items) |line| {
+ const skipped = if (side == .new) line.kind == .removed else line.kind == .added;
+ if (skipped) continue;
+ defer row += 1;
+ if (std.mem.trim(u8, line.code, " \t").len == 0) continue;
+ of += 1;
+ if (row < memo.lines.len and std.mem.eql(u8, memo.lines[row], line.code)) held += 1;
+ }
+ return .{ .held = held, .of = @max(of, 1) };
+}
+
+fn flush(out: *Out, hunk: *Hunk, memo: *SourceMemo, dir: []const u8) !void {
+ defer hunk.* = .{};
+ if (hunk.path.len == 0 or hunk.lines.items.len == 0) return;
+ const p = out.p;
+ const arena = p.scratch.allocator();
+ try findSource(p, memo, dir, hunk.path);
+ const disk = sideOnDisk(memo, hunk);
+ const side = disk.side;
+ // A line number of the hunk's, where the file has it now.
+ const moved = struct {
+ fn by(n: usize, shift: i64) usize {
+ return @intCast(@max(0, @as(i64, @intCast(n)) + shift));
+ }
+ }.by;
+ const shown = if (side == .neither) hunk.path else memo.shown.?;
+ const lines = hunk.lines.items;
+
+ // Where the hunk changes something, on the side its rows count: the
+ // place its label opens.
+ const first_change = for (lines) |line| {
+ if (line.kind != .context) break line;
+ } else lines[0];
+ const on_old = side == .old or (side == .neither and hunk.deleted);
+ const start_row = moved(if (on_old) hunk.old_start else hunk.new_start, disk.shift) -| 1;
+ const change_row = moved(if (on_old) first_change.old else first_change.new, disk.shift) -| 1;
+
+ // The declarations it stands in, outermost first, as a result's
+ // tree-sitter context: each one's header rows above the hunk.
+ var depth: usize = 0;
+ if (side != .neither) for (memo.declarations) |declaration| {
+ if (declaration.start_line >= start_row) break;
+ if (declaration.end_line < change_row) continue;
+ depth += 1;
+ var row = declaration.start_line;
+ while (row <= declaration.header_end_line and row < start_row) : (row += 1) {
+ const at: @FieldType(Row, "at") = .{ .line = row + 1 };
+ if (row == declaration.start_line and p.locations_config.tslocations) {
+ const label = try std.fmt.allocPrint(arena, "{s}:{d}", .{ shown, row + 1 });
+ try out.row(label, shown, .{ .kind = .context, .declaration = true, .at = at, .location_end = label.len, .code_start = label.len });
+ }
+ // A blank where a hunk line has its marker: the code aligns.
+ try out.row(try std.fmt.allocPrint(arena, " {s}", .{memo.lines[row]}), shown, .{ .kind = .context, .declaration = true, .at = at });
+ }
+ };
+
+ // The hunk's label: a step for n and N, and a look's place.
+ const line_no = change_row + 1;
+ var label: std.Io.Writer.Allocating = .init(arena);
+ try label.writer.print("{s}:{d}", .{ shown, line_no });
+ const location_end = label.written().len;
+ if (depth > 0) {
+ try label.writer.writeByte(' ');
+ try label.writer.splatByteAll('*', depth);
+ }
+ try out.row(label.written(), shown, .{ .kind = .match, .at = .{ .line = line_no }, .location_end = location_end, .code_start = label.written().len });
+ // No file to read declarations from: git's own function line, muted
+ // the same way. With one, git's guess (the last line before the hunk
+ // that looked like a function) would only contradict it.
+ if (side == .neither and hunk.header.len > 0)
+ try out.row(try std.fmt.allocPrint(arena, " {s}", .{hunk.header}), shown, .{ .kind = .context, .declaration = true, .at = .{ .line = line_no } });
+
+ // Each run of removed lines and the added lines after it: the words
+ // they changed.
+ var i: usize = 0;
+ while (i < lines.len) {
+ if (lines[i].kind == .context) {
+ i += 1;
+ continue;
+ }
+ const minus_start = i;
+ while (i < lines.len and lines[i].kind == .removed) i += 1;
+ const plus_start = i;
+ while (i < lines.len and lines[i].kind == .added) i += 1;
+ try inferEdits(arena, lines[minus_start..plus_start], lines[plus_start..i]);
+ }
+
+ // Each line behind its marker, `+`, `-` or a blank, as the diff
+ // has it: the marker coloured, the line as its file's.
+ for (lines) |line| {
+ const flag: u8 = switch (line.kind) {
+ .added => syntax.diff_added,
+ .removed => syntax.diff_removed,
+ else => 0,
+ } | @as(u8, if (line.kind != .context and !line.paired) syntax.diff_whole else 0);
+ const text = try std.fmt.allocPrint(arena, "{c}{s}", .{ @as(u8, switch (line.kind) {
+ .added => '+',
+ .removed => '-',
+ else => ' ',
+ }), line.code });
+ const colors = try arena.alloc(u8, text.len);
+ colors[0] = flag;
+ @memcpy(colors[1..], line.styles);
+ const on = moved(if (on_old) line.old else line.new, disk.shift);
+ try out.row(text, shown, .{ .kind = .preview, .at = .{ .line = @max(1, on) }, .colors = colors });
+ }
+}
+
+// ---- the words a changed line changed (delta's edits.rs) ----
+
+/// delta's `max-line-distance`: a removed and an added line further apart
+/// than this are not one line changed, and neither is emphasised.
+const max_line_distance = 0.6;
+
+/// ponytail: a run of more removed or added lines than this, or a pair
+/// whose token table is bigger than `max_cells`, is shown unemphasised
+/// rather than aligned at a quadratic cost (delta aligns them all).
+const max_run = 256;
+const max_cells = 1 << 16;
+
+/// Pair each removed line with the first added line after the last one
+/// paired that is near enough to it, in order, and emphasise in both the
+/// tokens one has and the other has not.
+fn inferEdits(arena: std.mem.Allocator, minus: []HunkLine, plus: []HunkLine) !void {
+ if (minus.len == 0 or plus.len == 0 or minus.len > max_run or plus.len > max_run) return;
+ var plus_index: usize = 0;
+ for (minus) |*m| {
+ const m_tokens = try tokenize(arena, m.code);
+ var j = plus_index;
+ while (j < plus.len) : (j += 1) {
+ const p_tokens = try tokenize(arena, plus[j].code);
+ if ((m_tokens.len + 1) * (p_tokens.len + 1) > max_cells) continue;
+ var alignment = try Alignment.init(arena, m_tokens, p_tokens);
+ const marks = try annotate(arena, &alignment, m.code, plus[j].code);
+ if (marks.distance > max_line_distance) continue;
+ for (marks.minus) |r| for (m.styles[r[0]..r[1]]) |*b| {
+ b.* |= syntax.diff_emph;
+ };
+ for (marks.plus) |r| for (plus[j].styles[r[0]..r[1]]) |*b| {
+ b.* |= syntax.diff_emph;
+ };
+ m.paired = true;
+ plus[j].paired = true;
+ plus_index = j + 1;
+ break;
+ }
+ }
+}
+
+/// delta's tokenize with its default `\w+`: a leading empty token, each
+/// run of word characters one token, and every other character one. A
+/// line starting with no word gets a second empty token, as delta's does.
+/// ponytail: any byte past ASCII counts as a word character, close to
+/// Unicode `\w` for letters; a non-ASCII punctuation mark joins a word.
+fn tokenize(arena: std.mem.Allocator, line: []const u8) ![]const []const u8 {
+ var tokens: std.ArrayList([]const u8) = .empty;
+ try tokens.append(arena, "");
+ if (line.len > 0 and !isWord(line[0])) try tokens.append(arena, "");
+ var at: usize = 0;
+ while (at < line.len) {
+ var end = at + 1;
+ // A byte past ASCII is a word's, so what is left is one byte.
+ if (isWord(line[at])) while (end < line.len and isWord(line[end])) {
+ end += 1;
+ };
+ try tokens.append(arena, line[at..end]);
+ at = end;
+ }
+ return tokens.items;
+}
+
+fn isWord(c: u8) bool {
+ return std.ascii.isAlphanumeric(c) or c == '_' or c >= 0x80;
+}
+
+const Op = enum(u2) { noop, deletion, insertion };
+
+/// delta's align.rs: a Needleman-Wunsch table over two token lists, a
+/// change costing more where it starts a new run, so changes group.
+const Alignment = struct {
+ x: []const []const u8,
+ y: []const []const u8,
+ cells: []Cell,
+ width: usize,
+
+ const Cell = struct { parent: u32, op: Op, cost: u32 };
+ const deletion_cost = 2;
+ const insertion_cost = 2;
+ const initial_mismatch_penalty = 1;
+ const never = std.math.maxInt(u32);
+
+ fn init(arena: std.mem.Allocator, x: []const []const u8, y: []const []const u8) !Alignment {
+ const width = x.len + 1;
+ const cells = try arena.alloc(Cell, width * (y.len + 1));
+ @memset(cells, .{ .parent = 0, .op = .noop, .cost = 0 });
+ var a: Alignment = .{ .x = x, .y = y, .cells = cells, .width = width };
+ for (1..width) |i| cells[i] = .{ .parent = 0, .op = .deletion, .cost = @intCast(i * deletion_cost + initial_mismatch_penalty) };
+ for (1..y.len + 1) |j| cells[j * width] = .{ .parent = 0, .op = .insertion, .cost = @intCast(j * insertion_cost + initial_mismatch_penalty) };
+ for (x, 0..) |x_i, i| for (y, 0..) |y_j, j| {
+ const left = a.index(i, j + 1);
+ const diag = a.index(i, j);
+ const up = a.index(i + 1, j);
+ // Ties go to the first: an insertion, then a deletion, then a
+ // match, so a moved token reads as removed then added.
+ const candidates = [3]Cell{
+ .{ .parent = @intCast(up), .op = .insertion, .cost = a.mismatchCost(up, insertion_cost) },
+ .{ .parent = @intCast(left), .op = .deletion, .cost = a.mismatchCost(left, deletion_cost) },
+ .{ .parent = @intCast(diag), .op = .noop, .cost = if (std.mem.eql(u8, x_i, y_j)) cells[diag].cost else never },
+ };
+ var best = candidates[0];
+ for (candidates[1..]) |c| if (c.cost < best.cost) {
+ best = c;
+ };
+ cells[a.index(i + 1, j + 1)] = best;
+ };
+ return a;
+ }
+
+ fn mismatchCost(a: *const Alignment, parent: usize, basic: u32) u32 {
+ const cell = a.cells[parent];
+ return cell.cost +| basic +| @as(u32, if (cell.op == .noop) initial_mismatch_penalty else 0);
+ }
+
+ fn index(a: *const Alignment, i: usize, j: usize) usize {
+ return j * a.width + i;
+ }
+
+ /// The operations read back from the table's far corner, in order,
+ /// each run as one (op, count).
+ fn coalesced(a: *const Alignment, arena: std.mem.Allocator) ![]const struct { Op, usize } {
+ var ops: std.ArrayList(Op) = .empty;
+ var cell = a.cells[a.index(a.x.len, a.y.len)];
+ while (true) {
+ try ops.append(arena, cell.op);
+ if (cell.parent == 0) break;
+ cell = a.cells[cell.parent];
+ }
+ std.mem.reverse(Op, ops.items);
+ var runs: std.ArrayList(struct { Op, usize }) = .empty;
+ for (ops.items) |op| {
+ if (runs.items.len > 0 and runs.items[runs.items.len - 1][0] == op) {
+ runs.items[runs.items.len - 1][1] += 1;
+ } else try runs.append(arena, .{ op, 1 });
+ }
+ return runs.items;
+ }
+};
+
+const Marks = struct {
+ /// Byte ranges of the removed and the added line to emphasise.
+ minus: []const [2]usize,
+ plus: []const [2]usize,
+ distance: f64,
+};
+
+/// delta's annotate: walk the alignment's runs over both lines, marking
+/// what each deleted and inserted, and a run of blanks between two changes
+/// with them; the distance is the changed width over the whole width (a
+/// kept section counting on both lines).
+fn annotate(arena: std.mem.Allocator, a: *const Alignment, minus_line: []const u8, plus_line: []const u8) !Marks {
+ var minus: std.ArrayList([2]usize) = .empty;
+ var plus: std.ArrayList([2]usize) = .empty;
+ var x_off: usize = 0;
+ var y_off: usize = 0;
+ var m_byte: usize = 0;
+ var p_byte: usize = 0;
+ var numer: usize = 0;
+ var denom: usize = 0;
+ var minus_prev: Op = .noop;
+ var plus_prev: Op = .noop;
+ const Take = struct {
+ fn section(tokens: []const []const u8, off: *usize, byte: *usize, n: usize, line: []const u8) [2]usize {
+ const start = byte.*;
+ const end_tok = @min(tokens.len, off.* + n);
+ for (tokens[@min(off.*, end_tok)..end_tok]) |t| byte.* += t.len;
+ off.* = end_tok;
+ byte.* = @min(byte.*, line.len);
+ return .{ start, byte.* };
+ }
+ };
+ for (try a.coalesced(arena)) |run| {
+ const op, const n = run;
+ switch (op) {
+ .deletion => {
+ const r = Take.section(a.x, &x_off, &m_byte, n, minus_line);
+ const w = trimmedWidth(minus_line[r[0]..r[1]]);
+ numer += w;
+ denom += w;
+ try minus.append(arena, r);
+ minus_prev = .deletion;
+ },
+ .noop => {
+ const r = Take.section(a.x, &x_off, &m_byte, n, minus_line);
+ const section = minus_line[r[0]..r[1]];
+ denom += 2 * trimmedWidth(section);
+ const is_space = std.mem.trim(u8, section, " \t").len == 0;
+ const coalesce = is_space and
+ ((minus_prev == .deletion and plus_prev == .insertion and
+ (x_off < a.x.len -| 1 or y_off < a.y.len -| 1)) or
+ (minus_prev == .noop and plus_prev == .noop));
+ if (coalesce and minus_prev == .deletion) try minus.append(arena, r);
+ const pr = Take.section(a.y, &y_off, &p_byte, n, plus_line);
+ if (coalesce and plus_prev == .insertion) try plus.append(arena, pr);
+ minus_prev = .noop;
+ plus_prev = .noop;
+ },
+ .insertion => {
+ const r = Take.section(a.y, &y_off, &p_byte, n, plus_line);
+ const w = trimmedWidth(plus_line[r[0]..r[1]]);
+ numer += w;
+ denom += w;
+ try plus.append(arena, r);
+ plus_prev = .insertion;
+ },
+ }
+ }
+ const distance: f64 = if (denom > 0) @as(f64, @floatFromInt(numer)) / @as(f64, @floatFromInt(denom)) else 0;
+ return .{ .minus = minus.items, .plus = plus.items, .distance = distance };
+}
+
+fn trimmedWidth(section: []const u8) usize {
+ return pardes.panes.File.displayWidth(std.mem.trim(u8, section, " \t"));
+}
+
+// ---- tests ----
+
+const testing = std.testing;
+
+fn emphasised(line: HunkLine) ![]const u8 {
+ var out: std.ArrayList(u8) = .empty;
+ for (line.code, line.styles) |c, s| try out.append(testing.allocator, if (s & syntax.diff_emph != 0) c else '.');
+ return out.toOwnedSlice(testing.allocator);
+}
+
+fn expectEmphasis(minus: []const u8, plus: []const u8, want_minus: []const u8, want_plus: []const u8) !void {
+ var arena_state: std.heap.ArenaAllocator = .init(testing.allocator);
+ defer arena_state.deinit();
+ const arena = arena_state.allocator();
+ var m = [_]HunkLine{.{ .kind = .removed, .code = minus, .styles = try arena.alloc(u8, minus.len), .old = 1, .new = 1 }};
+ var p = [_]HunkLine{.{ .kind = .added, .code = plus, .styles = try arena.alloc(u8, plus.len), .old = 2, .new = 1 }};
+ @memset(m[0].styles, 0);
+ @memset(p[0].styles, 0);
+ try inferEdits(arena, &m, &p);
+ const got_minus = try emphasised(m[0]);
+ defer testing.allocator.free(got_minus);
+ const got_plus = try emphasised(p[0]);
+ defer testing.allocator.free(got_plus);
+ try testing.expectEqualStrings(want_minus, got_minus);
+ try testing.expectEqualStrings(want_plus, got_plus);
+}
+
+test "delta's emphasis: the word a line changed, in both lines" {
+ try expectEmphasis(" let x = foo(1);", " let x = bar(1);", "............foo....", "............bar....");
+ try expectEmphasis("a b c", "a x c", "..b..", "..x..");
+}
+
+test "delta's emphasis: lines too far apart are no change of one another" {
+ try expectEmphasis("completely different text", "nothing alike here at all", ".........................", ".........................");
+}
+
+test "delta's emphasis: a word added keeps the rest plain" {
+ try expectEmphasis("fn run(a: u32)", "fn run(a: u32, b: u32)", "..............", "............., b: u32.");
+}
+
+test "delta's alignment: kitten to sitting, as align.rs has it" {
+ var arena_state: std.heap.ArenaAllocator = .init(testing.allocator);
+ defer arena_state.deinit();
+ const arena = arena_state.allocator();
+ // One token a letter, as delta's test splits them, behind the empty one.
+ const x = [_][]const u8{ "", "k", "i", "t", "t", "e", "n" };
+ const y = [_][]const u8{ "", "s", "i", "t", "t", "i", "n", "g" };
+ const a = try Alignment.init(arena, &x, &y);
+ var ops: std.ArrayList(Op) = .empty;
+ for (try a.coalesced(arena)) |run| for (0..run[1]) |_| try ops.append(arena, run[0]);
+ try testing.expectEqualSlices(Op, &.{ .noop, .deletion, .insertion, .noop, .noop, .noop, .deletion, .insertion, .noop, .insertion }, ops.items);
+}
+
+test "a diff stacks to a label a hunk and its lines, markers gone, tinted and stepped" {
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ const patch =
+ \\diff --git a/nowhere/x.txt b/nowhere/x.txt
+ \\--- a/nowhere/x.txt
+ \\+++ b/nowhere/x.txt
+ \\@@ -1,3 +1,3 @@ section one
+ \\ keep
+ \\-old value
+ \\+new value
+ \\ tail
+ \\
+ ;
+ const result = try format(p, "/pardes-surely-missing-dir", patch);
+ defer p.gpa.free(result.content);
+ defer locations.freeRows(p.gpa, result.rows);
+ try testing.expectEqualStrings("nowhere/x.txt:2\n section one\n keep\n-old value\n+new value\n tail\n", result.content);
+ try testing.expectEqual(@as(usize, 6), result.rows.len);
+ try testing.expectEqual(.match, result.rows[0].kind);
+ try testing.expectEqual(@as(usize, "nowhere/x.txt:2".len), result.rows[0].location_end);
+ try testing.expect(result.rows[1].declaration);
+ const removed = result.rows[3];
+ try testing.expect(removed.colors[0] & syntax.diff_removed != 0);
+ // Paired with the line it changed: no whole-line tint.
+ try testing.expect(removed.colors[0] & syntax.diff_whole == 0);
+ try testing.expect(removed.colors[1] & syntax.diff_emph != 0);
+ try testing.expect(removed.colors[5] & syntax.diff_emph == 0);
+ try testing.expect(result.rows[4].colors[0] & syntax.diff_added != 0);
+ try testing.expect(result.rows[2].colors[0] & (syntax.diff_added | syntax.diff_removed) == 0);
+}
+
+test "a hunk the file has moved since is found where it went, inside its declaration" {
+ if (!syntax.supportsPath("a.zig")) return error.SkipZigTest;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ var tmp = testing.tmpDir(.{});
+ defer tmp.cleanup();
+ // Two lines more above it than the patch knows of.
+ try tmp.dir.writeFile(testing.io, .{ .sub_path = "a.zig", .data = "// one\n// two\nconst S = struct {\n fn f() void {\n a();\n b();\n }\n};\n" });
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const dir = buf[0..try tmp.dir.realPath(testing.io, &buf)];
+ const patch =
+ \\--- a.zig
+ \\+++ a.zig
+ \\@@ -3,3 +3,3 @@ git's guess
+ \\ fn f() void {
+ \\- c();
+ \\+ a();
+ \\ b();
+ \\
+ ;
+ const result = try format(p, dir, patch);
+ defer p.gpa.free(result.content);
+ defer locations.freeRows(p.gpa, result.rows);
+ try testing.expect(std.mem.indexOf(u8, result.content, "a.zig:3\n const S = struct {\na.zig:5 *\n") != null);
+ try testing.expect(std.mem.indexOf(u8, result.content, "git's guess") == null);
+}
+
+test "a mailed patch keeps its headers, message and diffstat above its hunks" {
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ const patch =
+ \\From 0123 Mon Sep 17 00:00:00 2001
+ \\Subject: [PATCH] change x
+ \\
+ \\Why it changed.
+ \\---
+ \\ x.txt | 2 +-
+ \\
+ \\diff --git a/x.txt b/x.txt
+ \\index 1..2 100644
+ \\--- a/x.txt
+ \\+++ b/x.txt
+ \\@@ -1 +1 @@
+ \\-a
+ \\+b
+ \\
+ ;
+ const result = try format(p, "/pardes-surely-missing-dir", patch);
+ defer p.gpa.free(result.content);
+ defer locations.freeRows(p.gpa, result.rows);
+ try testing.expectEqualStrings("From 0123 Mon Sep 17 00:00:00 2001\nSubject: [PATCH] change x\n\nWhy it changed.\n---\n x.txt | 2 +-\n\nx.txt:1\n-a\n+b\n", result.content);
+}
+
+test "DiffLook hunks: a .patch looked at opens its +Diff; Diff goes to the text and back; DiffLook text opens the text" {
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ var tmp = testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(testing.io, .{ .sub_path = "x.txt", .data = "b\n" });
+ try tmp.dir.writeFile(testing.io, .{ .sub_path = "c.patch", .data = "--- x.txt\n+++ x.txt\n@@ -1 +1 @@\n-a\n+b\n" });
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const dir = buf[0..try tmp.dir.realPath(testing.io, &buf)];
+ const patch = try std.fs.path.join(testing.allocator, &.{ dir, "c.patch" });
+ defer testing.allocator.free(patch);
+ const hunks_path = try std.fs.path.join(testing.allocator, &.{ dir, "+Diff" });
+ defer testing.allocator.free(hunks_path);
+ const Count = struct {
+ fn of(pp: *Pardes, path: []const u8) usize {
+ var n: usize = 0;
+ for (pp.panes) |slot| if (slot) |pane| if (pane.file) |f| {
+ n += @intFromBool(std.mem.eql(u8, f.path, path));
+ };
+ return n;
+ }
+ };
+ try testing.expectEqual(pardes.config.Runtime.DiffLook.hunks, p.settings.diff_look);
+ pardes.look.lookAt(p, 0, patch);
+ try testing.expectEqual(@as(usize, 1), Count.of(p, hunks_path));
+ try testing.expectEqual(@as(usize, 0), Count.of(p, patch));
+ const hid = p.active;
+ try testing.expectEqualStrings(hunks_path, p.panes[hid].?.file.?.path);
+ try testing.expectEqualStrings("x.txt:1\n-a\n+b\n", p.panes[hid].?.file.?.content);
+ // Diff on it: the patch as text.
+ try testing.expect(p.executeBuiltinLine(hid, "Diff"));
+ try testing.expectEqual(@as(usize, 1), Count.of(p, patch));
+ const raw = p.active;
+ try testing.expectEqualStrings(patch, p.panes[raw].?.file.?.path);
+ // Diff on the text: the +Diff again, refilled, not another.
+ try testing.expect(p.executeBuiltinLine(raw, "Diff"));
+ try testing.expectEqual(@as(usize, 1), Count.of(p, hunks_path));
+ // DiffLook text: a look opens the text (here the pane already open).
+ try testing.expect(p.executeBuiltinLine(0, "DiffLook text"));
+ try p.removePane(raw, null);
+ pardes.look.lookAt(p, 0, patch);
+ try testing.expectEqual(@as(usize, 1), Count.of(p, patch));
+}
+
+test "a hunk edited since, beside siblings with its signature's tail, is found in its own function" {
+ if (!syntax.supportsPath("a.rs")) return error.SkipZigTest;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ var tmp = testing.tmpDir(.{});
+ defer tmp.cleanup();
+ // Three functions ending in one signature's tail; the patch is for the
+ // third, which has moved down a line and had a line inside it edited.
+ try tmp.dir.writeFile(testing.io, .{ .sub_path = "a.rs", .data =
+ \\// moved
+ \\fn one(
+ \\ limit: usize,
+ \\) -> u32 {
+ \\ 1
+ \\}
+ \\fn two(
+ \\ limit: usize,
+ \\) -> u32 {
+ \\ 2
+ \\}
+ \\fn three(
+ \\ limit: usize,
+ \\) -> u32 {
+ \\ let guard = enter();
+ \\ let a = 3;
+ \\ let b = a + 1;
+ \\ let c = b * 2; // edited since
+ \\ c
+ \\}
+ \\
+ });
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const dir = buf[0..try tmp.dir.realPath(testing.io, &buf)];
+ const patch =
+ \\--- a.rs
+ \\+++ a.rs
+ \\@@ -12,7 +12,8 @@ git's guess
+ \\ limit: usize,
+ \\ ) -> u32 {
+ \\+ let guard = enter();
+ \\ let a = 3;
+ \\ let b = a + 1;
+ \\ let c = b * 2;
+ \\ c
+ \\
+ ;
+ const result = try format(p, dir, patch);
+ defer p.gpa.free(result.content);
+ defer locations.freeRows(p.gpa, result.rows);
+ try testing.expect(std.mem.indexOf(u8, result.content, "a.rs:12\n fn three(\na.rs:15 *\n") != null);
+}
diff --git a/src/locations.zig b/src/locations.zig
index 6a604907..7755f6fd 100644
--- a/src/locations.zig
+++ b/src/locations.zig
@@ -159,7 +159,9 @@ const Pending = struct {
const Source = struct { path: []const u8, bytes: []const u8 };
-fn sourceText(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8, path: []const u8) ?Source {
+/// A file's text as a look from `dir` finds it: an open pane's, unsaved
+/// edits and all, else the disk's. Null for a PDF or one not there.
+pub fn sourceText(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8, path: []const u8) ?Source {
if (std.ascii.eqlIgnoreCase(std.fs.path.extension(path), ".pdf")) return null;
const lexical = std.fs.path.resolvePosix(arena, &.{ dir, path }) catch return null;
var pathbuf: [4096]u8 = undefined;
diff --git a/src/look.zig b/src/look.zig
index 41cfdc0c..6ba6a8d0 100644
--- a/src/look.zig
+++ b/src/look.zig
@@ -1869,6 +1869,18 @@ pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void {
const before = p.active;
var opened: ?usize = null;
if (!focusPaneByPath(p, target.path, target.at)) {
+ // A .diff or .patch looked at bare: its hunks stacked in a
+ // +Diff (DiffLook hunks), which takes the keyboard as the
+ // file would; one with none in it opens as text.
+ if (p.settings.diff_look == .hunks and !p.look_text and target.at.line == 0 and
+ (std.mem.endsWith(u8, target.path, ".diff") or std.mem.endsWith(u8, target.path, ".patch")))
+ if (filesystem.read(p, target.path)) |bytes| {
+ defer p.gpa.free(bytes);
+ if (panes.Output.openDiff(p, id, target.path, bytes)) |hid| {
+ p.active = hid;
+ return;
+ } else |_| {}
+ } else |_| {};
const free = p.freeSlot() orelse return p.reportError(id, "look", error.NoPaneSlots);
const nt = panes.File.open(p, free, target.path, target.at.line) catch |err|
return lookOpenFailed(p, id, target.path, err);
diff --git a/src/main.zig b/src/main.zig
index ed70b624..26259b43 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -102,7 +102,7 @@ const help_text =
;
/// `pardes -` inside a session: `text`, stdin as it came, escapes and all,
-/// into the directory's one +Pager (/pager, refilled when it is there):
+/// into a new +Pager of the directory (/pager):
/// written after the directory on that one open, the session parses it
/// (pager.zig) and puts it in as one undo step, left clean. A text the
/// session would not take is never lost: it goes to stderr, a terminal,
diff --git a/src/mouse.zig b/src/mouse.zig
index 8020fda8..733479dd 100644
--- a/src/mouse.zig
+++ b/src/mouse.zig
@@ -1288,7 +1288,7 @@ fn dragRelease(p: *Pardes, button: Mouse.Button) void {
pane.sel[sel_slot].state = .none;
pane.body.vsel = .{ .active = true, .row = @intCast(a.row), .col = @intCast(a.col), .explicit = true };
};
- if (s.ctrl) p.lspRequest(s.id, .definition, "");
+ if (s.ctrl) exec.runBuiltin(p, .Def, s.id, "", null);
}
} else {
const clk = pane.sel[b];
diff --git a/src/ninep/ctl.zig b/src/ninep/ctl.zig
index c9ce41e1..e6e738a5 100644
--- a/src/ninep/ctl.zig
+++ b/src/ninep/ctl.zig
@@ -682,7 +682,7 @@ pub fn readRoot(p: *Pardes, req: Req) Reply {
}
/// /pager, `pardes -`'s: the directory written (empty, or not absolute: the
-/// session's) gets its one +Pager, made or emptied; the serial is what a
+/// session's) gets a new +Pager; the serial is what a
/// read of this same open answers, never another client's. What the open
/// writes after that line is the text, held by tree.zig for `fillPager`.
pub fn writePager(p: *Pardes, req: Req) Reply {
@@ -742,6 +742,16 @@ pub fn fillPager(p: *Pardes, serial: u32, held: *std.ArrayList(u8)) error{OutOfM
panes.File.setContent(p, f, page.text);
f.pager_spans = page.spans;
f.saved_revision = f.revision;
+ // A diff paged (`git show`, difftui's patches): its hunks stacked in a
+ // +Diff (DiffLook hunks), the +Pager folded to its tag under it for
+ // Diff to bring back. The keyboard stays where it was, as a page's.
+ if (f.pager_diff and p.settings.diff_look == .hunks) {
+ const keyboard = p.active;
+ if (panes.Output.openDiff(p, id, f.path, f.content)) |_| {
+ if (!pane.collapsed) pardes.layout.toggleCollapse(p, id);
+ } else |_| {}
+ if (p.panes[keyboard] != null) p.active = keyboard;
+ }
}
/// The editor's step: the text of /pager opens closed unread goes in.
@@ -2258,7 +2268,8 @@ test "a builtin for one kind of pane is refused on another, and still acts on it
.{ "Petscii\n", "Petscii: only an image or a terminal pane takes it" },
.{ "Palette\n", "Palette: only an image pane takes it" },
.{ "Ascii\n", "Ascii: only an image pane takes it" },
- .{ "Filter\n", "Filter: only a terminal pane takes it" },
+ .{ "Filter\n", "Filter: only a terminal or a +Pager pane takes it" },
+ .{ "Diff\n", "Diff: only a diff or a +Diff pane takes it" },
.{ "Togglettymode\n", "Togglettymode: only a terminal pane takes it" },
};
for (cases) |case| {
@@ -4607,10 +4618,15 @@ test "pager answers its +Pager on the open that asked, whatever another client e
try testing.expectEqual(E.INVAL, call(p, .{ .tag = 8, .op = .write, .node = pager, .handle = refused, .data = "relative\n" }).errno());
try testing.expectEqualStrings("", call(p, .{ .tag = 9, .op = .read, .node = pager, .handle = refused, .size = 64 }).bytes);
_ = call(p, .{ .tag = 10, .op = .release, .node = pager, .handle = refused, .opened = true });
- // Resolved: `/tmp/../tmp/.` is /tmp's +Pager, the one made above.
+ // Resolved: `/tmp/../tmp/.` is /tmp, a +Pager of its own beside the
+ // one made above, which keeps its page.
const resolved = call(p, .{ .tag = 11, .op = .open, .node = pager, .omode = 2 }).reply.handle;
try testing.expectEqual(Status.ok, call(p, .{ .tag = 12, .op = .write, .node = pager, .handle = resolved, .data = "/tmp/../tmp/.\n" }).reply.status);
- try testing.expectEqualStrings(want, call(p, .{ .tag = 13, .op = .read, .node = pager, .handle = resolved, .size = 64 }).bytes);
+ const second = call(p, .{ .tag = 13, .op = .read, .node = pager, .handle = resolved, .size = 64 }).bytes;
+ try testing.expect(!std.mem.eql(u8, want, second));
+ const second_pane = p.panes[p.paneBySerial(try std.fmt.parseInt(u32, std.mem.trim(u8, second, "\n"), 10)).?].?;
+ try testing.expectEqualStrings("/tmp/+Pager", second_pane.file.?.path);
+ try testing.expect(p.paneBySerial(paged) != null);
_ = call(p, .{ .tag = 14, .op = .release, .node = pager, .handle = resolved, .opened = true });
// One that may not be written is refused, permission denied.
try testing.expectEqual(E.PERM, wr(p, pager, "/proc/1\n").errno());
@@ -4667,15 +4683,24 @@ test "what a /pager open writes after its directory is the text: plain in the bo
// PagerColor off, and an open closed with no read: the same text, plain,
// in at the editor's next step (a close through a mount never waits).
p.settings.pager_color = false;
+ const kept = try testing.allocator.dupe(u8, f.content);
+ defer testing.allocator.free(kept);
const shut = call(p, .{ .tag = 7, .op = .open, .node = pager, .omode = 1 }).reply.handle;
try testing.expectEqual(Status.ok, call(p, .{ .tag = 8, .op = .write, .node = pager, .handle = shut, .data = "/tmp\n" }).reply.status);
try testing.expectEqual(Status.ok, call(p, .{ .tag = 9, .op = .write, .node = pager, .handle = shut, .data = "\x1b[1;32mgreen\x1b[m\n" }).reply.status);
_ = call(p, .{ .tag = 10, .op = .release, .node = pager, .handle = shut, .opened = true });
- try testing.expectEqualStrings("", f.content);
+ // A new +Pager: the first keeps its page.
+ try testing.expectEqualStrings(kept, f.content);
+ const next = for (p.panes) |slot| {
+ const other = slot orelse continue;
+ if (other == pn) continue;
+ if (other.file) |*of| if (std.mem.eql(u8, of.path, "/tmp/+Pager")) break of;
+ } else return error.NoPager;
+ try testing.expectEqualStrings("", next.content);
fillClosedPagers(p);
- try testing.expectEqualStrings("green\n", f.content);
- try testing.expectEqual(@as(usize, 0), f.pager_spans.len);
- try testing.expectEqual(f.revision, f.saved_revision);
+ try testing.expectEqualStrings("green\n", next.content);
+ try testing.expectEqual(@as(usize, 0), next.pager_spans.len);
+ try testing.expectEqual(next.revision, next.saved_revision);
}
test "a command pane an exec open was answered is leased to it while it stays open: another client's command gets a pane of its own" {
diff --git a/src/ninep/tree.zig b/src/ninep/tree.zig
index c78a1aa2..eedab43b 100644
--- a/src/ninep/tree.zig
+++ b/src/ninep/tree.zig
@@ -258,7 +258,7 @@ pub const TopFile = enum(u5) {
/// The files opened lately, closed ones too, a line each:
/// `open|closed <path>`, most recent first.
recent,
- /// `pardes -`'s: a directory written, its +Pager made or emptied; a
+ /// `pardes -`'s: a directory written, a new +Pager made there; a
/// read of the same open answers its serial.
pager,
diff --git a/src/normal.zig b/src/normal.zig
index 93487e88..aec6b983 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -743,14 +743,15 @@ fn executeNormalAction(p: *Pardes, t: *Text, semantic: modal.Normal.Action) void
.undo => return edit.doUndo(p, t),
.redo => return edit.doRedo(p, t),
},
- .lsp => |request| return p.lspRequest(p.active, switch (request) {
- .definition => .definition,
- .declaration => .declaration,
- .type_definition => .type_definition,
- .implementation => .implementation,
- .references => .references,
- .format => .format,
- }, ""),
+ // gd and gr are the Def and Refs a tag shows, run as a click runs them.
+ .lsp => |request| return switch (request) {
+ .definition => exec.runBuiltin(p, .Def, p.active, "", null),
+ .references => exec.runBuiltin(p, .Refs, p.active, "", null),
+ .declaration => p.lspRequest(p.active, .declaration, ""),
+ .type_definition => p.lspRequest(p.active, .type_definition, ""),
+ .implementation => p.lspRequest(p.active, .implementation, ""),
+ .format => p.lspRequest(p.active, .format, ""),
+ },
.adjust_number => |delta| return edit.normalAdjustNumber(p, t, delta),
.leader => if (p.macro.replaying == 0) {
p.leader_on = true;
diff --git a/src/pardes.zig b/src/pardes.zig
index 2a74e441..29192c33 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -480,6 +480,7 @@ pub const Loc = struct {
test {
_ = @import("tagline.zig");
+ _ = @import("hunks.zig");
_ = @import("builtins_json.zig");
_ = @import("exec.zig");
_ = @import("look.zig");
@@ -864,7 +865,7 @@ test "TreeContext command and custom tag survive a workspace round trip" {
p.gpa.free(pane.file.?.path);
pane.file.?.path = path;
if (!panes.File.supportsContext(pane)) return error.SkipZigTest;
- try std.testing.expectEqualStrings(tagline.context_pane_tail, tagline.curTail(pane));
+ try std.testing.expectEqualStrings(if (lsp.speaks("/test.zig")) tagline.lsp_context_pane_tail else tagline.context_pane_tail, tagline.curTail(pane));
try std.testing.expect(!pane.file.?.tree_context);
try std.testing.expect(p.executeBuiltinLine(0, "TreeContext on"));
try std.testing.expect(pane.file.?.tree_context);
@@ -920,7 +921,7 @@ test "Togglettymode builtin and keyboard chord share mode transitions including
try std.testing.expectEqualStrings("unchanged\n", file.file.?.content);
}
-test "Filter is ordered after Del and toggles only its terminal pane" {
+test "Filter is ordered after Del and toggles only its terminal or +Pager pane" {
const testing = std.testing;
const del = std.meta.stringToEnum(Builtin, "Del") orelse return error.MissingDelBuiltin;
const filter = std.meta.stringToEnum(Builtin, "Filter") orelse return error.MissingFilterBuiltin;
@@ -954,6 +955,17 @@ test "Filter is ordered after Del and toggles only its terminal pane" {
try testing.expect(p.executeBuiltinLine(0, "Filter"));
try testing.expect(first.tty_filter);
try testing.expect(!second.tty_filter);
+
+ // A +Pager opens filtered, with Filter on its tag and no line numbers;
+ // a second is a pane of its own.
+ const pager_id = try panes.Output.openPager(p, 0, "/tmp");
+ const pager_pane = p.panes[pager_id].?;
+ try testing.expect(pager_pane.tty_filter);
+ try testing.expectEqualStrings(tagline.pager_pane_tail, tagline.curTail(pager_pane));
+ try testing.expectEqual(@as(u16, 0), panes.File.gutterWidth(pager_pane));
+ try testing.expect(p.executeBuiltinLine(pager_id, "Filter"));
+ try testing.expect(!pager_pane.tty_filter);
+ try testing.expect(try panes.Output.openPager(p, 0, "/tmp") != pager_id);
}
test "compact tag commands stay beside their own prefix across layout changes" {
@@ -1194,6 +1206,73 @@ test "Lspwhy after a Hover asks to explain that hover, in its file at its place,
try std.testing.expect(seen);
}
+test "Def and Refs are a speaking file's tag words; gd, gr and a 2-1 chord all run them" {
+ if (!lsp.supports.contains(.definition)) return error.SkipZigTest;
+ const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 24, .tty_only = true });
+ defer p.deinit();
+ const pane = try p.setTestFile("const alpha = 1;\nconst beta = alpha;\n");
+ // A .txt has no server: no Def, no Refs.
+ try std.testing.expect(std.mem.indexOf(u8, tagline.curTail(pane), "Def") == null);
+ const f = &pane.file.?;
+ p.gpa.free(f.path);
+ f.path = try p.gpa.dupe(u8, "/tmp/x.zig");
+ try std.testing.expect(std.mem.endsWith(u8, tagline.curTail(pane), " Def Refs"));
+ p.sync();
+ while (p.nextEffect()) |_| {}
+ const Asked = struct {
+ fn one(q: *Pardes, kind: lsp.Kind) !u32 {
+ var at: ?u32 = null;
+ while (q.nextEffect()) |e| if (e == .lsp) {
+ try std.testing.expectEqual(kind, e.lsp.kind);
+ try std.testing.expectEqualStrings("", e.lsp.arg.slice());
+ try std.testing.expect(at == null);
+ at = e.lsp.offset;
+ };
+ q.lsp_wait = null;
+ return at orelse error.NothingAsked;
+ }
+ };
+ // gd and gr: at the cursor, on `alpha`'s declaration.
+ pane.body.cur_row = 0;
+ pane.body.cur_col = 8;
+ p.update(.{ .key = .{ .cp = 'g' } });
+ p.update(.{ .key = .{ .cp = 'd' } });
+ try std.testing.expectEqual(@as(u32, 8), try Asked.one(p, .definition));
+ p.update(.{ .key = .{ .cp = 'g' } });
+ p.update(.{ .key = .{ .cp = 'r' } });
+ try std.testing.expectEqual(@as(u32, 8), try Asked.one(p, .references));
+
+ const r = p.rects[0];
+ const x0 = r.x + config.GUTTER + panes.File.gutterWidth(pane);
+ const use_y = p.bodyTop(pane, r) + 1;
+ const tag = try tagline.tagText(p, p.scratch.allocator(), pane);
+ for ([_]struct { word: []const u8, kind: lsp.Kind }{ .{ .word = " Def ", .kind = .definition }, .{ .word = " Refs", .kind = .references } }) |w| {
+ // B1 sweeps the use of `alpha` on the second line (bytes 30..35),
+ // leaving the cursor at its far end.
+ p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = x0 + 13, .row = use_y } });
+ p.update(.{ .mouse = .{ .button = config.select_button, .kind = .drag, .col = x0 + 17, .row = use_y } });
+ p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = x0 + 17, .row = use_y } });
+ // B2 on the tag word, B1 clicked while it is held: the sweep is its
+ // argument, and it asks at the start of `alpha`, not at the cursor.
+ const wx = r.x + TAG_TEXT_INSET + @as(u16, @intCast(std.mem.indexOf(u8, tag, w.word).? + 1));
+ p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .press, .col = wx, .row = r.y } });
+ p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = wx, .row = r.y } });
+ p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = wx, .row = r.y } });
+ p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .release, .col = wx, .row = r.y } });
+ try std.testing.expectEqual(@as(u32, 30), try Asked.one(p, w.kind));
+ // Clicked bare, it asks at the cursor, where the sweep left it.
+ pane.body.cur_row = 0;
+ pane.body.cur_col = 2;
+ p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .press, .col = wx, .row = r.y } });
+ p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .release, .col = wx, .row = r.y } });
+ try std.testing.expectEqual(@as(u32, 2), try Asked.one(p, w.kind));
+ }
+ // A symbol the file does not hold is said, and nothing is asked.
+ exec.runBuiltin(p, .Def, 0, "", "gamma");
+ try std.testing.expectError(error.NothingAsked, Asked.one(p, .definition));
+ try std.testing.expectEqualStrings("Def: no gamma in this file", pane.msg[0..pane.msg_len]);
+}
+
test "the Tutor pane is named +Tutor in the session's directory, never a bare path at the root" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
@@ -4508,6 +4587,9 @@ pub const Pardes = struct {
chord_hold: bool = false,
/// The look just run found nothing (look.zig missed).
look_missed: bool = false,
+ /// The look being run opens a .diff or .patch as text whatever DiffLook
+ /// says: Diff going back from a +Diff, Edit's B (it edits the file).
+ look_text: bool = false,
look_hover_wait: ?look.LookHoverWait = null,
/// The place a look-hover last found nothing to open: the pointer
/// resting there does not ask again every frame (look.noteLookHover).
@@ -4748,6 +4830,8 @@ pub const Pardes = struct {
const named = try std.fs.path.join(gpa, &.{ dir, "+Pager" });
gpa.free(shown.file.?.path);
shown.file.?.path = named;
+ shown.file.?.pager = true;
+ shown.tty_filter = true;
shown.file.?.pager_diff = panes.File.looksLikeDiff(content[0..@min(content.len, 64 * 1024)]);
shown.file.?.pager_spans = page.spans;
p.oneColumn();
@@ -6674,7 +6758,8 @@ pub const Pardes = struct {
pub const SavePath = Effect.Buf(effect_path_cap);
- pub fn lspRequest(p: *Pardes, asked: usize, kind: lsp.Kind, arg: []const u8) void {
+ pub fn lspRequest(p: *Pardes, asked: usize, kind: lsp.Kind, arg_in: []const u8) void {
+ var arg = arg_in;
if (!normal.multiOnce(p)) return; // one question per keystroke, from the primary
// Lspwhy narrates the last query where it was asked -- that pane's
// file, place and argument -- from wherever it is run.
@@ -6697,10 +6782,30 @@ pub const Pardes = struct {
(!zig_buf and std.mem.indexOfAny(u8, arg, " \t\r\n\"\\") != null))
return p.reportFailure(id, std.fmt.bufPrint(&said, "Rename: {s} is no name", .{arg}) catch "Rename: no name");
}
- const off = if (pane.file) |f| modal.offsetAt(f.content, .{
+ var off = if (pane.file) |f| modal.offsetAt(f.content, .{
.row = @intCast(@max(0, pane.body.cur_row)),
.col = @intCast(@max(0, pane.body.cur_col)),
}) else 0;
+ // Def or Refs given a symbol (a 2-1 chord's selection) asks at its
+ // occurrence nearest the cursor, which a sweep leaves at one end of
+ // what it selected; the server is asked at a place, never a name.
+ if ((kind == .definition or kind == .references) and arg.len > 0) {
+ const content = pane.file.?.content;
+ var nearest: ?usize = null;
+ var best: usize = 0;
+ var from: usize = 0;
+ while (std.mem.indexOfPos(u8, content, from, arg)) |at_hit| : (from = at_hit + 1) {
+ const d = if (at_hit > off) at_hit - off else off -| (at_hit + arg.len);
+ if (nearest != null and at_hit > off and d >= best) break;
+ if (nearest == null or d < best) {
+ nearest = at_hit;
+ best = d;
+ }
+ }
+ off = nearest orelse
+ return p.reportFailure(id, std.fmt.bufPrint(&said, "{s}: no {s} in this file", .{ lspWord(kind), arg }) catch "no such symbol in this file");
+ arg = "";
+ }
// Lspwhy asks the last query again, narrated: its kind and argument,
// at its place when asked from its pane. None yet: a definition.
var explained: [160]u8 = undefined;
@@ -6858,6 +6963,8 @@ pub const Pardes = struct {
fn lspWord(kind: lsp.Kind) []const u8 {
return switch (kind) {
.hover => "Hover",
+ .definition => "Def",
+ .references => "Refs",
.explain => "Lspwhy",
.incoming_calls => "Callers",
.outgoing_calls => "Callees",
diff --git a/src/syntax.zig b/src/syntax.zig
index b7406b04..89d96239 100644
--- a/src/syntax.zig
+++ b/src/syntax.zig
@@ -854,7 +854,13 @@ pub fn highlightLocationRows(gpa: std.mem.Allocator, content: []const u8, rows:
if (comptime @hasField(@TypeOf(row), "location_end")) {
address_only = row.location_end > 0 and source_start == end;
}
- if (!address_only) {
+ // A row its producer coloured whole is coloured below: no
+ // fragment of it to parse.
+ var coloured = false;
+ if (comptime @hasField(@TypeOf(row), "colors")) {
+ coloured = row.colors.len > 0 and row.colors.len >= end - source_start;
+ }
+ if (!address_only and !coloured) {
sources[source_count] = .{ .index = index, .start = source_start, .len = end - source_start };
source_count += 1;
}
@@ -1037,10 +1043,15 @@ fn childOfKind(node: ts.Node, kind: []const u8) ?ts.Node {
/// A diff line's style byte carries whether the line was added or removed
/// over its syntax style (the low bits), so the painter can tint its row
-/// and mark its prefix.
+/// and mark its prefix; Diff marks the words a changed line changed
+/// (hunks.zig), drawn on a stronger tint.
pub const diff_added: u8 = 0x80;
pub const diff_removed: u8 = 0x40;
-pub const syn_bits: u8 = 0x3f;
+pub const diff_emph: u8 = 0x20;
+/// A +Diff line added or removed whole, paired with no line it changed:
+/// its row takes a faint tint, on its marker's byte.
+pub const diff_whole: u8 = 0x10;
+pub const syn_bits: u8 = 0x0f;
/// A file section's hunks are parsed together, each side as one text, in
/// pieces: a piece takes whole hunks until it holds `diff_piece_lines`
diff --git a/src/tagline.zig b/src/tagline.zig
index d13f3c5f..cf0b17fd 100644
--- a/src/tagline.zig
+++ b/src/tagline.zig
@@ -21,6 +21,13 @@ pub const pdf_pane_tail = " " ++ config.pdf_pane_builtins_str;
pub const file_pane_tail = " " ++ config.file_pane_builtins_str;
pub const context_pane_tail = file_pane_tail ++ " TreeContext";
pub const locations_pane_tail = file_pane_tail ++ " LocationsConfig";
+/// A file a language server speaks for (by its extension): its jumps too.
+pub const lsp_pane_tail = file_pane_tail ++ " " ++ config.lsp_pane_builtins_str;
+pub const lsp_context_pane_tail = context_pane_tail ++ " " ++ config.lsp_pane_builtins_str;
+pub const pager_pane_tail = " " ++ config.pager_pane_builtins_str;
+pub const diff_pane_tail = " " ++ config.diff_pane_builtins_str;
+pub const pager_diff_pane_tail = " " ++ config.pager_diff_pane_builtins_str;
+pub const diff_view_tail = " " ++ config.diff_view_builtins_str ++ " LocationsConfig";
pub const terminal_pane_tail = " " ++ config.terminal_pane_builtins_str;
pub const command_pane_tail = " " ++ config.command_pane_builtins_str;
pub const dir_pane_tail = " " ++ config.dir_pane_builtins_str;
@@ -164,10 +171,15 @@ pub fn curTail(pane: *Pane) []const u8 {
pub fn defaultTail(pane: *const Pane) []const u8 {
if (comptime pdf_enabled) if (pane.pdf != null) return pdf_pane_tail;
if (pane.file) |file| if (file.listing != null) return dir_pane_tail;
- if (pane.file) |file| if (file.output) |out|
+ if (pane.file) |file| if (file.pager) return if (file.pager_diff) pager_diff_pane_tail else pager_pane_tail;
+ if (pane.file != null and pane.colorAlgo() == .diff) return diff_pane_tail;
+ if (pane.file) |file| if (file.output) |out| {
+ if (std.meta.eql(out.from, panes.Output.Origin{ .cmd = .Diff })) return diff_view_tail;
if (panes.Output.usesLocationsConfig(out.from)) return locations_pane_tail;
- if (panes.File.supportsContext(pane)) return context_pane_tail;
- if (pane.file != null) return file_pane_tail;
+ };
+ const speaks = if (pane.file) |file| file.output == null and file.mini == null and pardes.lsp.speaks(file.path) else false;
+ if (panes.File.supportsContext(pane)) return if (speaks) lsp_context_pane_tail else context_pane_tail;
+ if (pane.file != null) return if (speaks) lsp_pane_tail else file_pane_tail;
if (pane.command != null) return command_pane_tail;
if (pane.isTerminal()) return if (pane.shell_tail_len > 0) pane.shell_tail[0..pane.shell_tail_len] else terminal_pane_tail;
return pane_tail;
diff --git a/src/terminal.zig b/src/terminal.zig
index 3bb1fbda..3190c6e3 100644
--- a/src/terminal.zig
+++ b/src/terminal.zig
@@ -2041,7 +2041,7 @@ pub fn recolorAnsi(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16
const filtered: ?*FilteredColors = if (pane.tty_filter) blk: {
const tz_filter = tracy.zone(@src(), "filterInit");
defer tz_filter.end();
- filtered_storage = FilteredColors.init(p, pane);
+ filtered_storage = FilteredColors.init(p, &pane.terminal.?.vt);
break :blk &filtered_storage;
} else null;
// DECSCNM, read once: the filtered palette folds it in itself, the raw
@@ -2192,7 +2192,9 @@ fn cellStyle(p: *Pardes, ci: ghostty_vt.PageList.Cell, filtered: ?*FilteredColor
return cs;
}
-const FilteredColors = struct {
+/// A program's colours mapped to the theme (Filter): a terminal's cells, or
+/// a +Pager's spans (`vt` null, the program's palette xterm's own).
+pub const FilteredColors = if (enabled) struct {
source: GColor.Palette,
target: *const GColor.Palette,
theme_bg: GColor.RGB,
@@ -2212,16 +2214,18 @@ const FilteredColors = struct {
cache_key: [256]u8 = undefined,
cache_valid: [256]bool = @splat(false),
- fn init(p: *Pardes, pane: *const Pane) FilteredColors {
+ pub fn init(p: *Pardes, vt: ?*const ghostty_vt.Terminal) FilteredColors {
var source = GColor.default;
- for (&source, 0..) |*rgb, i|
- rgb.* = pane.terminal.?.vt.colorForXterm(.{ .palette = @intCast(i) }) orelse rgb.*;
+ if (vt) |t| {
+ for (&source, 0..) |*rgb, i|
+ rgb.* = t.colorForXterm(.{ .palette = @intCast(i) }) orelse rgb.*;
+ }
const theme = p.theme();
var theme_bg = asGhostRgb(theme.bg orelse theme.tag_bg);
var theme_fg = asGhostRgb(theme.fg orelse theme.tag_fg);
- var dynamic_bg = pane.terminal.?.vt.colorForXterm(.{ .dynamic = .background });
- var dynamic_fg = pane.terminal.?.vt.colorForXterm(.{ .dynamic = .foreground });
- if (pane.terminal.?.vt.modes.get(.reverse_colors)) {
+ var dynamic_bg = if (vt) |t| t.colorForXterm(.{ .dynamic = .background }) else null;
+ var dynamic_fg = if (vt) |t| t.colorForXterm(.{ .dynamic = .foreground }) else null;
+ if (vt != null and vt.?.modes.get(.reverse_colors)) {
std.mem.swap(GColor.RGB, &theme_bg, &theme_fg);
std.mem.swap(?GColor.RGB, &dynamic_bg, &dynamic_fg);
}
@@ -2280,6 +2284,18 @@ const FilteredColors = struct {
return asPardesColor(self.keyedRgb(style.bg(cell, &self.source).?));
}
+ /// A +Pager span's colour (pager.zig), as `fg` and `bg` map a cell's.
+ pub fn spanColor(self: *FilteredColors, color: pardes.Color, is_bg: bool) pardes.Color {
+ return switch (color) {
+ .default => color,
+ .index => |idx| if (is_bg) self.bg_for_palette[idx] else self.fg_for_palette[idx],
+ .rgb => |rgb| blk: {
+ const keyed = self.keyedRgb(asGhostRgb(rgb));
+ break :blk asPardesColor(if (is_bg) keyed else self.legible(keyed));
+ },
+ };
+ }
+
fn legible(self: *const FilteredColors, rgb: GColor.RGB) GColor.RGB {
if (contrastOf(luminanceOf(rgb), self.default_bg_luminance) >=
config.tty_filter_min_contrast) return rgb;
@@ -2317,7 +2333,7 @@ const FilteredColors = struct {
self.cache_valid[slot] = true;
return best;
}
-};
+} else struct {};
const channel_luminance: [256]f64 = blk: {
@setEvalBranchQuota(20000);
@@ -2570,7 +2586,7 @@ test "terminal Filter maps the default roles before it maps anything else" {
// the null-page fallback that only the legacy dark theme exercises.
for (0..9) |t| {
p.settings.theme = @intCast(t);
- const stage_one = FilteredColors.init(p, pane);
+ const stage_one = FilteredColors.init(p, &pane.terminal.?.vt);
// `dark` declares no background of its own, which is exactly why the
// resolver reads the tag colours as the fallback rather than `.?`.
const theme = p.theme();
@@ -2584,7 +2600,7 @@ test "terminal Filter maps the default roles before it maps anything else" {
p.settings.theme = 0;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]11;#5f5f5f\x1b\\" } });
- var moved = FilteredColors.init(p, pane);
+ var moved = FilteredColors.init(p, &pane.terminal.?.vt);
try testing.expect(!moved.default_bg.eql(moved.theme_bg));
try testing.expect(moved.default_bg.eql(moved.keyedRgb(.{ .r = 0x5f, .g = 0x5f, .b = 0x5f })));
}
@@ -2609,7 +2625,7 @@ test "terminal Filter refuses a foreground that would collapse onto the page" {
for (0..9) |t| {
p.settings.theme = @intCast(t);
- var fc = FilteredColors.init(p, pane);
+ var fc = FilteredColors.init(p, &pane.terminal.?.vt);
const page = asPardesColor(fc.default_bg);
const rescued = asPardesColor(fc.fallback_fg);
_ = frame.reset(.retain_capacity);
@@ -2661,7 +2677,7 @@ test "terminal Filter holds every projected foreground off the page" {
for (0..9) |t| {
p.settings.theme = @intCast(t);
- var fc = FilteredColors.init(p, pane);
+ var fc = FilteredColors.init(p, &pane.terminal.?.vt);
var refused: usize = 0;
for (fc.target, 0..) |projected, key| {
const ink = fc.legible(projected);