//! docs/typ/reference.typ, Addons : a library that brings a kind //! of pane, driven here through addons/fake/fake.c (every function of //! src/kinds/pardes_addon.h) and the copies of it built wrong. const std = @import("std"); const Session = @import("session").Session; const fake = Session.fake_addons; fn has(hay: []const u8, needle: []const u8) bool { return std.mem.indexOf(u8, hay, needle) != null; } /// The serial of the pane /index lists of kind `kind`. fn paneOf(s: *Session, kind: []const u8) !u32 { var lines = std.mem.tokenizeScalar(u8, try s.read("/index"), '\n'); while (lines.next()) |line| { var words = std.mem.tokenizeScalar(u8, line, ' '); const serial = words.next() orelse continue; if (std.mem.eql(u8, words.next() orelse continue, kind)) return std.fmt.parseInt(u32, serial, 10); } return error.NoSuchPane; } /// The library at `path` loaded, as from a terminal's directory. fn load(s: *Session, path: []const u8) !void { const real = try std.Io.Dir.cwd().realPathFileAlloc(std.testing.io, path, s.arena.allocator()); try s.write("/ctl", s.at("Addon load {s}\n", .{real})); } fn unload(s: *Session, name: []const u8) void { _ = s.refused("/ctl", s.at("Addon unload {s}\n", .{name})) catch {}; } test "addons: Addon load takes a library in, /addons lists it with the kinds compiled in, its words join /commands and Help, and Addon unload lets it go" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); try load(&s, fake.ok); defer unload(&s, "fake"); // ` `. const listed = try s.read("/addons"); try std.testing.expect(std.mem.startsWith(u8, listed, "fake 1 2.2 0 /")); var fields = std.mem.tokenizeScalar(u8, listed[0..std.mem.indexOfScalar(u8, listed, '\n').?], ' '); for (0..5) |_| _ = fields.next(); try std.testing.expectEqual(@as(usize, 64), fields.next().?.len); try std.testing.expectEqualStrings("loaded", fields.next().?); const commands = try s.read("/commands"); try std.testing.expect(has(commands, "\nFake both -- a fake pane, counting (addon fake)\n")); try std.testing.expect(has(commands, "\nFakeBump arg pane -- add to the count (addon fake)\n")); // Its word run where no pane of its kind is: refused, saying where. try std.testing.expect(try s.refused("/ctl", "FakeBump\n") != 0); try std.testing.expect(has(s.said, "FakeBump is a fake pane's word")); // A pane of it open, it stays; closed, it goes. try s.write("/ctl", "Fake\n"); const pane = try paneOf(&s, "fake"); try std.testing.expect(std.mem.startsWith(u8, try s.read("/addons"), "fake 1 2.2 1 /")); try std.testing.expect(try s.refused("/ctl", "Addon unload fake\n") != 0); try std.testing.expect(has(s.said, "1 fake pane is open")); try s.write(s.at("/pane/{d}/ctl", .{pane}), "Del\n"); try s.write("/ctl", "Addon unload fake\n"); try std.testing.expect(!has(try s.read("/addons"), "fake")); try std.testing.expect(!has(try s.read("/commands"), "Fake")); } test "addons: a library of another ABI, one with no pardes_addon, and one whose word is the core's are refused, each listed with why" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); for ([_][]const u8{ fake.abi, fake.no_export, fake.core_word }) |path| try load(&s, path); const listed = try s.read("/addons"); try std.testing.expect(std.mem.startsWith(u8, listed, "fakeabi 1 3.0 0 /")); try std.testing.expect(has(listed, " refused: wants abi 3, this pardes speaks 2\n")); try std.testing.expect(has(listed, " refused: it has no pardes_addon\n")); try std.testing.expect(has(listed, "\nfakeword 1 2.2 0 /")); try std.testing.expect(has(listed, " refused: word Save is the core's\n")); // A file that is no library at all: listed with what the loader said. var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "notalib.so", .data = "not a library\n" }); var buf: [4096]u8 = undefined; const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)]; try s.write("/ctl", s.at("Addon load {s}/notalib.so\n", .{dir})); try std.testing.expect(has(try s.read("/addons"), s.at("notalib.so 0 0.0 0 {s}/notalib.so - ", .{dir}))); try std.testing.expect(!has(try s.read("/addons"), "notalib.so - loaded")); // None of them brought a word. try std.testing.expect(!has(try s.read("/commands"), "(addon fake")); } test "addons: a pane of an addon's kind shows its cells and its picture, takes its keys, clicks, words and ticks, and answers its body and ctl" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); try load(&s, fake.ok); defer unload(&s, "fake"); try s.write("/ctl", "Fake\n"); const pane = try paneOf(&s, "fake"); try std.testing.expectEqual(pane, try s.focused()); try std.testing.expect(has(try s.screen(), "count 0")); // Its picture is a placement over its cells, in /screen's images. try std.testing.expect(has(try s.read("/screen"), "\"images\":[{")); // Every key but Esc is its own. try s.keys("ab"); try std.testing.expect(has(try s.screen(), "count 2")); try std.testing.expect(has(try s.screen(), "kb")); try s.click("count 2", 3, 1); try std.testing.expect(has(try s.screen(), "count 3")); try std.testing.expect(has(try s.screen(), "m3")); // Its words go to it from its ctl; one it refuses fails the write. try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeBump 10\n"); try std.testing.expect(has(try s.screen(), "count 13")); try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{pane})), "count:13 ")); // A job's answer lands at the end of the step that asked for it (a // test's job runs at once; a real one lands on a later step). try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeJob\n"); try std.testing.expect(has(try s.screen(), "count 19")); try s.expect(s.at("/pane/{d}/body", .{pane}), "fake\n\n"); // Esc leaves it, as from a raw terminal. try s.keys("\x1b"); try std.testing.expect(try s.focused() != pane); } test "addons: the image addon opens the pictures a Look names, fitted, with the core's art words in its tag; refuses what it cannot read; and keeps a picture's bytes through a dump" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); try load(&s, Session.image_addon); const listed = try s.read("/addons"); try std.testing.expect(std.mem.startsWith(u8, listed, "image 1 2.2 0 /") and has(listed, " loaded\n")); var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var buf: [4096]u8 = undefined; const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)]; // A PNG 4x2, a JPEG 16x8 baseline and progressive, a PPM 2x1: each a // pane showing its pixels (`src`), over the cells it fits. const b64 = std.base64.standard.Decoder; const pictures = [_]struct { []const u8, []const u8, u32, u32 }{ .{ "red.png", "iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAIAAADwyuo0AAAAE0lEQVR4nGP4z8AARGDiPwMyBwBnsgf5Q2OaZwAAAABJRU5ErkJggg==", 4, 2 }, .{ "red.jpg", "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wAARCAAIABADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD5Dooor8LP9VD/2Q==", 16, 8 }, .{ "red.jpeg", "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wgARCAAIABADASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAVAQEBAAAAAAAAAAAAAAAAAAAGCP/aAAwDAQACEAMQAAABkIC1V//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEAAQUCP//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Bf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Bf//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEABj8CP//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEAAT8hP//aAAwDAQACAAMAAAAQA//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Qf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Qf//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEAAT8QP//Z", 16, 8 }, .{ "pixel.ppm", "P6\n2 1\n255\n\x0d\x4d\xe7\x0d\x4d\xe7", 2, 1 }, }; for (pictures) |pic| { const bytes = if (std.mem.endsWith(u8, pic[0], ".ppm")) pic[1] else blk: { const out = try s.arena.allocator().alloc(u8, try b64.calcSizeForSlice(pic[1])); try b64.decode(out, pic[1]); break :blk out; }; try tmp.dir.writeFile(std.testing.io, .{ .sub_path = pic[0], .data = bytes }); try s.write("/look", s.at("{s}/{s}\n", .{ dir, pic[0] })); try std.testing.expect(has(try s.read("/screen"), s.at("\"serial\":{d},\"rect\":", .{try s.focused()}))); try std.testing.expect(has(try s.read("/screen"), s.at("\"src\":[0,0,{d},{d}]", .{ pic[2], pic[3] }))); } const pane = try s.focused(); // Its tag: the kind's `img`, the core's art words, its path. With no // pixels to show (no frontend), glyph art whatever Petscii says. const tag = s.at("/pane/{d}/tag", .{pane}); try std.testing.expect(std.mem.startsWith(u8, try s.read(tag), s.at("img petscii:on palette:commodore ascii:on {s}/pixel.ppm ", .{dir}))); const ctl = s.at("/pane/{d}/ctl", .{pane}); for ([_][]const u8{ "Petscii on\n", "Palette terminal\n", "Palette terminal\n", "Ascii off\n" }) |line| try s.write(ctl, line); try std.testing.expect(std.mem.startsWith(u8, try s.read(tag), "img petscii:on palette:terminal ascii:off ")); try std.testing.expect(has(try s.read("/screen"), "\"petscii\":true")); // A file it cannot read: the Look fails saying so, and opens nothing. try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "bad.png", .data = "\x89PNG not really" }); const panes = (try s.read("/index")).len; try std.testing.expect(try s.refused("/look", s.at("{s}/bad.png\n", .{dir})) != 0); try std.testing.expect(has(s.said, "bad.png: not an image pardes can read")); try std.testing.expectEqual(panes, (try s.read("/index")).len); // Its record is the file's bytes: restored without the addon it waits // as a placeholder holding them, and shows them again when it comes. try s.write("/ctl", "Dump\n"); const label = try s.arena.allocator().dupe(u8, std.mem.sliceTo(try s.read("/dumps"), ' ')); var lines = std.mem.tokenizeScalar(u8, try s.read("/index"), '\n'); while (lines.next()) |line| if (std.mem.indexOf(u8, line, " image ") != null) try s.write(s.at("/pane/{s}/ctl", .{std.mem.sliceTo(line, ' ')}), "Del\n"); try s.write("/ctl", "Addon unload image\n"); try s.write("/ctl", s.at("Restore {s}\n", .{label})); try std.testing.expect(has(try s.screen(), "addon image 1 is not loaded: Addon load ")); try load(&s, Session.image_addon); defer unload(&s, "image"); try std.testing.expect(has(try s.read("/screen"), "\"src\":[0,0,4,2]")); } test "addons: a Plumb rule to a loaded kind opens that kind's pane, is refused naming one not loaded, and with its kind gone the look falls through to text" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); try load(&s, Session.image_addon); var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var buf: [4096]u8 = undefined; const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)]; // A PNG under a name no kind claims. const png = "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\xcf\xc0\x00\x00\x03\x01\x01\x00\xc9\xfe\x92\xef\x00\x00\x00\x00IEND\xaeB`\x82"; try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "red.pic", .data = png }); try std.testing.expect(try s.refused("/ctl", "Plumb suffix .pic to nokind\n") != 0); try std.testing.expect(has(s.said, "Plumb: invalid port: url, dir, file or a loaded kind")); try s.write("/ctl", "Plumb suffix .pic to image\n"); try s.write("/look", s.at("{s}/red.pic\n", .{dir})); try std.testing.expectEqual(try paneOf(&s, "image"), try s.focused()); try s.write(s.at("/pane/{d}/ctl", .{try s.focused()}), "Del\n"); try s.write("/ctl", "Addon unload image\n"); try s.write("/look", s.at("{s}/red.pic\n", .{dir})); try std.testing.expect(has(try s.read(s.at("/pane/{d}/tag", .{try s.focused()})), "red.pic")); try std.testing.expectError(error.NoSuchPane, paneOf(&s, "image")); } test "addons: a dump keeps an addon's pane; restored without its addon it waits as a placeholder, and opens in place when the addon comes" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); try load(&s, fake.ok); try s.write("/ctl", "Fake\n"); const pane = try paneOf(&s, "fake"); try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeBump 41\n"); try s.write("/ctl", "Dump\n"); const label = std.mem.sliceTo(try s.read("/dumps"), ' '); const kept = try s.arena.allocator().dupe(u8, label); // Restored with it: the pane as it was, through the kind's own record. try s.write("/ctl", s.at("Restore {s}\n", .{kept})); try std.testing.expect(has(try s.screen(), "count 41")); // Restored without it: a placeholder in its place, saying what it waits for. try s.write(s.at("/pane/{d}/ctl", .{try paneOf(&s, "fake")}), "Del\n"); try s.write("/ctl", "Addon unload fake\n"); try s.write("/ctl", s.at("Restore {s}\n", .{kept})); const waiting = try paneOf(&s, "fake"); try std.testing.expect(has(try s.screen(), "addon fake 1 is not loaded: Addon load ")); try std.testing.expect(try s.refused(s.at("/pane/{d}/ctl", .{waiting}), "FakeBump\n") != 0); // The addon back, the pane opens where it stands, its count kept. try load(&s, fake.ok); defer unload(&s, "fake"); try std.testing.expectEqual(waiting, try paneOf(&s, "fake")); try std.testing.expect(has(try s.screen(), "count 41")); } test "addons: Addon reload moves every pane of the kind to the library as it is now, its state kept; a library that fails its checks leaves the old one running" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var buf: [4096]u8 = undefined; const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)]; const lib = s.at("{s}/fake.so", .{dir}); const bytes = struct { fn of(ss: *Session, path: []const u8) ![]u8 { return std.Io.Dir.cwd().readFileAlloc(std.testing.io, path, ss.arena.allocator(), .limited(64 << 20)); } }.of; try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "fake.so", .data = try bytes(&s, fake.ok) }); try s.write("/ctl", s.at("Addon load {s}\n", .{lib})); defer unload(&s, "fake"); try s.write("/ctl", "Fake\n"); const pane = try paneOf(&s, "fake"); try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeBump 7\n"); try s.keys("ab"); try std.testing.expect(has(try s.screen(), "count 9")); const before = try s.arena.allocator().dupe(u8, try s.read("/addons")); // Half built: another ABI's. Refused, and the old library still runs. try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "fake.so", .data = try bytes(&s, fake.abi) }); try s.write("/ctl", "Addon reload fake\n"); try std.testing.expectEqualStrings(before, try s.read("/addons")); try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeBump 1\n"); try std.testing.expect(has(try s.screen(), "count 10")); // As it is now: its record taken across, by the old library's dump // and the new one's load. try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "fake.so", .data = try bytes(&s, fake.ok) }); try s.write("/ctl", "Addon reload fake\n"); try std.testing.expectEqual(pane, try paneOf(&s, "fake")); try std.testing.expect(has(try s.screen(), "count 10")); // A library with no record of its own: the pane opens again from its // words' last values (FakeBump 1), what keys did gone. try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "fake.so", .data = try bytes(&s, fake.no_dump) }); try s.write("/ctl", "Addon reload fake\n"); try std.testing.expect(has(try s.screen(), "count 1")); // /addons says the file it runs now: another BLAKE3. try std.testing.expect(!std.mem.eql(u8, before, try s.read("/addons"))); } test "addons: a job under way across a reload answers into nothing, its library kept until it has; the reloaded pane's own jobs land" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var buf: [4096]u8 = undefined; const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)]; const copy = struct { fn of(ss: *Session, d: std.Io.Dir, from: []const u8) !void { try d.writeFile(std.testing.io, .{ .sub_path = "fake.so", .data = try std.Io.Dir.cwd().readFileAlloc(std.testing.io, from, ss.arena.allocator(), .limited(64 << 20)) }); } }.of; try copy(&s, tmp.dir, fake.ok); try s.write("/ctl", s.at("Addon load {s}/fake.so\n", .{dir})); defer unload(&s, "fake"); try s.write("/ctl", "Fake\n"); const pane = try paneOf(&s, "fake"); try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeBump 5\n"); // A job taken by a worker, still running as the library is replaced // by another (one with no record: the pane comes back at its place, 5, // then its words' last values, FakeBump 5: 10). s.hold_jobs = true; try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeJob\n"); try copy(&s, tmp.dir, fake.no_dump); try s.write("/ctl", "Addon reload fake\n"); try std.testing.expect(has(try s.screen(), "count 10 ")); // It answers now, from the old library's code: of another generation, // the answer is dropped, and the old library goes after it. s.releaseJobs(); try std.testing.expect(has(try s.screen(), "count 10 ")); try s.write(s.at("/pane/{d}/ctl", .{pane}), "FakeJob\n"); try std.testing.expect(has(try s.screen(), "count 16 ")); } test "addons: a Look at a file whose extension an addon claims opens a pane of its kind, and its words are in Help" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); try load(&s, fake.ok); defer unload(&s, "fake"); var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "five.fake", .data = "12345" }); var buf: [4096]u8 = undefined; const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)]; const pane = try s.lookFile(s.at("{s}/five.fake", .{dir})); try std.testing.expectEqual(pane, try paneOf(&s, "fake")); // Its bytes were the kind's to open: five of them. try std.testing.expect(has(try s.screen(), "count 5")); try s.write(s.at("/pane/{d}/ctl", .{pane}), "Del\n"); try s.write("/ctl", "Help\n"); const help = try s.read(s.at("/pane/{d}/body", .{try s.focused()})); try std.testing.expect(has(help, "SPC z f Fake a fake pane, counting (addon fake)\n")); }