summaryrefslogtreecommitdiff
path: root/test/hxkeys.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 06:08:57 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commitf923d0342f7fbbc965867c19e03cb6c94fcb7fd3 (patch)
tree5893aafa1253d4a49c61aab97fdacb9020cd8dbb /test/hxkeys.zig
parent56274a68fb7a418625f01d479ced9fbfc19383f2 (diff)
downloadpardes-f923d0342f7fbbc965867c19e03cb6c94fcb7fd3.tar.gz
pardes-f923d0342f7fbbc965867c19e03cb6c94fcb7fd3.zip
hxlib: hxdiff's cases on the library, against helix's goldens and against the file pane (docs/next-editor.md, R6): test/hxlib.zig types each case into a `pardes-editor` value and prints its result as hxdiff prints a pane's, doing what an app does with the s, S, K and Alt-K it is handed back (the keys to <ret> its pattern, <esc> no answer) and printing a case that reaches any other action (a view, n and N, a macro, gw) as the caller's; hxdiff takes another driver's results (`--actual=`), and `zig build hxlib` (`-- --parity`) holds them to the goldens or the file pane; the key notation is test/hxkeys.zig, which both harnesses read; what the cases found, fixed: paneCursorLines gave the library's body no lines (mm, mi, ma, md, mr, insert-mode arrows), and the library's selectRegex keeps its pattern in `/` as pardes's prompt does (look.submitSearch); a page key in insert mode moves a view and is the caller's; test/lib's `zig build bench -- <KiB> <keys>`: a key's cost, the pages it changes, a parse; hxlib 537 of 658 compared with 0 mismatches (5 waived as for pardes, 121 the caller's), --parity 617 of 738 with 0 mismatches and 0 waived; hxdiff 658 / parity 738 / hxgolf 124 with 0 mismatches, core-test 811 of 950, shell-test 990 of 993, replicas pass, lib-test pass
Diffstat (limited to 'test/hxkeys.zig')
-rw-r--r--test/hxkeys.zig80
1 files changed, 80 insertions, 0 deletions
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;
+}