@weborigami/language 0.7.0-beta.1 → 0.7.0-beta.3

package/test/compiler/optimize.test.js

@@ -15,6 +15,16 @@ import {
 } from "./codeHelpers.js";
 
 describe("optimize", () => {
+  test("define cache path based on source", () => {
+    const expression = "{ a = { b: 1 } }";
+    const expected = [
+      ops.object,
+      "/folder/test.ori/",
+      ["a", [ops.getter, [ops.object, "/folder/test.ori/a/", ["b", 1]]]],
+    ];
+    assertCompile(expression, expected);
+  });
+
   test("change local references to context references", () => {
     const expression = `(name) => {
       a: name,
@@ -26,6 +36,7 @@ describe("optimize", () => {
       [["name", [[ops.params, 0], 0]]],
       [
         ops.object,
+        "/folder/test.ori/_objects/",
         [
           "a",
           [
@@ -49,11 +60,13 @@ describe("optimize", () => {
     const expression = `{ a: 1, more: { a } }`;
     const expected = [
       ops.object,
+      "/folder/test.ori/",
       ["a", 1],
       [
         "more",
         [
           ops.object,
+          "/folder/test.ori/more/",
           [
             "a",
             [
@@ -76,11 +89,13 @@ describe("optimize", () => {
     }`;
     const expected = [
       ops.object,
+      "/folder/test.ori/",
       ["name", "Alice"],
       [
         "user",
         [
           ops.object,
+          "/folder/test.ori/user/",
           [
             "name",
             [
@@ -95,7 +110,7 @@ describe("optimize", () => {
     assertCompile(expression, expected, "shell");
   });
 
-  describe.only("resolve reference", () => {
+  describe("resolve reference", () => {
     test("external reference", () => {
       // Compilation of `folder` where folder isn't a variable
       const code = createCode([
@@ -115,6 +130,31 @@ describe("optimize", () => {
       );
     });
 
+    test("external reference with path", () => {
+      // Compilation of `src/templates/page.ori` where src isn't a variable
+      const code = createCode([
+        markers.traverse,
+        [markers.reference, "src/"],
+        [ops.literal, "templates/"],
+        [ops.literal, "page.ori"],
+      ]);
+      const parent = {};
+      const expected = [
+        [
+          ops.cache,
+          "test.ori/_refs/src/",
+          [[ops.scope], [ops.literal, "src/"]],
+        ],
+        [ops.literal, "templates/"],
+        [ops.literal, "page.ori"],
+      ];
+      const globals = {};
+      assertCodeEqual(
+        optimize(code, { cachePath: "test.ori", globals, parent }),
+        expected,
+      );
+    });
+
     test("external reference with implied unpack", () => {
       // Compilation of `greet.ori("world")`
       const code = createCode([
@@ -141,6 +181,7 @@ describe("optimize", () => {
       // Compilation of `{ (posts) = posts.txt }`
       const code = createCode([
         ops.object,
+        null,
         [
           "(posts)",
           [ops.getter, [markers.traverse, [markers.reference, "posts.txt"]]],
@@ -149,13 +190,14 @@ describe("optimize", () => {
       const parent = {};
       const expected = [
         ops.object,
+        "/folder/test.ori/",
         [
           "(posts)",
           [
             ops.getter,
             [
               ops.cache,
-              "test.ori/_refs/posts.txt",
+              "/folder/test.ori/_refs/posts.txt",
               [[ops.scope], [ops.literal, "posts.txt"]],
             ],
           ],
@@ -163,7 +205,7 @@ describe("optimize", () => {
       ];
       const globals = {};
       assertCodeEqual(
-        optimize(code, { cachePath: "test.ori", globals, parent }),
+        optimize(code, { cachePath: "/folder/test.ori", globals, parent }),
         expected,
       );
     });
@@ -233,9 +275,9 @@ describe("optimize", () => {
         [ops.literal, "passwd"],
       ]);
       const expected = [
-        ops.cache,
-        "test.ori/_refs//etc/passwd",
-        [[ops.rootDirectory], [ops.literal, "etc/"], [ops.literal, "passwd"]],
+        [ops.cache, "test.ori/_refs//", [ops.rootDirectory]],
+        [ops.literal, "etc/"],
+        [ops.literal, "passwd"],
       ];
       assertCodeEqual(optimize(code, { cachePath: "test.ori" }), expected);
     });
@@ -259,14 +301,13 @@ describe("optimize", () => {
       ]);
       const parent = {};
       const expected = [
-        ops.cache,
-        "test.ori/_refs/path/to/file",
         [
-          [ops.scope],
-          [ops.literal, "path/"],
-          [ops.literal, "to/"],
-          [ops.literal, "file"],
+          ops.cache,
+          "test.ori/_refs/path/",
+          [[ops.scope], [ops.literal, "path/"]],
         ],
+        [ops.literal, "to/"],
+        [ops.literal, "file"],
       ];
       assertCodeEqual(
         optimize(code, { cachePath: "test.ori", parent }),
@@ -284,9 +325,12 @@ describe("optimize", () => {
       const globals = {};
       const parent = {};
       const expected = [
-        ops.cache,
-        "test.ori/_refs/package.json/name",
-        [[ops.scope], [ops.literal, "package.json/"], [ops.literal, "name"]],
+        [
+          ops.cache,
+          "test.ori/_refs/package.json/",
+          [[ops.scope], [ops.literal, "package.json/"]],
+        ],
+        [ops.literal, "name"],
       ];
       assertCodeEqual(
         optimize(code, { cachePath: "test.ori", globals, parent }),
@@ -319,6 +363,7 @@ function assertCompile(expression, expected, mode = "shell") {
     typeof expression !== "string"
       ? expression
       : {
+          cachePath: "/folder/test.ori",
           text: expression,
           relativePath: "test.ori",
         };

package/test/compiler/parse.test.js

@@ -604,7 +604,7 @@ describe("Origami parser", () => {
         [ops.literal, "key"],
       ]);
       assertParse("callExpression", "{ a: 1, b: 2}/b", [
-        [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
+        [ops.object, null, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
         [ops.literal, "b"],
       ]);
       assertParse("callExpression", "files:foo/bar", [
@@ -897,12 +897,13 @@ Body`,
       assertParse("expression", "1", [ops.literal, 1]);
       assertParse("expression", "{ a: 1, b: 2 }", [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [ops.literal, 2]],
       ]);
       assertParse("expression", "serve { index.html: 'hello' }", [
         [markers.traverse, [markers.reference, "serve"]],
-        [ops.object, ["index.html", [ops.literal, "hello"]]],
+        [ops.object, null, ["index.html", [ops.literal, "hello"]]],
       ]);
       assertParse("expression", "fn =`x`", [
         [markers.traverse, [markers.reference, "fn"]],
@@ -991,6 +992,7 @@ Body`,
       }`,
         [
           ops.object,
+          null,
           [
             "index.html",
             [
@@ -1010,6 +1012,7 @@ Body`,
                 [markers.traverse, [markers.reference, "images"]],
                 [
                   ops.object,
+                  null,
                   [
                     "value",
                     [markers.traverse, [markers.reference, "thumbnail.js"]],
@@ -1253,27 +1256,32 @@ Body`,
 
   describe("objectLiteral", () => {
     test("basic objects", () => {
-      assertParse("objectLiteral", "{}", [ops.object]);
+      assertParse("objectLiteral", "{}", [ops.object, null]);
       assertParse("objectLiteral", "{ a: 1, b }", [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [markers.traverse, [markers.reference, "b"]]],
       ]);
       assertParse("objectLiteral", "{ sub: { a: 1 } }", [
         ops.object,
-        ["sub", [ops.object, ["a", [ops.literal, 1]]]],
+        null,
+        ["sub", [ops.object, null, ["a", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", "{ sub: { a/: 1 } }", [
         ops.object,
-        ["sub", [ops.object, ["a/", [ops.literal, 1]]]],
+        null,
+        ["sub", [ops.object, null, ["a/", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", `{ "a": 1, "b": 2 }`, [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [ops.literal, 2]],
       ]);
       assertParse("objectLiteral", "{ a = b, b = 2 }", [
         ops.object,
+        null,
         ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
         ["b", [ops.literal, 2]],
       ]);
@@ -1285,24 +1293,29 @@ Body`,
       }`,
         [
           ops.object,
+          null,
           ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
           ["b", [ops.literal, 2]],
         ],
       );
       assertParse("objectLiteral", "{ a: { b: 1 } }", [
         ops.object,
-        ["a", [ops.object, ["b", [ops.literal, 1]]]],
+        null,
+        ["a", [ops.object, null, ["b", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", "{ a: { b = 1 } }", [
         ops.object,
-        ["a", [ops.object, ["b", [ops.literal, 1]]]],
+        null,
+        ["a", [ops.object, null, ["b", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", "{ a: { b = fn() } }", [
         ops.object,
+        null,
         [
           "a",
           [
             ops.object,
+            null,
             [
               "b",
               [ops.getter, [[markers.traverse, [markers.reference, "fn"]]]],
@@ -1312,6 +1325,7 @@ Body`,
       ]);
       assertParse("objectLiteral", "{ x = fn.js('a') }", [
         ops.object,
+        null,
         [
           "x",
           [
@@ -1326,10 +1340,12 @@ Body`,
 
       assertParse("objectLiteral", "{ (a): 1 }", [
         ops.object,
+        null,
         ["(a)", [ops.literal, 1]],
       ]);
       assertParse("objectLiteral", "{ <path/to/file.txt> }", [
         ops.object,
+        null,
         [
           "file.txt",
           [
@@ -1350,15 +1366,24 @@ Body`,
       assertParse("objectLiteral", "{ a: 1, ...more, c: a }", [
         [
           ops.object,
+          null,
           ["a", [ops.literal, 1]],
           ["c", [markers.traverse, [markers.reference, "a"]]],
           [
             "_result",
             [
               ops.merge,
-              [ops.object, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
+              [
+                ops.object,
+                null,
+                ["a", [ops.getter, [[ops.inherited, 1], "a"]]],
+              ],
               [markers.traverse, [markers.reference, "more"]],
-              [ops.object, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
+              [
+                ops.object,
+                null,
+                ["c", [ops.getter, [[ops.inherited, 1], "c"]]],
+              ],
             ],
           ],
         ],
@@ -1366,6 +1391,7 @@ Body`,
       ]);
       assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [ops.literal, 2]],
       ]);
@@ -1374,6 +1400,7 @@ Body`,
     test("computed property keys", () => {
       assertParse("objectLiteral", "{ [key]: value }", [
         ops.object,
+        null,
         [
           [markers.traverse, [markers.reference, "key"]],
           [markers.traverse, [markers.reference, "value"]],
@@ -1816,6 +1843,7 @@ title: Title goes here
 Body text`,
       [
         ops.object,
+        null,
         ["title", [ops.literal, "Title goes here"]],
         ["_body", [ops.templateIndent, [ops.literal, ["Body text"]]]],
       ],
@@ -1835,6 +1863,7 @@ Body text`,
 `,
       [
         ops.object,
+        null,
         ["title", [ops.literal, "Title"]],
         [
           "_body",

package/test/handlers/epub_handler.test.js

@@ -0,0 +1,27 @@
+import Zip from "adm-zip";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import epub_handler from "../../src/handlers/epub_handler.js";
+
+describe("EPUB handler", () => {
+  test("ensures mimetype file comes first", async () => {
+    const tree = {
+      EPUB: {
+        "index.xhtml": "This is where the book content goes",
+      },
+      "META-INF": {
+        "container.xml": "This is where the metadata goes",
+      },
+      mimetype: "application/epub+zip",
+    };
+    const buffer = await epub_handler.pack(tree);
+    const unzipped = new Zip(buffer);
+    const entries = unzipped.getEntries();
+    const entryNames = entries.map((entry) => entry.entryName);
+    assert.deepEqual(entryNames, [
+      "mimetype",
+      "EPUB/index.xhtml",
+      "META-INF/container.xml",
+    ]);
+  });
+});

package/test/handlers/zip_handler.test.js

@@ -0,0 +1,45 @@
+import { Tree } from "@weborigami/async-tree";
+import Zip from "adm-zip";
+import assert from "node:assert";
+import fs from "node:fs/promises";
+import { describe, test } from "node:test";
+import zip_handler from "../../src/handlers/zip_handler.js";
+
+describe("ZIP handler", () => {
+  test("creates a ZIP file as Buffer", async () => {
+    const tree = {
+      "ReadMe.md": "This is a ReadMe file.",
+      sub: {
+        "file.txt": "This is a text file in a subfolder.",
+      },
+    };
+    const buffer = await zip_handler.pack(tree);
+    const unzipped = new Zip(buffer);
+    const entries = unzipped.getEntries();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].entryName, "ReadMe.md");
+    assert.equal(
+      entries[0].getData().toString("utf8"),
+      "This is a ReadMe file.",
+    );
+    assert.equal(entries[1].entryName, "sub/file.txt");
+    assert.equal(
+      entries[1].getData().toString("utf8"),
+      "This is a text file in a subfolder.",
+    );
+  });
+
+  test("reads a ZIP file", async () => {
+    const fixturePath = new URL("fixtures/test.zip", import.meta.url);
+    const buffer = await fs.readFile(fixturePath);
+    const tree = await zip_handler.unpack(buffer);
+    const plain = await Tree.plain(tree);
+    assert.deepEqual(Object.keys(plain), ["ReadMe.md", "sub"]);
+    assert.deepEqual(Object.keys(plain.sub), ["file.txt"]);
+    assert.equal(String(plain["ReadMe.md"]), "This is a ReadMe file.\n");
+    assert.equal(
+      String(plain.sub["file.txt"]),
+      "This is a text file in a subfolder.\n",
+    );
+  });
+});

package/test/runtime/AsyncCacheTransform.test.js

@@ -41,7 +41,8 @@ describe("AsyncCacheTransform", () => {
       ],
     ]);
 
-    assert.deepEqual(await Tree.entries(calcs), [
+    const entries = await Tree.entries(calcs);
+    assert.deepEqual(entries, [
       ["a", 8],
       ["b", 4],
       ["c", 3],
@@ -55,11 +56,13 @@ describe("AsyncCacheTransform", () => {
 
     // Replace formula for a
     // { a = 3 * b, b = c + 1, c = 3 }
-    data.set("a", async () => {
+    await data.set("a", async () => {
       log.push("a");
       const b = await calcs.get("b");
       return 3 * b;
     });
+    // Manually trigger cache invalidation
+    data.onValueChange("a");
     log = [];
     const a2 = await calcs.get("a");
     assert.strictEqual(a2, 12);
@@ -67,11 +70,12 @@ describe("AsyncCacheTransform", () => {
 
     // Replace formula for b
     // { a = 3 * b, b = c + 10, c = 3 }
-    data.set("b", async () => {
+    await data.set("b", async () => {
       log.push("b");
       const c = await calcs.get("c");
       return c + 10;
     });
+    data.onValueChange("b");
     log = [];
     const a3 = await calcs.get("a");
     assert.strictEqual(a3, 39);
@@ -79,10 +83,11 @@ describe("AsyncCacheTransform", () => {
 
     // Replace value of c
     // { a = 3 * b, b = c + 10, c = 100 }
-    data.set("c", async () => {
+    await data.set("c", async () => {
       log.push("c");
       return 100;
     });
+    data.onValueChange("c");
     log = [];
     const a4 = await calcs.get("a");
     assert.strictEqual(a4, 330);

package/test/runtime/SyncCacheTransform.test.js

@@ -62,6 +62,8 @@ describe("SyncCacheTransform", () => {
       const b = calcs.get("b");
       return 3 * b;
     });
+    // Manually trigger cache invalidation
+    data.onValueChange("a");
     log = [];
     const a2 = calcs.get("a");
     assert.strictEqual(a2, 12);
@@ -74,6 +76,7 @@ describe("SyncCacheTransform", () => {
       const c = calcs.get("c");
       return c + 10;
     });
+    data.onValueChange("b");
     log = [];
     const a3 = calcs.get("a");
     assert.strictEqual(a3, 39);
@@ -85,6 +88,7 @@ describe("SyncCacheTransform", () => {
       log.push("c");
       return 100;
     });
+    data.onValueChange("c");
     log = [];
     const a4 = calcs.get("a");
     assert.strictEqual(a4, 330);

package/test/runtime/asyncCalcs.js

@@ -1,13 +1,35 @@
-import { AsyncMap, SyncMap } from "@weborigami/async-tree";
+import { AsyncMap } from "@weborigami/async-tree";
 import AsyncCacheTransform from "../../src/runtime/AsyncCacheTransform.js";
-import SyncCacheTransform from "../../src/runtime/SyncCacheTransform.js";
 
 export default function asyncCalcs(iterable) {
-  const data = new (SyncCacheTransform(SyncMap))(iterable);
+  const data = new (AsyncCacheTransform(AsyncDataMap))(new Map(iterable));
   const calcs = new (AsyncCacheTransform(AsyncResultsMap))(data);
   return { calcs, data };
 }
 
+class AsyncDataMap extends AsyncMap {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+
+  async delete(key) {
+    return this.source.delete(key);
+  }
+
+  async get(key) {
+    return this.source.get(key);
+  }
+
+  async *keys() {
+    yield* this.source.keys();
+  }
+
+  async set(key, value) {
+    return this.source.set(key, value);
+  }
+}
+
 class AsyncResultsMap extends AsyncMap {
   constructor(source) {
     super();
@@ -15,7 +37,7 @@ class AsyncResultsMap extends AsyncMap {
   }
 
   async get(key) {
-    let value = this.source.get(key);
+    let value = await this.source.get(key);
     if (typeof value === "function") {
       value = await value();
     }

package/test/runtime/errors.test.js

@@ -188,7 +188,7 @@ evaluating: \x1B[31mposts.md\x1B[0m
         `(post1/totle).toUpperCase()`,
         `ReferenceError: Tried to get a property of something that doesn't exist.
 This path returned undefined: post1/totle
-evaluating: \x1B[31mpost1/totle\x1B[0m`,
+evaluating: \x1B[31m(post1/totle)\x1B[0m`,
         { parent },
       );
     });
@@ -238,7 +238,7 @@ evaluating: \x1B[31msup/\x1B[0m`,
 Tried to traverse path:  map/1/a
 Stopped unexpectedly at: 1/
 Slash-separated keys are searched as strings. Here there's no string "1" key, but there is a number 1 key.
-To get the value for that number key, use parentheses: map/(1)
+To get the value for that number key, use parentheses: map/(1)/a
 evaluating: \x1B[31m1/\x1B[0m`,
         { parent },
       );
@@ -250,8 +250,8 @@ evaluating: \x1B[31m1/\x1B[0m`,
       });
       await assertError(
         `file.foo/bar`,
-        `TraverseError: A path hit binary data that can't be unpacked.
-Tried to traverse path:  file.foo/bar
+        `TraverseError: A path tried to unpack data but there's no unpack function.
+Tried to traverse path:  file.foo/
 Stopped unexpectedly at: file.foo/
 The value couldn't be unpacked because no file extension handler is registered for ".foo".
 evaluating: \x1B[31mfile.foo/\x1B[0m`,