//! 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 /// ``, ``, ``. 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 (.{ .{ "", pe.Key.escape }, .{ "", pe.Key.enter }, .{ "", 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() { let x = 1;}ggxyp" ++ "wwCcfoo"; const second = "%dpuuUjjAbar" ++ "ggiqu"; 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"); 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]); }