summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 07:44:55 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commit0db7861d9da09e059fa1b9e40fff5cd52add27f2 (patch)
tree6e95dfa36e07b3234b1d5cdb990b11f95c184a3f /test
parentd3742ddf2b3a85eb3935cb35e958fa27f1293a6b (diff)
parentdee94c740bdaea61ff35b4e0a7f1d2815c9ee441 (diff)
downloadpardes-0db7861d9da09e059fa1b9e40fff5cd52add27f2.tar.gz
pardes-0db7861d9da09e059fa1b9e40fff5cd52add27f2.zip
integration: the text pane a library (pardes-editor), with the GPU move, the terminal, the plumber and the diff work
A merge of pardes-next (wmrtztwl) and editor-lib (rlumrxuq), no conflicts. Gated against the baseline of the integration line (.scratch/sketch/gpu/mbase): the merge with the library before its follow-up, in full: frame corpus 77/77 identical in Debug and in ReleaseFast, the gated window -0.019% instructions (threshold 0.5%), unit-test on gui 1584/1592 with no failure the baseline has not; this merge: corpus 77/77 in Debug, unit-test on gui 1584/1592, on tui core-test 811/950 (139 skipped), shell-test 990/993, lib-test, hxdiff 658, parity 738, hxgolf 124, hxlib 538 and its parity 618, all 0 mismatches, replicas pass. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'test')
-rw-r--r--test/hxdiff.zig111
-rw-r--r--test/hxkeys.zig80
-rw-r--r--test/hxlib.zig136
-rw-r--r--test/lib/bench.zig80
-rw-r--r--test/lib/build.zig28
-rw-r--r--test/lib/editor.zig216
-rw-r--r--test/panes.zig2
-rw-r--r--test/perf.zig2
8 files changed, 571 insertions, 84 deletions
diff --git a/test/hxdiff.zig b/test/hxdiff.zig
index 010cc674..f18f498b 100644
--- a/test/hxdiff.zig
+++ b/test/hxdiff.zig
@@ -3,6 +3,7 @@
// --strict checks complete corpus coverage. Waivers pin both sides of a known difference.
const std = @import("std");
const pardes = @import("pardes");
+const hxkeys = @import("hxkeys.zig");
// Its own root, so src/main.zig's logFn does not apply here: the core it
// drives feeds every case's text through ghostty-vt, which narrates each
@@ -36,6 +37,9 @@ pub fn main(init: std.process.Init) !void {
var verbose = false;
var strict = false;
var pane_override: ?[]const u8 = null;
+ // Another driver's results, a line a case (test/hxlib.zig, the
+ // library's): held against the goldens, or with --parity the file pane.
+ var actual_path: ?[]const u8 = null;
var goldens_path: ?[]const u8 = null;
var waivers_path: ?[]const u8 = null;
const paths = try arena.alloc([]const u8, @max(args.len - 1, 3)); // room for the defaults below
@@ -56,6 +60,8 @@ pub fn main(init: std.process.Init) !void {
const kind = a["--pane=".len..];
if (!std.mem.eql(u8, kind, "file") and !std.mem.eql(u8, kind, "tty")) return error.UnknownPane;
pane_override = kind;
+ } else if (std.mem.startsWith(u8, a, "--actual=")) {
+ actual_path = a["--actual=".len..];
} else if (std.mem.eql(u8, a, "--waivers")) {
if (waivers_path != null) return error.DuplicateWaiverPath;
want_waivers = true;
@@ -74,7 +80,8 @@ pub fn main(init: std.process.Init) !void {
&.{ "test/hxcases/cases.jsonl", "test/hxcases/parity.jsonl" }
else
&.{ "test/hxcases/cases.jsonl", "test/hxcases/goldens.jsonl", "test/hxcases/waivers.jsonl" };
- if (parity) waivers_path = waivers_path orelse "test/hxcases/parity-waivers.jsonl";
+ // the pty pane's differences from the file pane; the library has none
+ if (parity and actual_path == null) waivers_path = waivers_path orelse "test/hxcases/parity-waivers.jsonl";
@memcpy(paths[0..defaults.len], defaults);
n_paths = defaults.len;
}
@@ -135,6 +142,17 @@ pub fn main(init: std.process.Init) !void {
var n_cases: usize = 0;
var n_bad: usize = 0;
var n_waived: usize = 0;
+ var n_skipped: usize = 0;
+ var actuals: std.StringHashMap([]const u8) = .init(arena);
+ if (actual_path) |ap| {
+ const asrc = std.Io.Dir.cwd().readFileAlloc(init.io, ap, arena, .limited(256 * 1024 * 1024)) catch |e| fatal("read {s}: {s}", .{ ap, @errorName(e) });
+ var alines = std.mem.splitScalar(u8, asrc, '\n');
+ while (alines.next()) |line| {
+ if (line.len == 0) continue;
+ const named = std.json.parseFromSliceLeaky(struct { name: []const u8 }, arena, line, .{ .ignore_unknown_fields = true }) catch |e| fatal("{s}: bad result line: {s}", .{ ap, @errorName(e) });
+ try actuals.put(named.name, line);
+ }
+ }
var names: std.StringHashMap(void) = .init(arena);
for (case_paths) |path| {
const src = std.Io.Dir.cwd().readFileAlloc(init.io, path, arena, .limited(64 * 1024 * 1024)) catch |e| fatal("read {s}: {s}", .{ path, @errorName(e) });
@@ -155,7 +173,17 @@ pub fn main(init: std.process.Init) !void {
goldens.get(case.name) orelse fatal("no golden for case {s}", .{case.name})
else
null;
- const actual = try runCase(arena, case, if (parity) "tty" else pane_override orelse case.pane);
+ const actual = if (actual_path) |ap| other: {
+ const result = actuals.get(case.name) orelse fatal("{s}: no result for case {s}", .{ ap, case.name });
+ // a case the driver stopped in: where the app's part began
+ const skip = std.json.parseFromSliceLeaky(struct { skip: ?[]const u8 = null }, arena, result, .{ .ignore_unknown_fields = true }) catch fatal("{s}: bad result for {s}", .{ ap, case.name });
+ if (skip.skip) |why| {
+ n_skipped += 1;
+ if (verbose) std.debug.print("SKIPPED {s}: {s}\n", .{ case.name, why });
+ continue;
+ }
+ break :other std.json.parseFromSliceLeaky(Result, arena, result, .{}) catch fatal("{s}: bad result for {s}", .{ ap, case.name });
+ } else try runCase(arena, case, if (parity) "tty" else pane_override orelse case.pane);
try validateResult(actual);
const want = reference orelse {
const row = try std.json.Stringify.valueAlloc(arena, actual, .{ .emit_null_optional_fields = false });
@@ -165,7 +193,7 @@ pub fn main(init: std.process.Init) !void {
};
try validateResult(want);
const reference_name = if (parity) "file" else "helix";
- const actual_name = if (parity) "pty" else "pardes";
+ const actual_name = if (actual_path != null) "lib" else if (parity) "pty" else "pardes";
const difference = try diffResult(arena, want, actual, reference_name, actual_name);
if (difference.len == 0) {
if (strict and waivers.contains(case.name)) fatal("stale waiver: {s}", .{case.name});
@@ -194,7 +222,8 @@ pub fn main(init: std.process.Init) !void {
}
}
if (!parity and goldens_path == null) return;
- std.debug.print("{s}: {d} cases, {d} mismatches, {d} waived\n", .{ if (parity) "hxparity" else "hxdiff", n_cases, n_bad, n_waived });
+ std.debug.print("{s}{s}: {d} cases, {d} mismatches, {d} waived\n", .{ if (parity) "hxparity" else "hxdiff", if (actual_path != null) "-lib" else "", n_cases - n_skipped, n_bad, n_waived });
+ if (actual_path != null) std.debug.print("{d} cases the library hands its caller (an action not the text's), not compared\n", .{n_skipped});
if (n_bad > 0) std.process.exit(1);
}
@@ -347,77 +376,7 @@ fn runCase(arena: std.mem.Allocator, case: Case, pane_kind: []const u8) !Result
// keys: helix notation — printables verbatim, <...> specials
var ki: usize = 0;
- while (ki < case.keys.len) {
- var key: pardes.Key = .{ .cp = 0 };
- if (case.keys[ki] == '<') {
- const close = std.mem.indexOfScalarPos(u8, case.keys, ki, '>') orelse
- fatal("case {s}: unterminated < in keys", .{case.name});
- var name = case.keys[ki + 1 .. close];
- ki = close + 1;
- while (true) {
- if (std.mem.startsWith(u8, name, "C-")) {
- key.ctrl = true;
- name = name[2..];
- } else if (std.mem.startsWith(u8, name, "A-")) {
- key.alt = true;
- name = name[2..];
- } else if (std.mem.startsWith(u8, name, "S-")) {
- key.shift = true;
- name = name[2..];
- } else break;
- }
- if (name.len == 1 or (name.len > 1 and name.len <= 4 and name[0] >= 0x80)) {
- key.cp = std.unicode.utf8Decode(name) catch return error.InvalidKey;
- if (!key.ctrl and !key.alt) key.text = name;
- } else if (std.mem.eql(u8, name, "esc")) {
- key.cp = pardes.Key.escape;
- } else if (std.mem.eql(u8, name, "ret")) {
- key.cp = pardes.Key.enter;
- } else if (std.mem.eql(u8, name, "tab")) {
- key.cp = pardes.Key.tab;
- } else if (std.mem.eql(u8, name, "space")) {
- key.cp = ' ';
- if (!key.ctrl and !key.alt) key.text = " ";
- } else if (std.mem.eql(u8, name, "backspace")) {
- key.cp = pardes.Key.backspace;
- } else if (std.mem.eql(u8, name, "del")) {
- key.cp = pardes.Key.delete;
- } else if (std.mem.eql(u8, name, "lt")) {
- key.cp = '<';
- if (!key.ctrl and !key.alt) key.text = "<";
- } else if (std.mem.eql(u8, name, "gt")) {
- key.cp = '>';
- if (!key.ctrl and !key.alt) key.text = ">";
- } else if (std.mem.eql(u8, name, "minus")) {
- // helix spells Alt-'-' this way: a bare `-` after a modifier
- // is a parse error in its own macro notation
- key.cp = '-';
- if (!key.ctrl and !key.alt) key.text = "-";
- } else if (std.mem.eql(u8, name, "up")) {
- key.cp = pardes.Key.up;
- } else if (std.mem.eql(u8, name, "down")) {
- key.cp = pardes.Key.down;
- } else if (std.mem.eql(u8, name, "left")) {
- key.cp = pardes.Key.left;
- } else if (std.mem.eql(u8, name, "right")) {
- key.cp = pardes.Key.right;
- } else if (std.mem.eql(u8, name, "home")) {
- key.cp = pardes.Key.home;
- } else if (std.mem.eql(u8, name, "end")) {
- key.cp = pardes.Key.end;
- } else if (std.mem.eql(u8, name, "pageup")) {
- key.cp = pardes.Key.page_up;
- } else if (std.mem.eql(u8, name, "pagedown")) {
- key.cp = pardes.Key.page_down;
- } else fatal("case {s}: unknown key <{s}>", .{ case.name, name });
- } else {
- const len = std.unicode.utf8ByteSequenceLength(case.keys[ki]) catch return error.InvalidKey;
- if (len > case.keys.len - ki) return error.InvalidKey;
- const text = case.keys[ki..][0..len];
- key.cp = std.unicode.utf8Decode(text) catch return error.InvalidKey;
- key.text = text;
- ki += len;
- }
+ while (hxkeys.next(pardes.Key, case.keys, &ki) catch |err| fatal("case {s}: {s}", .{ case.name, @errorName(err) })) |key| {
core.update(.{ .key = key });
pump(core);
}
@@ -433,7 +392,7 @@ fn runCase(arena: std.mem.Allocator, case: Case, pane_kind: []const u8) !Result
// the cursor's empty row below the output (see Pardes.shellRows), so
// its line list is exactly a file content's — join it and you have the
// same bytes, trailing newline included, with nothing to patch up.
- const lines = try pardes.edit.paneCursorLines(core, &pane.body);
+ const lines = try pardes.edit.paneCursorLines(core.editor(), &pane.body);
var text_len: usize = if (lines.len == 0) 0 else lines.len - 1;
for (lines) |ln| text_len = std.math.add(usize, text_len, ln.len) catch return error.OutOfMemory;
const joined = try arena.alloc(u8, text_len);
diff --git a/test/hxkeys.zig b/test/hxkeys.zig
new file mode 100644
index 00000000..c94e5900
--- /dev/null
+++ b/test/hxkeys.zig
@@ -0,0 +1,80 @@
+//! helix's key notation as hxdiff's cases spell it (test/hxcases): the
+//! next key of `keys` from `i.*`, null at the end; printables verbatim,
+//! `<...>` specials and modifiers. The core's harness (hxdiff.zig) and the
+//! library's (hxlib.zig) read the cases through it.
+const std = @import("std");
+
+pub fn next(comptime Key: type, keys: []const u8, i: *usize) !?Key {
+ if (i.* >= keys.len) return null;
+ var key: Key = .{ .cp = 0 };
+ if (keys[i.*] == '<') {
+ const close = std.mem.indexOfScalarPos(u8, keys, i.*, '>') orelse
+ return error.UnterminatedKey;
+ var name = keys[i.* + 1 .. close];
+ i.* = close + 1;
+ while (true) {
+ if (std.mem.startsWith(u8, name, "C-")) {
+ key.ctrl = true;
+ name = name[2..];
+ } else if (std.mem.startsWith(u8, name, "A-")) {
+ key.alt = true;
+ name = name[2..];
+ } else if (std.mem.startsWith(u8, name, "S-")) {
+ key.shift = true;
+ name = name[2..];
+ } else break;
+ }
+ if (name.len == 1 or (name.len > 1 and name.len <= 4 and name[0] >= 0x80)) {
+ key.cp = std.unicode.utf8Decode(name) catch return error.InvalidKey;
+ if (!key.ctrl and !key.alt) key.text = name;
+ } else if (std.mem.eql(u8, name, "esc")) {
+ key.cp = Key.escape;
+ } else if (std.mem.eql(u8, name, "ret")) {
+ key.cp = Key.enter;
+ } else if (std.mem.eql(u8, name, "tab")) {
+ key.cp = Key.tab;
+ } else if (std.mem.eql(u8, name, "space")) {
+ key.cp = ' ';
+ if (!key.ctrl and !key.alt) key.text = " ";
+ } else if (std.mem.eql(u8, name, "backspace")) {
+ key.cp = Key.backspace;
+ } else if (std.mem.eql(u8, name, "del")) {
+ key.cp = Key.delete;
+ } else if (std.mem.eql(u8, name, "lt")) {
+ key.cp = '<';
+ if (!key.ctrl and !key.alt) key.text = "<";
+ } else if (std.mem.eql(u8, name, "gt")) {
+ key.cp = '>';
+ if (!key.ctrl and !key.alt) key.text = ">";
+ } else if (std.mem.eql(u8, name, "minus")) {
+ // helix spells Alt-'-' this way: a bare `-` after a modifier
+ // is a parse error in its own macro notation
+ key.cp = '-';
+ if (!key.ctrl and !key.alt) key.text = "-";
+ } else if (std.mem.eql(u8, name, "up")) {
+ key.cp = Key.up;
+ } else if (std.mem.eql(u8, name, "down")) {
+ key.cp = Key.down;
+ } else if (std.mem.eql(u8, name, "left")) {
+ key.cp = Key.left;
+ } else if (std.mem.eql(u8, name, "right")) {
+ key.cp = Key.right;
+ } else if (std.mem.eql(u8, name, "home")) {
+ key.cp = Key.home;
+ } else if (std.mem.eql(u8, name, "end")) {
+ key.cp = Key.end;
+ } else if (std.mem.eql(u8, name, "pageup")) {
+ key.cp = Key.page_up;
+ } else if (std.mem.eql(u8, name, "pagedown")) {
+ key.cp = Key.page_down;
+ } else return error.UnknownKey;
+ } else {
+ const len = std.unicode.utf8ByteSequenceLength(keys[i.*]) catch return error.InvalidKey;
+ if (len > keys.len - i.*) return error.InvalidKey;
+ const text = keys[i.*..][0..len];
+ key.cp = std.unicode.utf8Decode(text) catch return error.InvalidKey;
+ key.text = text;
+ i.* += len;
+ }
+ return key;
+}
diff --git a/test/hxlib.zig b/test/hxlib.zig
new file mode 100644
index 00000000..b6c1bfd3
--- /dev/null
+++ b/test/hxlib.zig
@@ -0,0 +1,136 @@
+//! hxdiff's cases on the library (`pardes-editor`, src/lib_editor.zig):
+//! each case's keys typed into an editor value, its result printed as
+//! hxdiff prints a pane's, one line a case, for `hxdiff --actual` to hold
+//! against helix's goldens or the file pane (`zig build hxlib`). The
+//! library does what an app would with the actions it hands back that a
+//! case needs: s, S, K and Alt-K take the keys up to <ret> as their
+//! pattern, and the tree-sitter walks run on the app's parse (a case's text
+//! has no grammar). A case that reaches any other action (a view, `:`,
+//! `/`, LSP, a macro) is the app's from there: printed as skipped, with the
+//! role.
+const std = @import("std");
+const pe = @import("pardes-editor");
+const hxkeys = @import("hxkeys.zig");
+
+pub const std_options: std.Options = .{ .log_level = .err, .logFn = logFn };
+
+fn logFn(comptime level: std.log.Level, comptime scope: @EnumLiteral(), comptime format: []const u8, args: anytype) void {
+ if (scope == .mvzr) return; // a pattern typed a key at a time, as hxdiff.zig says
+ std.log.defaultLog(level, scope, format, args);
+}
+
+const Ed = pe.Editor(.{ .text = 1 << 20, .undo = 4 << 20, .registers = 64 << 10, .selections = 1024 });
+
+const Case = struct { name: []const u8, pane: []const u8 = "file", path: ?[]const u8 = null, text: []const u8, keys: []const u8 };
+const Pos = struct { row: i32, col: i32 };
+const Sel = struct { cursor: Pos, anchor: Pos };
+const Result = struct {
+ name: []const u8,
+ text: []const u8,
+ mode: []const u8,
+ cursor: Pos,
+ anchor: Pos,
+ sels: ?[]const Sel = null,
+ primary: ?usize = null,
+};
+const Skip = struct { name: []const u8, skip: []const u8 };
+
+pub fn main(init: std.process.Init) !void {
+ const gpa = std.heap.page_allocator;
+ const args = try init.minimal.args.toSlice(init.arena.allocator());
+ const ed = try gpa.create(Ed);
+ const stdout = std.Io.File.stdout();
+ for (args[1..]) |path| {
+ var file_arena = std.heap.ArenaAllocator.init(gpa);
+ defer file_arena.deinit();
+ const src = try std.Io.Dir.cwd().readFileAlloc(init.io, path, file_arena.allocator(), .limited(64 << 20));
+ var lines = std.mem.splitScalar(u8, src, '\n');
+ while (lines.next()) |raw| {
+ const line = std.mem.trim(u8, raw, " \t\r");
+ if (line.len == 0) continue;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const case = try std.json.parseFromSliceLeaky(Case, a, line, .{ .ignore_unknown_fields = true });
+ const out = try runCase(a, ed, case);
+ try stdout.writeStreamingAll(init.io, out);
+ try stdout.writeStreamingAll(init.io, "\n");
+ }
+ }
+}
+
+fn runCase(a: std.mem.Allocator, ed: *Ed, case: Case) ![]u8 {
+ ed.* = .{};
+ try ed.load(case.text);
+ // the app's parse: a case's text has no grammar (no path), so the
+ // tree-sitter walks run and leave the ranges, as a file pane's do
+ var syn: pe.Syntax = .{};
+ var i: usize = 0;
+ while (try hxkeys.next(pe.Key, case.keys, &i)) |k| {
+ // a page key in insert mode moves a view, which the library has not
+ if (ed.mode() == .insert and (k.cp == pe.Key.page_up or k.cp == pe.Key.page_down))
+ return std.json.Stringify.valueAlloc(a, Skip{ .name = case.name, .skip = "insert page key" }, .{});
+ var call = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+ defer call.deinit();
+ switch (ed.key(call.allocator(), &syn, k)) {
+ .done, .pending, .unbound => {},
+ .refused => |why| return std.json.Stringify.valueAlloc(a, Skip{ .name = case.name, .skip = @tagName(why) }, .{}),
+ .action => |act| switch (act.role) {
+ inline .select_regex, .split_regex, .keep_regex, .remove_regex => |role| {
+ // the app's prompt: the keys to <ret> are the pattern
+ var pattern: std.ArrayList(u8) = .empty;
+ const answered = while (try hxkeys.next(pe.Key, case.keys, &i)) |p| {
+ if (p.cp == pe.Key.enter) break true;
+ if (p.cp == pe.Key.escape) break false;
+ if (p.cp == pe.Key.backspace) {
+ if (pattern.items.len > 0) pattern.items.len -= 1;
+ continue;
+ }
+ try pattern.appendSlice(a, p.text);
+ } else false;
+ if (!answered) continue;
+ const how = @field(pe.RegexMode, @tagName(role)[0 .. @tagName(role).len - "_regex".len]);
+ _ = ed.selectRegex(call.allocator(), pattern.items, how);
+ },
+ else => return std.json.Stringify.valueAlloc(a, Skip{ .name = case.name, .skip = @tagName(act.role) }, .{}),
+ },
+ }
+ }
+ const c = ed.cursor;
+ const anchor: Pos = if (c.vsel.active) .{ .row = c.vsel.row, .col = c.vsel.col } else .{ .row = c.cur_row, .col = c.cur_col };
+ // as hxdiff.zig's: the primary slotted among the others in document order
+ var sels: ?[]const Sel = null;
+ var primary: ?usize = null;
+ if (c.nsel > 0) {
+ const out = try a.alloc(Sel, @as(usize, c.nsel) + 1);
+ var n: usize = 0;
+ const prim: Sel = .{ .cursor = .{ .row = c.cur_row, .col = c.cur_col }, .anchor = anchor };
+ const pr_row = @min(prim.cursor.row, prim.anchor.row);
+ const pr_col = if (prim.cursor.row == prim.anchor.row) @min(prim.cursor.col, prim.anchor.col) else if (prim.cursor.row < prim.anchor.row) prim.cursor.col else prim.anchor.col;
+ for (ed.sels[0..c.nsel]) |s| {
+ const s_row = @min(s.row, s.arow);
+ const s_col = if (s.row == s.arow) @min(s.col, s.acol) else if (s.row < s.arow) s.col else s.acol;
+ if (primary == null and (pr_row < s_row or (pr_row == s_row and pr_col <= s_col))) {
+ primary = n;
+ out[n] = prim;
+ n += 1;
+ }
+ out[n] = .{ .cursor = .{ .row = s.row, .col = s.col }, .anchor = .{ .row = s.arow, .col = s.acol } };
+ n += 1;
+ }
+ if (primary == null) {
+ primary = n;
+ out[n] = prim;
+ }
+ sels = out;
+ }
+ return std.json.Stringify.valueAlloc(a, Result{
+ .name = case.name,
+ .text = try ed.bytes(a),
+ .mode = if (c.mode == .normal and c.select) "select" else @tagName(c.mode),
+ .cursor = .{ .row = c.cur_row, .col = c.cur_col },
+ .anchor = anchor,
+ .sels = sels,
+ .primary = primary,
+ }, .{ .emit_null_optional_fields = false });
+}
diff --git a/test/lib/bench.zig b/test/lib/bench.zig
new file mode 100644
index 00000000..7e945064
--- /dev/null
+++ b/test/lib/bench.zig
@@ -0,0 +1,80 @@
+//! What a key costs on the library (`zig build bench -- <KiB> <keys>`, Debug
+//! or -Doptimize): a text of that size in the C grammar's shape, a key
+//! typed into its middle `keys` times, each with an arena of its own; the
+//! 4 KiB pages of the value a typed character changes; a full parse of the
+//! text. `keys` 0 makes the text alone, to count what the keys add; a
+//! third argument, `pages`, counts the pages (a copy and a compare a key,
+//! which an instruction count of the keys leaves out).
+const std = @import("std");
+const pe = @import("pardes-editor");
+
+const Ed = pe.Editor(.{ .text = 128 * 1024, .undo = 512 * 1024 });
+
+extern fn tree_sitter_c() *const pe.syntax.ts.Language;
+
+fn now() u64 {
+ var ts: std.c.timespec = undefined;
+ _ = std.c.clock_gettime(.MONOTONIC, &ts);
+ return @as(u64, @intCast(ts.sec)) * std.time.ns_per_s + @as(u64, @intCast(ts.nsec));
+}
+
+pub fn main(init: std.process.Init) !void {
+ const gpa = std.heap.page_allocator;
+ const args = try init.minimal.args.toSlice(init.arena.allocator());
+ const kib = try std.fmt.parseInt(usize, args[1], 10);
+ const keys = try std.fmt.parseInt(usize, args[2], 10);
+ const count_pages = args.len > 3;
+ var text: std.ArrayList(u8) = .empty;
+ var i: usize = 0;
+ while (text.items.len < kib * 1024) : (i += 1) try text.print(gpa, "int f{d}(int x) {{ return x + {d}; }}\n", .{ i, i });
+ text.items.len = kib * 1024;
+ const ed = try gpa.create(Ed);
+ ed.* = .{};
+ try ed.load(text.items);
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ // to the middle, into insert mode
+ for ([_]pe.Key{ .{ .cp = '%', .text = "%" }, .{ .cp = ';', .text = ";" } }) |k| _ = ed.key(arena.allocator(), null, k);
+ var to_middle: [8]u8 = undefined;
+ for (std.fmt.bufPrint(&to_middle, "{d}G", .{text.items.len / 2 / 32}) catch unreachable) |c| _ = ed.key(arena.allocator(), null, .{ .cp = c, .text = &.{c} });
+ _ = ed.key(arena.allocator(), null, .{ .cp = 'i', .text = "i" });
+ _ = arena.reset(.free_all);
+ if (keys == 0) return;
+
+ const before = try gpa.create(Ed);
+ var pages_max: usize = 0;
+ var pages_sum: usize = 0;
+ var key_ns: u64 = 0;
+ for (0..keys) |n| {
+ if (count_pages) before.* = ed.*;
+ const t0 = now();
+ const out = ed.key(arena.allocator(), null, .{ .cp = 'a' + @as(u21, @intCast(n % 26)), .text = &.{'a' + @as(u8, @intCast(n % 26))} });
+ key_ns += now() - t0;
+ if (out != .done) return error.NotTyped;
+ _ = arena.reset(.retain_capacity);
+ if (!count_pages) continue;
+ const a = std.mem.asBytes(before);
+ const b = std.mem.asBytes(ed);
+ var pages: usize = 0;
+ var at: usize = 0;
+ while (at < a.len) : (at += 4096) {
+ const end = @min(at + 4096, a.len);
+ if (!std.mem.eql(u8, a[at..end], b[at..end])) pages += 1;
+ }
+ pages_max = @max(pages_max, pages);
+ pages_sum += pages;
+ }
+ const per_key = key_ns / keys;
+
+ pe.syntax.start(std.heap.smp_allocator); // tree-sitter mallocs: not a page each
+ const lang: pe.Language = .{ .name = "c-as-dsl", .ext = ".cdsl", .ts = tree_sitter_c() };
+ var syn: pe.Syntax = .{};
+ // the parser and its queries made once, then the parse alone timed
+ _ = syn.parse(arena.allocator(), ed, lang) orelse return error.NoTree;
+ syn.tree.?.destroy();
+ syn.tree = null;
+ const p0 = now();
+ _ = syn.parse(arena.allocator(), ed, lang) orelse return error.NoTree;
+ const parse = now() - p0;
+ std.debug.print("{d} KiB: {d} keys, {d} ns a key, pages changed a key {d} max {d:.2} mean, value {d} bytes, full parse {d} ns\n", .{ kib, keys, per_key, pages_max, @as(f64, @floatFromInt(pages_sum)) / @as(f64, @floatFromInt(keys)), @sizeOf(Ed), parse });
+}
diff --git a/test/lib/build.zig b/test/lib/build.zig
index 6cd8d6e5..436517d4 100644
--- a/test/lib/build.zig
+++ b/test/lib/build.zig
@@ -1,18 +1,34 @@
//! A package that depends on pardes for its library, as a program that draws
//! source text itself would: pardes's `lib-test` step runs `zig build test`
//! here, so the `pardes-syntax` module is built the way such a package
-//! builds it (build.zig's `library`), with the minimal grammars.
+//! builds it (build.zig's `library`), with the minimal grammars, and
+//! `pardes-editor`, the text pane as a library, which it asks for.
const std = @import("std");
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
- const pardes = b.dependency("pardes", .{ .target = target, .optimize = optimize, .@"tree-sitter" = .minimal });
- const tests = b.addTest(.{ .root_module = b.createModule(.{
+ const pardes = b.dependency("pardes", .{ .target = target, .optimize = optimize, .@"tree-sitter" = .minimal, .editor = true });
+ const step = b.step("test", "colour, outline and walk a C and a Zig source through pardes's library, and edit a text with its editor");
+ // A file belongs to one module: the syntax alone, and the editor (which
+ // has it as `.syntax`), each a test of its own.
+ for ([_][2][]const u8{ .{ "lib.zig", "pardes-syntax" }, .{ "editor.zig", "pardes-editor" } }) |t| {
+ const tests = b.addTest(.{ .root_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ .root_source_file = b.path(t[0]),
+ .imports = &.{.{ .name = t[1], .module = pardes.module(t[1]) }},
+ }) });
+ step.dependOn(&b.addRunArtifact(tests).step);
+ }
+ // What a key costs, a page count and a parse: `zig build bench -- <KiB> <keys>`.
+ const bench = b.addExecutable(.{ .name = "bench", .root_module = b.createModule(.{
.target = target,
.optimize = optimize,
- .root_source_file = b.path("lib.zig"),
- .imports = &.{.{ .name = "pardes-syntax", .module = pardes.module("pardes-syntax") }},
+ .root_source_file = b.path("bench.zig"),
+ .imports = &.{.{ .name = "pardes-editor", .module = pardes.module("pardes-editor") }},
}) });
- b.step("test", "colour, outline and walk a C and a Zig source through pardes's library").dependOn(&b.addRunArtifact(tests).step);
+ const run_bench = b.addRunArtifact(bench);
+ run_bench.addPassthruArgs();
+ b.step("bench", "a key typed into the library's editor at a size, its pages and a parse").dependOn(&run_bench.step);
}
diff --git a/test/lib/editor.zig b/test/lib/editor.zig
new file mode 100644
index 00000000..2784b176
--- /dev/null
+++ b/test/lib/editor.zig
@@ -0,0 +1,216 @@
+//! The editor as a package that depends on pardes takes it
+//! (`pardes-editor`): a value of plain data a program keeps, typed into a
+//! key at a time with an arena each call, copied anywhere, refused whole at
+//! its capacities (docs/next-editor.md).
+const std = @import("std");
+const pe = @import("pardes-editor");
+
+const Ed = pe.Editor(.{ .text = 4096, .undo = 8192, .registers = 1024, .selections = 16 });
+
+/// Keys in helix's notation, the few these tests type: printables, and
+/// `<esc>`, `<ret>`, `<bs>`.
+fn typeKeys(ed: anytype, gpa: std.mem.Allocator, keys: []const u8) !void {
+ var i: usize = 0;
+ while (i < keys.len) {
+ var k: pe.Key = .{ .cp = keys[i], .text = keys[i .. i + 1] };
+ inline for (.{ .{ "<esc>", pe.Key.escape }, .{ "<ret>", pe.Key.enter }, .{ "<bs>", pe.Key.backspace } }) |special| {
+ if (std.mem.startsWith(u8, keys[i..], special[0])) k = .{ .cp = special[1] };
+ }
+ i += if (k.text.len == 0) std.mem.indexOfScalarPos(u8, keys, i, '>').? + 1 - i else 1;
+ // every call its own arena, gone after it: nothing of a key outlives it
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ switch (ed.key(arena.allocator(), null, k)) {
+ .refused => return error.Refused,
+ else => {},
+ }
+ }
+}
+
+fn text(ed: anytype, buf: []u8) []const u8 {
+ return ed.read(buf);
+}
+
+const first = "ifn main() {<ret> let x = 1;<ret>}<esc>ggxyp" ++ "wwCcfoo<esc>";
+const second = "%dpuuUjjAbar<esc>" ++ "ggiq<esc>u";
+
+test "a value copied elsewhere, its old memory gone, types on as one never moved" {
+ const gpa = std.testing.allocator;
+ const still = try gpa.create(Ed);
+ defer gpa.destroy(still);
+ still.* = .{};
+ try typeKeys(still, gpa, first);
+ try typeKeys(still, gpa, second);
+
+ const before = try gpa.create(Ed);
+ before.* = .{};
+ try typeKeys(before, gpa, first);
+ const moved = try gpa.create(Ed);
+ defer gpa.destroy(moved);
+ @memcpy(std.mem.asBytes(moved), std.mem.asBytes(before));
+ @memset(std.mem.asBytes(before), 0xAA);
+ gpa.destroy(before);
+ try typeKeys(moved, gpa, second);
+
+ try std.testing.expectEqualSlices(u8, std.mem.asBytes(still), std.mem.asBytes(moved));
+ var buf: [4096]u8 = undefined;
+ // `%d` then `p`, both undone, the delete redone: `A` types into nothing
+ try std.testing.expectEqualStrings("bar", text(moved, &buf));
+}
+
+test "undo goes back as far as the ring holds, and redo all the way again" {
+ const gpa = std.testing.allocator;
+ const ed = try gpa.create(Ed);
+ defer gpa.destroy(ed);
+ ed.* = .{};
+ const xs: [1000]u8 = @splat('x');
+ try ed.load(&xs);
+ // thirty edits, each a snapshot of a thousand bytes: an 8 KiB ring
+ // keeps the last few
+ for (0..30) |_| try typeKeys(ed, gpa, "ia<esc>");
+ var buf: [4096]u8 = undefined;
+ var last: [4096]u8 = undefined;
+ const final = text(ed, &last);
+ try std.testing.expectEqual(1030, final.len);
+ try std.testing.expect(ed.undo.count < 30);
+ const kept = ed.undo.count;
+ for (0..40) |_| try typeKeys(ed, gpa, "u");
+ try std.testing.expectEqual(1030 - kept, text(ed, &buf).len);
+ for (0..40) |_| try typeKeys(ed, gpa, "U");
+ try std.testing.expectEqualStrings(final, text(ed, &buf));
+}
+
+test "a key whose text would not fit is refused, and the value is as it was" {
+ const gpa = std.testing.allocator;
+ const ed = try gpa.create(Ed);
+ defer gpa.destroy(ed);
+ ed.* = .{};
+ const ys: [5000]u8 = @splat('y');
+ try std.testing.expectError(error.TextFull, ed.load(&ys));
+ try ed.load(ys[0..4094]);
+ try typeKeys(ed, gpa, "iab");
+ const kept = try gpa.create(Ed);
+ defer gpa.destroy(kept);
+ kept.* = ed.*;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ try std.testing.expectEqual(pe.Outcome{ .refused = .text_full }, ed.key(arena.allocator(), null, .{ .cp = 'c', .text = "c" }));
+ try std.testing.expectEqualSlices(u8, std.mem.asBytes(kept), std.mem.asBytes(ed));
+}
+
+test "what is not the text's comes back, and the caller can do it" {
+ const gpa = std.testing.allocator;
+ const ed = try gpa.create(Ed);
+ defer gpa.destroy(ed);
+ ed.* = .{};
+ try ed.load("one two one\n");
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ try std.testing.expectEqual(pe.Role.command_line, ed.key(a, null, .{ .cp = ':', .text = ":" }).action.role);
+ _ = ed.key(a, null, .{ .cp = '%', .text = "%" });
+ try std.testing.expectEqual(pe.Role.select_regex, ed.key(a, null, .{ .cp = 's', .text = "s" }).action.role);
+ _ = ed.selectRegex(a, "one", .select);
+ var out: [pe.max_selections]pe.Selection = undefined;
+ const got = try ed.ranges(a, &out);
+ try std.testing.expectEqual(2, got.n);
+ try std.testing.expectEqual(pe.Selection{ .anchor = 8, .head = 11 }, out[1]);
+ try std.testing.expectEqual(pe.Mode.normal, ed.mode());
+ _ = ed.key(a, null, .{ .cp = 'g', .text = "g" });
+ try std.testing.expectEqual(pe.Role.goto_prefix, ed.pending().?);
+}
+
+extern fn tree_sitter_c() *const pe.syntax.ts.Language;
+
+test "a language handed in at run time parses and colours the text" {
+ const gpa = std.testing.allocator;
+ const ed = try gpa.create(Ed);
+ defer gpa.destroy(ed);
+ ed.* = .{};
+ try ed.load("int f() { return 1; }\n");
+ pe.syntax.start(gpa);
+ defer pe.syntax.stop();
+ const lang: pe.Language = .{ .name = "mine", .ext = ".mine", .ts = tree_sitter_c(), .highlights = "\"return\" @keyword (number_literal) @number" };
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ var syn: pe.Syntax = .{};
+ defer syn.forget();
+ const tree = syn.parse(arena.allocator(), ed, lang) orelse return error.NoTree;
+ try std.testing.expectEqualStrings("translation_unit", tree.rootNode().kind());
+ const colors = try pe.Syntax.colors(arena.allocator(), ed, lang, 0, ed.len());
+ try std.testing.expectEqual(pe.syntax.Syn.keyword, colors[10]);
+ try std.testing.expectEqual(pe.syntax.Syn.number, colors[17]);
+ try std.testing.expectEqual(pe.syntax.Syn.none, colors[0]);
+}
+
+test "with a parse handed in, the tree-sitter walks run in the library; without, they are the caller's" {
+ const gpa = std.testing.allocator;
+ const ed = try gpa.create(Ed);
+ defer gpa.destroy(ed);
+ ed.* = .{};
+ try ed.load("int f() { return 1 + 2; }\n");
+ pe.syntax.start(gpa);
+ defer pe.syntax.stop();
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const alt_o: pe.Key = .{ .cp = 'o', .alt = true };
+ const alt_i: pe.Key = .{ .cp = 'i', .alt = true };
+ try std.testing.expectEqual(pe.Role.expand_node, ed.key(a, null, alt_o).action.role);
+ var syn: pe.Syntax = .{ .lang = .{ .name = "mine", .ext = ".mine", .ts = tree_sitter_c(), .textobjects = "(function_definition body: (_) @function.inside) @function.around" } };
+ defer syn.forget();
+ for ("21l") |c| _ = ed.key(a, &syn, .{ .cp = c, .text = &.{c} });
+ var out: [pe.max_selections]pe.Selection = undefined;
+ // `2`, then `1 + 2`, then `return 1 + 2;`; Alt-i goes back the way it
+ // came (helix's object_selections: not the first child, `1`)
+ for ([_]struct { pe.Key, pe.Selection }{
+ .{ alt_o, .{ .anchor = 17, .head = 22 } },
+ .{ alt_o, .{ .anchor = 10, .head = 23 } },
+ .{ alt_i, .{ .anchor = 17, .head = 22 } },
+ .{ alt_i, .{ .anchor = 21, .head = 22 } },
+ }) |step| {
+ try std.testing.expectEqual(pe.Outcome.done, ed.key(a, &syn, step[0]));
+ _ = try ed.ranges(a, &out);
+ try std.testing.expectEqual(step[1], out[0]);
+ }
+ // the grammar's textobjects handed in: `maf`, the function around
+ for ("maf") |c| _ = ed.key(a, &syn, .{ .cp = c, .text = &.{c} });
+ _ = try ed.ranges(a, &out);
+ try std.testing.expectEqual(pe.Selection{ .anchor = 0, .head = 25 }, out[0]);
+}
+
+test "a byte range replaced is one step to undo, the ranges following it; a drag joined is one step, refused whole when it does not fit" {
+ const gpa = std.testing.allocator;
+ const ed = try gpa.create(Ed);
+ defer gpa.destroy(ed);
+ ed.* = .{};
+ try ed.load("a = 12 + 3;\n");
+ try typeKeys(ed, gpa, "9l");
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var buf: [4096]u8 = undefined;
+ var out: [pe.max_selections]pe.Selection = undefined;
+ // a drag on the number: its first frame a step, the rest joined to it
+ try std.testing.expectEqual(pe.Outcome.done, ed.replace(a, 4, 6, "130", false));
+ _ = try ed.ranges(a, &out);
+ try std.testing.expectEqual(pe.Selection{ .anchor = 10, .head = 11 }, out[0]); // still on `3`
+ const steps = ed.undo.count;
+ try std.testing.expectEqual(pe.Outcome.done, ed.replace(a, 4, 7, "131", true));
+ try std.testing.expectEqual(pe.Outcome.done, ed.replace(a, 4, 7, "14", true));
+ try std.testing.expectEqualStrings("a = 14 + 3;\n", text(ed, &buf));
+ try std.testing.expectEqual(steps, ed.undo.count);
+ _ = try ed.ranges(a, &out);
+ try std.testing.expectEqual(pe.Selection{ .anchor = 9, .head = 10 }, out[0]);
+ try typeKeys(ed, gpa, "u");
+ try std.testing.expectEqualStrings("a = 12 + 3;\n", text(ed, &buf));
+ try typeKeys(ed, gpa, "U");
+ try std.testing.expectEqualStrings("a = 14 + 3;\n", text(ed, &buf));
+ // what would not fit: refused, the value as it was
+ const kept = try gpa.create(Ed);
+ defer gpa.destroy(kept);
+ kept.* = ed.*;
+ const ys: [4096]u8 = @splat('y');
+ try std.testing.expectEqual(pe.Outcome{ .refused = .text_full }, ed.replace(a, 0, 1, &ys, false));
+ try std.testing.expectEqualSlices(u8, std.mem.asBytes(kept), std.mem.asBytes(ed));
+}
diff --git a/test/panes.zig b/test/panes.zig
index 04769ccf..fb973ea2 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -1153,7 +1153,7 @@ test "terminal edits and undo survive partial history clearing and whole-screen
try std.testing.expectEqualStrings("edit one\nedit two", snapshot.ovl.?.text);
}
try std.testing.expectEqual(@as(usize, 2), pardes.Term.emulatorOf(pane.terminal.?).vt.screens.active.pages.countTrackedPins());
- try pardes.edit.undoStep(p, &pane.body, true);
+ try pardes.edit.undoStep(p.editor(), &pane.body, true);
try std.testing.expectEqualStrings("edit one\nedit two", pane.ovl.?.text);
try std.testing.expectEqual(expected, pane.ovl.?.row);
}
diff --git a/test/perf.zig b/test/perf.zig
index 0f5466ad..85cc2ca3 100644
--- a/test/perf.zig
+++ b/test/perf.zig
@@ -695,7 +695,7 @@ fn measureTerm(op: TermOp, fx: TermFixture, reps: usize) !Cell {
pump(core);
}
_ = try frame(core);
- const motion_rows = if (op == .key_down) (try pardes.edit.paneCursorLines(core, &pane.body)).len else 0;
+ const motion_rows = if (op == .key_down) (try pardes.edit.paneCursorLines(core.editor(), &pane.body)).len else 0;
if (op == .key_down and motion_rows < 3) return error.EmptyTerminalFixture;
var cols = screen_cols;