summaryrefslogtreecommitdiff
path: root/src/hunks.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/hunks.zig')
-rw-r--r--src/hunks.zig350
1 files changed, 289 insertions, 61 deletions
diff --git a/src/hunks.zig b/src/hunks.zig
index 8f4b4233..afd2ac9d 100644
--- a/src/hunks.zig
+++ b/src/hunks.zig
@@ -6,21 +6,48 @@
//! 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 = @import("pardes.zig");
const Pardes = pardes.Pardes;
+const Pane = pardes.Pane;
+const Output = pardes.panes.Output;
+
const Row = locations.Row;
+/// What `format` takes of the editor it stacks for: its allocators, the
+/// files a diff names read as the editor reads them (in pardes an open
+/// pane's text, else the disk's, each read a site of the step's tape:
+/// openDiff), their declarations, and one setting.
+pub const Ctx = struct {
+ /// The text and rows made, the caller's.
+ gpa: std.mem.Allocator,
+ /// All else, the call's.
+ arena: std.mem.Allocator,
+ /// `path` as a look from `dir` finds it, its text the arena's (or the
+ /// editor's, good for the call); null when it is not there.
+ source: *const fn (ctx: *const Ctx, dir: []const u8, path: []const u8) ?Source,
+ /// The declarations of `bytes`, the file at `path`, outermost first
+ /// (syntax.analyzeSource's), the arena's.
+ declarations: *const fn (ctx: *const Ctx, path: []const u8, bytes: []const u8) error{OutOfMemory}![]const syntax.ContextDeclaration,
+ /// The two above's own.
+ host: *anyopaque,
+ /// A declaration above a hunk gets its `path:line` row too
+ /// (LocationsConfig's tslocations).
+ tslocations: bool,
+};
+
+/// A file's text, and its path as `dir` and the path named resolve.
+pub const Source = struct { path: []const u8, bytes: []const u8 };
+
/// 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();
+/// row's metadata (Output.fillRows). Text and rows are `ctx.gpa`'s.
+pub fn format(ctx: *const Ctx, dir: []const u8, content: []const u8) !locations.Result {
+ const arena = ctx.arena;
const styles = try syntax.highlightDiff(arena, content, 0, content.len);
- var out: Out = .{ .p = p, .text = .init(p.gpa) };
+ var out: Out = .{ .gpa = ctx.gpa, .text = .init(ctx.gpa) };
errdefer out.deinit();
var walk: diff.Walk = .{};
var hunk: Hunk = .{};
@@ -46,7 +73,7 @@ pub fn format(p: *Pardes, dir: []const u8, content: []const u8) !locations.Resul
// A `\ No newline` belongs to the line above, as delta shows it.
.no_newline => {},
else => {
- try flush(&out, &hunk, &source, dir);
+ try flush(ctx, &out, &hunk, &source, dir);
switch (got.kind) {
.hunk => hunk = .{
.path = walk.path(),
@@ -69,9 +96,9 @@ pub fn format(p: *Pardes, dir: []const u8, content: []const u8) !locations.Resul
}
at = nl + 1;
}
- try flush(&out, &hunk, &source, dir);
- const rows = try out.rows.toOwnedSlice(p.gpa);
- errdefer locations.freeRows(p.gpa, rows);
+ try flush(ctx, &out, &hunk, &source, dir);
+ const rows = try out.rows.toOwnedSlice(ctx.gpa);
+ errdefer locations.freeRows(ctx.gpa, rows);
return .{ .content = try out.text.toOwnedSlice(), .rows = rows, .anchor = null };
}
@@ -105,13 +132,13 @@ fn gitContext(line: []const u8) []const u8 {
}
const Out = struct {
- p: *Pardes,
+ gpa: std.mem.Allocator,
text: std.Io.Writer.Allocating,
rows: std.ArrayList(Row) = .empty,
fn deinit(out: *Out) void {
out.text.deinit();
- locations.freeRowList(out.p.gpa, &out.rows);
+ locations.freeRowList(out.gpa, &out.rows);
}
const Meta = struct {
@@ -127,7 +154,7 @@ const Out = struct {
fn row(out: *Out, text: []const u8, path: []const u8, meta: Meta) !void {
try out.text.writer.writeAll(text);
try out.text.writer.writeByte('\n');
- try locations.appendRow(out.p.gpa, &out.rows, .{
+ try locations.appendRow(out.gpa, &out.rows, .{
.kind = meta.kind,
.declaration = meta.declaration,
.path = @constCast(path),
@@ -153,7 +180,7 @@ const SourceMemo = struct {
/// 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 {
+pub fn sourceRoot(ctx: *const Ctx, 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| {
@@ -161,31 +188,27 @@ pub fn sourceRoot(p: *Pardes, dir: []const u8, content: []const u8) []const u8 {
} else return dir;
var base: []const u8 = dir;
for (0..8) |_| {
- if (locations.sourceText(p, p.scratch.allocator(), base, path) != null) return base;
+ if (ctx.source(ctx, base, path) != null) return base;
base = std.Io.Dir.path.dirname(base) orelse return dir;
}
return dir;
}
-fn findSource(p: *Pardes, memo: *SourceMemo, dir: []const u8, path: []const u8) !void {
+fn findSource(ctx: *const Ctx, memo: *SourceMemo, dir: []const u8, path: []const u8) !void {
if (std.mem.eql(u8, memo.path, path)) return;
- const arena = p.scratch.allocator();
+ const arena = ctx.arena;
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| {
+ if (ctx.source(ctx, base, path)) |text| {
memo.shown = if (base.ptr == dir.ptr) path else try std.Io.Dir.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);
+ memo.declarations = try ctx.declarations(ctx, text.path, text.bytes);
return;
}
base = std.Io.Dir.path.dirname(base) orelse return;
@@ -251,12 +274,11 @@ fn heldAt(memo: *const SourceMemo, hunk: *const Hunk, comptime side: Side, start
return .{ .held = held, .of = @max(of, 1) };
}
-fn flush(out: *Out, hunk: *Hunk, memo: *SourceMemo, dir: []const u8) !void {
+fn flush(ctx: *const Ctx, 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 arena = ctx.arena;
+ try findSource(ctx, 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.
@@ -287,7 +309,7 @@ fn flush(out: *Out, hunk: *Hunk, memo: *SourceMemo, dir: []const u8) !void {
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) {
+ if (row == declaration.start_line and ctx.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 });
}
@@ -331,10 +353,10 @@ fn flush(out: *Out, hunk: *Hunk, memo: *SourceMemo, dir: []const u8) !void {
// 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,
+ .added => syntax.ground_add,
+ .removed => syntax.ground_del,
else => 0,
- } | @as(u8, if (line.kind != .context and !line.paired) syntax.diff_whole else 0);
+ } | @as(u8, if (line.kind != .context and !line.paired) syntax.ground_line else 0);
const text = try std.fmt.allocPrint(arena, "{c}{s}", .{ @as(u8, switch (line.kind) {
.added => '+',
.removed => '-',
@@ -389,10 +411,10 @@ fn inferEdits(arena: std.mem.Allocator, minus: []HunkLine, plus: []HunkLine) !vo
const marks = annotate(pair, &alignment, m.code, plus[j].code) catch continue;
if (marks.distance > max_line_distance) continue;
for (marks.minus) |r| for (m.styles[r[0]..r[1]]) |*b| {
- b.* |= syntax.diff_emph;
+ b.* |= syntax.ground_emph;
};
for (marks.plus) |r| for (plus[j].styles[r[0]..r[1]]) |*b| {
- b.* |= syntax.diff_emph;
+ b.* |= syntax.ground_emph;
};
m.paired = true;
plus[j].paired = true;
@@ -574,16 +596,208 @@ fn annotate(arena: std.mem.Allocator, a: *const Alignment, minus_line: []const u
}
fn trimmedWidth(section: []const u8) usize {
- return pardes.panes.File.displayWidth(std.mem.trim(u8, section, " \t"));
+ return @import("File.zig").displayWidth(std.mem.trim(u8, section, " \t"));
+}
+
+// ---- the +Diff in the editor ----
+//
+// Its word (Diff), the open and the text it goes back to; and the three
+// hooks the generic code calls, one call each (look.zig's bare look and
+// commit look, ninep/ctl.zig's filled +Pager), which a plumber's rules
+// would replace.
+
+/// The `Diff` word (builtins.zig registers it): on a +Diff, the diff it
+/// stacks as text; on a diff, its hunks stacked in a +Diff.
+pub fn word(c: pardes.builtins.Ctx) void {
+ const f = &c.pane.file.?;
+ if (diffSource(c.p, f)) |source| return showDiffText(c.p, c.id, source);
+ _ = openDiff(c.p, c.id, f.path, f.content) catch |err| switch (err) {
+ error.NoHunks => c.p.reportFailure(c.id, "Diff: no hunk in it"),
+ else => c.p.reportError(c.id, "hunks", err),
+ };
+}
+
+/// A pane the word works on: a diff (a .diff, a .patch, a +Pager holding
+/// one) or a +Diff.
+pub fn shows(pane: *const Pane) bool {
+ const f = pane.file orelse return false;
+ return pane.colorAlgo() == .diff or (f.output != null and std.meta.eql(f.output.?.from, Output.Origin{ .cmd = .Diff }));
+}
+
+/// The hook of a bare look at a .diff or a .patch (look.zig's open): its
+/// hunks stacked in a +Diff, which takes the keyboard as the file would;
+/// false, for look to open it as text, when it is no such file, a place in
+/// one, one with no hunk, or the text is what is asked (showDiffText).
+pub fn lookedAt(p: *Pardes, id: usize, path: []const u8, at: pardes.look.Spot) bool {
+ if (p.look_text or at.line != 0 or !(std.mem.endsWith(u8, path, ".diff") or std.mem.endsWith(u8, path, ".patch"))) return false;
+ const bytes = pardes.filesystem.read(p, path) catch return false;
+ defer p.gpa.free(bytes);
+ p.view().active = openDiff(p, id, path, bytes) catch return false;
+ return true;
+}
+
+/// The hook of a +Pager filled with a diff (ninep/ctl.zig's fillPager:
+/// `git show`, difftui's patches): its hunks stacked in a +Diff in the
+/// +Pager's place, the +Pager closed. The keyboard stays where it was, as
+/// a page's.
+pub fn paged(p: *Pardes, id: usize) void {
+ const f = &p.panes[id].?.file.?;
+ const keyboard = p.view().active;
+ if (openDiff(p, id, f.path, f.content)) |hid| {
+ // ponytail: the text is gone with it; Diff on the +Diff says no such file.
+ p.removePane(id, hid) catch |err| p.reportError(id, "pager", err);
+ } else |_| {}
+ if (p.panes[keyboard] != null) p.view().active = keyboard;
+}
+
+/// The hook of a commit hash (7 to 40 hex digits, a letter and a digit
+/// among them; look.zig's look at a word) looked at inside a git repository: `git show` it, paged into a +Pager,
+/// which stacks its hunks in a +Diff (ctl.fillPager); the command pane
+/// goes when it succeeds (Pane.commandDone).
+// ponytail: a hex word that names no commit leaves git's error in a command pane, not a search; check the object first if that bites.
+pub fn lookedAtCommit(p: *Pardes, id: usize, pane: *Pane, hash: []const u8) bool {
+ if (!isCommitHash(hash)) return false;
+ var dir = pardes.filesystem.localPath(Pardes.paneDir(pane)) orelse return false;
+ while (true) {
+ var buf: [4096]u8 = undefined;
+ const dot_git = std.fmt.bufPrint(&buf, "{s}/.git", .{dir}) catch return false;
+ if (pardes.exec.kindOf(dot_git) != null) break;
+ dir = std.Io.Dir.path.dirname(dir) orelse return false;
+ }
+ var line: [64]u8 = undefined;
+ const dst = pardes.exec.execute(p, id, std.fmt.bufPrint(&line, "git show {s}", .{hash}) catch return false) orelse return true;
+ if (p.panes[dst]) |c| c.command_pages = true;
+ return true;
+}
+
+fn isCommitHash(hex: []const u8) bool {
+ if (hex.len < 7 or hex.len > 40) return false;
+ var digit = false;
+ var letter = false;
+ for (hex) |c| switch (c) {
+ '0'...'9' => digit = true,
+ 'a'...'f' => letter = true,
+ else => return false,
+ };
+ return digit and letter;
+}
+
+/// Diff: `content`, the diff at `path` (a file, a +Pager), stacked as a
+/// diff viewer shows it (format), in a +Diff where its files are found
+/// (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; a commit's (`git show`, a
+/// mailed patch) is named for it too, `+Diff-<12 hex>`, so each commit
+/// keeps a +Diff of its own. 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.Io.Dir.path.dirname(path) orelse p.sessionDir();
+ // Each file read is a site of the step's tape (fs.zig): a replica
+ // replays the authority's bytes and reads no disk of its own.
+ const Read = struct {
+ fn source(ctx: *const Ctx, from: []const u8, name: []const u8) ?Source {
+ const pp: *Pardes = @ptrCast(@alignCast(ctx.host));
+ const text = locations.sourceText(pp, ctx.arena, from, name) orelse return null;
+ return .{ .path = text.path, .bytes = text.bytes };
+ }
+ fn declarations(ctx: *const Ctx, name: []const u8, bytes: []const u8) error{OutOfMemory}![]const syntax.ContextDeclaration {
+ const pp: *Pardes = @ptrCast(@alignCast(ctx.host));
+ var hit = pp.locations_cache.get(pp.tree_sitter_gpa, name, bytes, true, false) catch
+ locations.Cache.Hit{ .analysis = syntax.analyzeSource(ctx.arena, name, bytes, true, false) catch .{} };
+ defer hit.deinit(pp.tree_sitter_gpa);
+ // The cache's may go at its next use: kept for the call.
+ return ctx.arena.dupe(syntax.ContextDeclaration, hit.analysis.declarations);
+ }
+ };
+ const ctx: Ctx = .{
+ .gpa = p.gpa,
+ .arena = p.scratch.allocator(),
+ .source = Read.source,
+ .declarations = Read.declarations,
+ .host = p,
+ .tslocations = p.locations_config.tslocations,
+ };
+ const root = sourceRoot(&ctx, dir, content);
+ const result = try format(&ctx, 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 > Output.max_arg) std.Io.Dir.path.basename(path) else path;
+ var name_buf: [pardes.config.diff_buffer.len + 13]u8 = undefined;
+ const name = if (diff.commitHash(content)) |hash|
+ std.fmt.bufPrint(&name_buf, "{s}-{s}", .{ pardes.config.diff_buffer, hash[0..@min(hash.len, 12)] }) catch unreachable
+ else
+ null;
+ return Output.fillRows(p, id, root, .{ .cmd = .Diff }, name, 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.
+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) pardes.layout.toggleCollapse(p, i);
+ p.view().active = i;
+ return;
+ }
+ p.look_text = true;
+ defer p.look_text = false;
+ pardes.look.lookAt(p, id, source);
+}
+
+/// The diff a +Diff stacks (openDiff's arg): its path.
+pub fn diffSource(p: *Pardes, f: *const pardes.panes.File.State) ?[]const u8 {
+ const o = f.output orelse return null;
+ if (!std.meta.eql(o.from, Output.Origin{ .cmd = .Diff })) return null;
+ const arg = o.arg();
+ if (arg.len > 0 and arg[0] == '/') return arg;
+ return std.Io.Dir.path.join(p.scratch.allocator(), &.{ std.Io.Dir.path.dirname(f.path) orelse "", arg }) catch null;
}
// ---- tests ----
const testing = std.testing;
+/// A Ctx over the disk, as the editor's is without panes or a cache.
+const TestCtx = struct {
+ arena_state: std.heap.ArenaAllocator,
+ ctx: Ctx,
+
+ fn init(t: *TestCtx) void {
+ t.arena_state = .init(testing.allocator);
+ t.ctx = .{ .gpa = testing.allocator, .arena = t.arena_state.allocator(), .source = source, .declarations = declarations, .host = t, .tslocations = true };
+ syntax.start(testing.allocator);
+ }
+
+ fn deinit(t: *TestCtx) void {
+ syntax.stop();
+ t.arena_state.deinit();
+ }
+
+ fn source(ctx: *const Ctx, dir: []const u8, path: []const u8) ?Source {
+ const full = std.Io.Dir.path.resolvePosix(ctx.arena, &.{ dir, path }) catch return null;
+ const bytes = std.Io.Dir.cwd().readFileAlloc(testing.io, full, ctx.arena, .limited(1 << 20)) catch return null;
+ return .{ .path = full, .bytes = bytes };
+ }
+
+ fn declarations(ctx: *const Ctx, path: []const u8, bytes: []const u8) error{OutOfMemory}![]const syntax.ContextDeclaration {
+ return (syntax.analyzeSource(ctx.arena, path, bytes, true, false) catch return &.{}).declarations;
+ }
+};
+
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 '.');
+ for (line.code, line.styles) |c, s| try out.append(testing.allocator, if (s & syntax.ground_emph != 0) c else '.');
return out.toOwnedSlice(testing.allocator);
}
@@ -631,8 +845,9 @@ test "delta's alignment: kitten to sitting, as align.rs has it" {
}
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();
+ var t: TestCtx = undefined;
+ t.init();
+ defer t.deinit();
const patch =
\\diff --git a/nowhere/x.txt b/nowhere/x.txt
\\--- a/nowhere/x.txt
@@ -644,28 +859,29 @@ test "a diff stacks to a label a hunk and its lines, markers gone, tinted and st
\\ tail
\\
;
- const result = try format(p, "/pardes-surely-missing-dir", patch);
- defer p.gpa.free(result.content);
- defer locations.freeRows(p.gpa, result.rows);
+ const result = try format(&t.ctx, "/pardes-surely-missing-dir", patch);
+ defer testing.allocator.free(result.content);
+ defer locations.freeRows(testing.allocator, 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);
+ try testing.expect(removed.colors[0] & syntax.ground_del != 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);
+ try testing.expect(removed.colors[0] & syntax.ground_line == 0);
+ try testing.expect(removed.colors[1] & syntax.ground_emph != 0);
+ try testing.expect(removed.colors[5] & syntax.ground_emph == 0);
+ try testing.expect(result.rows[4].colors[0] & syntax.ground_add != 0);
+ try testing.expect(result.rows[2].colors[0] & (syntax.ground_add | syntax.ground_del) == 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 t: TestCtx = undefined;
+ t.init();
+ defer t.deinit();
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
// Two lines more above it than the patch knows of.
@@ -682,16 +898,17 @@ test "a hunk the file has moved since is found where it went, inside its declara
\\ b();
\\
;
- const result = try format(p, dir, patch);
- defer p.gpa.free(result.content);
- defer locations.freeRows(p.gpa, result.rows);
+ const result = try format(&t.ctx, dir, patch);
+ defer testing.allocator.free(result.content);
+ defer locations.freeRows(testing.allocator, 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();
+ var t: TestCtx = undefined;
+ t.init();
+ defer t.deinit();
const patch =
\\From 0123 Mon Sep 17 00:00:00 2001
\\Subject: [PATCH] change x
@@ -709,9 +926,9 @@ test "a mailed patch keeps its headers, message and diffstat above its hunks" {
\\+b
\\
;
- const result = try format(p, "/pardes-surely-missing-dir", patch);
- defer p.gpa.free(result.content);
- defer locations.freeRows(p.gpa, result.rows);
+ const result = try format(&t.ctx, "/pardes-surely-missing-dir", patch);
+ defer testing.allocator.free(result.content);
+ defer locations.freeRows(testing.allocator, 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);
}
@@ -755,8 +972,9 @@ test "a .patch looked at opens its +Diff, and Diff goes to the text and back" {
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 t: TestCtx = undefined;
+ t.init();
+ defer t.deinit();
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
// Three functions ending in one signature's tail; the patch is for the
@@ -799,9 +1017,9 @@ test "a hunk edited since, beside siblings with its signature's tail, is found i
\\ c
\\
;
- const result = try format(p, dir, patch);
- defer p.gpa.free(result.content);
- defer locations.freeRows(p.gpa, result.rows);
+ const result = try format(&t.ctx, dir, patch);
+ defer testing.allocator.free(result.content);
+ defer locations.freeRows(testing.allocator, result.rows);
try testing.expect(std.mem.indexOf(u8, result.content, "a.rs:12\n fn three(\na.rs:15 *\n") != null);
}
@@ -837,3 +1055,13 @@ test "patch panes keep different commits and reuse only the same commit" {
try testing.expectEqual(first, try Page.open(p, a));
try testing.expectEqualStrings(original, p.panes[first].?.file.?.content);
}
+
+test "a commit hash is 7 to 40 lowercase hex digits with a letter and a digit" {
+ try std.testing.expect(isCommitHash("9bffa7041c"));
+ try std.testing.expect(isCommitHash("9bffa7041cd2e8a0b6b1f7c3e4d5a6b7c8d9e0f1"));
+ try std.testing.expect(!isCommitHash("9bffa7"));
+ try std.testing.expect(!isCommitHash("defaced"));
+ try std.testing.expect(!isCommitHash("1234567"));
+ try std.testing.expect(!isCommitHash("0x9bffa7041c"));
+ try std.testing.expect(!isCommitHash("9BFFA7041C"));
+}