diff options
Diffstat (limited to 'src/addon_test.zig')
| -rw-r--r-- | src/addon_test.zig | 167 |
1 files changed, 109 insertions, 58 deletions
diff --git a/src/addon_test.zig b/src/addon_test.zig index 496b7504..3cbb5a64 100644 --- a/src/addon_test.zig +++ b/src/addon_test.zig @@ -1,25 +1,30 @@ //! `pardes --addon-test <addon.so> <script>`: an addon's author's test. //! The addon is loaded into a session of its own (80x24, no terminal, no -//! disk, its jobs run at once, its clock virtual and moved by `tick` and -//! `settle` alone), a pane of it opened, and the -//! script's lines run in turn, each printed with the pane's cells and -//! placements after it; a script compares the output with what it wants -//! as a snapshot script does (`diff`). +//! disk, its jobs run at once, its clock virtual, starting at 1 s and moved +//! by `tick` and `settle` alone), a pane of it opened, and the script's +//! lines run in turn, each printed with the pane's tag (the kind's own +//! prefix), cells and placements after it; a script compares the output +//! with what it wants as a snapshot script does (`diff`). //! //! open [path] a pane of the kind (the first step opens one bare) //! key hjkl<up> keys, a character or <up> <down> <left> <right> //! <enter> <tab> <bs> <esc> <space> each //! tick 100 the clock 100 ms on, the kind's ticks run -//! settle ticks until the kind asks for none (at most 1000) -//! size 60 20 the session's cells, the pane's share of them +//! settle ticks until the kind asks for none (at most 1000): +//! a kind that asks for ticks while idle fails it +//! size 60 20 the session's terminal, the pane's share of it +//! (`window CxR` says what the kind paints) //! seed 7 what every pane's seed is made from (before open) //! click 3 1 a left click at the body's column 3, row 1 +//! focus, blur the window takes the keyboard, or loses it +//! dump the pane's record (its length) loaded into a +//! fresh pane, which the script goes on with +//! body, ctl the pane's body, or its ctl file's read //! Word arg one of the kind's words, at its pane //! # anything a comment, not printed const std = @import("std"); const pardes = @import("pardes.zig"); const Kind = @import("Kind.zig"); -const Addon = @import("Addon.zig"); const Pardes = pardes.Pardes; pub fn main(io: std.Io, gpa: std.mem.Allocator, lib: []const u8, script_path: ?[]const u8) u8 { @@ -35,16 +40,8 @@ pub fn main(io: std.Io, gpa: std.mem.Allocator, lib: []const u8, script_path: ?[ } fn run(io: std.Io, gpa: std.mem.Allocator, lib: []const u8, script_path: ?[]const u8, out: *std.Io.Writer) !void { - Kind.inline_jobs = true; - var why: Kind.Buf(160) = .{}; - if (!Addon.load(lib, &why)) { - try out.print("addon-test: {s}\n", .{why.slice()}); - return error.KindRefused; - } - const ops = Kind.byName(why.slice()).?; const script = try std.Io.Dir.cwd().readFileAlloc(io, script_path orelse return error.NoScript, gpa, .limited(1 << 20)); defer gpa.free(script); - // The regions and the C libraries' allocators a frontend sets up. const allocs = pardes.memory.init(gpa); defer pardes.memory.deinit(); @@ -54,6 +51,14 @@ fn run(io: std.Io, gpa: std.mem.Allocator, lib: []const u8, script_path: ?[]cons defer pardes.syntax.stop(); const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24, .state = .memory, .image_allocator = allocs.image, .pdf_allocator = allocs.pdf, .tree_sitter_allocator = allocs.tree_sitter, .frame_allocator = allocs.frame }); defer p.deinit(); + // Loaded as `Addon load` loads it, the host's half here. + pardes.Addon.perform(p, .load, 0, lib); + const last = &p.kinds.kinds[p.kinds.n - 1]; + if (last.refused) { + try out.print("addon-test: {s}\n", .{last.why.slice()}); + return error.KindRefused; + } + const k = p.kinds.n - 1; var now: u64 = std.time.ns_per_s; p.advance(now); var id: ?usize = null; @@ -65,58 +70,97 @@ fn run(io: std.Io, gpa: std.mem.Allocator, lib: []const u8, script_path: ?[]cons const verb_end = std.mem.indexOfScalar(u8, line, ' ') orelse line.len; const verb = line[0..verb_end]; const arg = std.mem.trim(u8, line[verb_end..], " "); - if (std.mem.eql(u8, verb, "seed")) { + const is = struct { + fn is(v: []const u8, w: []const u8) bool { + return std.mem.eql(u8, v, w); + } + }.is; + if (is(verb, "seed")) { Kind.seed_base = std.fmt.parseInt(u64, arg, 10) catch 0; - } else if (std.mem.eql(u8, verb, "open")) { - id = try open(p, ops, if (arg.len > 0) arg else null); - } else { - if (id == null) id = try open(p, ops, null); - const at = id.?; - if (std.mem.eql(u8, verb, "key")) { - try keys(p, arg); - } else if (std.mem.eql(u8, verb, "tick")) { - now += (std.fmt.parseInt(u64, arg, 10) catch 0) * std.time.ns_per_ms; + continue; + } + const opened = id == null or is(verb, "open"); + if (opened) id = try open(p, k, if (is(verb, "open") and arg.len > 0) arg else null); + const at = id.?; + if (is(verb, "key")) { + try keys(p, arg); + } else if (is(verb, "tick")) { + now += (std.fmt.parseInt(u64, arg, 10) catch 0) * std.time.ns_per_ms; + p.advance(now); + } else if (is(verb, "settle")) { + var n: usize = 0; + while (Kind.wake(p) != null and n < 1000) : (n += 1) { + now = @max(now + 1, p.nextWake() orelse break); p.advance(now); - } else if (std.mem.eql(u8, verb, "settle")) { - var n: usize = 0; - while (pardes.Kind.wake(p) != null and n < 1000) : (n += 1) { - now = @max(now + 1, p.nextWake() orelse break); - p.advance(now); - } - if (n == 1000) try out.writeAll("settle: still asking for frames after 1000 ticks\n"); - } else if (std.mem.eql(u8, verb, "size")) { - var it = std.mem.tokenizeScalar(u8, arg, ' '); - const cols = std.fmt.parseInt(u16, it.next() orelse "80", 10) catch 80; - const rows = std.fmt.parseInt(u16, it.next() orelse "24", 10) catch 24; - p.update(.{ .resize = .{ .cols = cols, .rows = rows } }); - } else if (std.mem.eql(u8, verb, "click")) { - var it = std.mem.tokenizeScalar(u8, arg, ' '); - const col = std.fmt.parseInt(u16, it.next() orelse "0", 10) catch 0; - const row = std.fmt.parseInt(u16, it.next() orelse "0", 10) catch 0; - const body = bodyRect(p, at) orelse continue; - for ([_]pardes.Mouse.Kind{ .press, .release }) |k| - p.update(.{ .mouse = .{ .button = .left, .kind = k, .col = body.x + col, .row = body.y + row } }); - } else { - p.active = at; - if (!p.executeBuiltinLine(at, line)) try out.print("not a word here: {s}\n", .{verb}); } + if (n == 1000) try out.writeAll("settle: still asking for frames after 1000 ticks\n"); + } else if (is(verb, "size")) { + var it = std.mem.tokenizeScalar(u8, arg, ' '); + const cols = std.fmt.parseInt(u16, it.next() orelse "80", 10) catch 80; + const rows = std.fmt.parseInt(u16, it.next() orelse "24", 10) catch 24; + p.update(.{ .resize = .{ .cols = cols, .rows = rows } }); + } else if (is(verb, "click")) { + var it = std.mem.tokenizeScalar(u8, arg, ' '); + const col = std.fmt.parseInt(u16, it.next() orelse "0", 10) catch 0; + const row = std.fmt.parseInt(u16, it.next() orelse "0", 10) catch 0; + const body = window(p, at) orelse continue; + for ([_]pardes.Mouse.Kind{ .press, .release }) |mk| + p.update(.{ .mouse = .{ .button = .left, .kind = mk, .col = body.x + col, .row = body.y + row } }); + } else if (is(verb, "focus") or is(verb, "blur")) { + p.update(.{ .focus = is(verb, "focus") }); + } else if (is(verb, "dump")) { + id = try reloaded(p, gpa, at, out); + } else if (is(verb, "body") or is(verb, "ctl")) { + drain(p); + var fields: [4096]u8 = undefined; + const text = if (is(verb, "body")) try Kind.body(p.panes[at].?, p.scratch.allocator()) else Kind.ctlRead(p.panes[at].?, &fields); + var rows = std.mem.splitScalar(u8, std.mem.trimEnd(u8, text, "\n"), '\n'); + while (rows.next()) |row| try out.print("={s}\n", .{row}); + continue; + } else if (!is(verb, "open")) { + p.active = at; + if (!p.executeBuiltinLine(at, line)) try out.print("not a word here: {s}\n", .{verb}); } drain(p); - if (id) |at| try show(p, gpa, at, out); + try show(p, gpa, id.?, out, opened or is(verb, "size")); } } -fn open(p: *Pardes, ops: *const Kind.Ops, path: ?[]const u8) !usize { +fn open(p: *Pardes, k: u8, path: ?[]const u8) !usize { const free = p.freeSlot() orelse return error.NoPaneSlots; - _ = if (path) |at| try Kind.openFile(p, free, ops, at) else try Kind.open(p, free, ops, null, null); + _ = if (path) |at| try Kind.openFile(p, free, k, at) else try Kind.open(p, free, k, null, null); pardes.exec.placeNew(p, p.active, null, free, .doc); p.active = free; drain(p); return free; } +/// The pane's record loaded into a fresh pane in its place, as a Restore +/// would: what the script goes on with. +fn reloaded(p: *Pardes, gpa: std.mem.Allocator, at: usize, out: *std.Io.Writer) !usize { + const slot = p.panes[at].?.addon.?; + const record = try pardes.dump.slotRecord(slot); + defer if (record) |r| slot.gpa.free(r); + try out.print("dump {d} bytes\n", .{if (record) |r| r.len else 0}); + var bytes: std.Io.Writer.Allocating = .init(gpa); + defer bytes.deinit(); + try pardes.dump.slotWrite(slot, gpa, &bytes.writer); + const fresh = try slot.gpa.create(Kind.Slot); + try pardes.dump.slotRead(fresh, slot.gpa, bytes.written()); + try p.removePane(at, null); + const free = p.freeSlot() orelse return error.NoPaneSlots; + const pane = try p.newDocPane(free); + pane.addon = fresh; + pardes.dump.reviveSlot(p, free, fresh); + pardes.exec.placeNew(p, p.active, null, free, .doc); + p.active = free; + drain(p); + return free; +} + +/// Its effects done as a host does them: its jobs here, at once. fn drain(p: *Pardes) void { - while (p.nextEffect()) |_| {} + while (p.nextEffect()) |e| if (e == .job) p.perform(e); } fn keys(p: *Pardes, text: []const u8) !void { @@ -140,25 +184,32 @@ fn keys(p: *Pardes, text: []const u8) !void { break :blk c; }; p.update(.{ .key = .{ .cp = cp } }); + drain(p); } } -fn bodyRect(p: *Pardes, id: usize) ?pardes.Rect { +/// The cells the kind paints: its body less the notices over it. +fn window(p: *Pardes, id: usize) ?pardes.Rect { var arena: std.heap.ArenaAllocator = .init(p.gpa); defer arena.deinit(); const s = p.render(arena.allocator()) catch return null; - const r = s.region(.body, id) orelse return null; - return r.rect; + var r = (s.region(.body, id) orelse return null).rect; + const shown = p.panes[id].?.notices.span(); + r.y += shown; + r.h -|= shown; + return r; } /// The pane's body, a line a row (an unpainted cell a space), then each -/// placement over it. -fn show(p: *Pardes, gpa: std.mem.Allocator, id: usize, out: *std.Io.Writer) !void { +/// placement over it; `window CxR` first when asked. +fn show(p: *Pardes, gpa: std.mem.Allocator, id: usize, out: *std.Io.Writer, size: bool) !void { var arena: std.heap.ArenaAllocator = .init(gpa); defer arena.deinit(); const s = try p.render(arena.allocator()); const pane = p.panes[id] orelse return out.writeAll("(the pane is gone)\n"); - try out.print("tag {s}\n", .{try pardes.tagline.tagPrefix(p, pane)}); + const slot = pane.addon.?; + if (size) if (window(p, id)) |w| try out.print("window {d}x{d}\n", .{ w.w, w.h }); + try out.print("tag {s}\n", .{if (slot.prefix.len > 0) slot.prefix.slice() else slot.nameOf()}); const r = (s.region(.body, id) orelse return).rect; for (r.y..r.y + r.h) |y| { var row: std.ArrayList(u8) = .empty; |
