summaryrefslogtreecommitdiff
path: root/src/Output.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/Output.zig')
-rw-r--r--src/Output.zig90
1 files changed, 73 insertions, 17 deletions
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;