@weborigami/language 0.6.16 → 0.7.0-beta.1

package/test/compiler/optimize.test.js

@@ -46,15 +46,7 @@ describe("optimize", () => {
   });
 
   test("resolve deeper context references", () => {
-    // Compilation of `{ a: 1, more: { a } }`
-    const code = createCode([
-      ops.object,
-      ["a", [ops.literal, 1]],
-      [
-        "more",
-        [ops.object, ["a", [markers.traverse, [markers.reference, "a"]]]],
-      ],
-    ]);
+    const expression = `{ a: 1, more: { a } }`;
     const expected = [
       ops.object,
       ["a", 1],
@@ -72,7 +64,7 @@ describe("optimize", () => {
         ],
       ],
     ];
-    assertCodeEqual(optimize(code), expected);
+    assertCompile(expression, expected);
   });
 
   test("when defining a property, avoid recursive references", () => {
@@ -103,7 +95,7 @@ describe("optimize", () => {
     assertCompile(expression, expected, "shell");
   });
 
-  describe("resolve reference", () => {
+  describe.only("resolve reference", () => {
     test("external reference", () => {
       // Compilation of `folder` where folder isn't a variable
       const code = createCode([
@@ -113,35 +105,36 @@ describe("optimize", () => {
       const parent = {};
       const expected = [
         ops.cache,
-        {},
-        "folder",
-        [
-          [ops.scope, parent],
-          [ops.literal, "folder"],
-        ],
+        "test.ori/_refs/folder",
+        [[ops.scope], [ops.literal, "folder"]],
       ];
       const globals = {};
-      assertCodeEqual(optimize(code, { globals, parent }), expected);
+      assertCodeEqual(
+        optimize(code, { cachePath: "test.ori", globals, parent }),
+        expected,
+      );
     });
 
-    test("external reference", () => {
-      // Compilation of `index.html` where `index` isn't a variable
+    test("external reference with implied unpack", () => {
+      // Compilation of `greet.ori("world")`
       const code = createCode([
-        markers.traverse,
-        [markers.reference, "index.html"],
+        [markers.traverse, [markers.reference, "greet.ori"]],
+        [ops.literal, "world"],
       ]);
       const parent = {};
       const expected = [
-        ops.cache,
-        {},
-        "index.html",
         [
-          [ops.scope, parent],
-          [ops.literal, "index.html"],
+          ops.cache,
+          "test.ori/_refs/greet.ori/",
+          [ops.unpack, [[ops.scope], [ops.literal, "greet.ori"]]],
         ],
+        "world",
       ];
       const globals = {};
-      assertCodeEqual(optimize(code, { globals, parent }), expected);
+      assertCodeEqual(
+        optimize(code, { cachePath: "test.ori", globals, parent }),
+        expected,
+      );
     });
 
     test("external reference inside object with matching key", () => {
@@ -162,18 +155,17 @@ describe("optimize", () => {
             ops.getter,
             [
               ops.cache,
-              {},
-              "posts.txt",
-              [
-                [ops.scope, parent],
-                [ops.literal, "posts.txt"],
-              ],
+              "test.ori/_refs/posts.txt",
+              [[ops.scope], [ops.literal, "posts.txt"]],
             ],
           ],
         ],
       ];
       const globals = {};
-      assertCodeEqual(optimize(code, { globals, parent }), expected);
+      assertCodeEqual(
+        optimize(code, { cachePath: "test.ori", globals, parent }),
+        expected,
+      );
     });
 
     test("global reference", () => {
@@ -233,17 +225,26 @@ describe("optimize", () => {
     });
 
     test("root directory", () => {
-      // Compilation of `</>`
-      const code = createCode([markers.traverse, [markers.external, "/"]]);
-      const expected = [ops.cache, {}, "/", [ops.rootDirectory]];
-      assertCodeEqual(optimize(code), expected);
+      // Compilation of `</etc/passwd>`
+      const code = createCode([
+        markers.traverse,
+        [markers.external, "/"],
+        [ops.literal, "etc/"],
+        [ops.literal, "passwd"],
+      ]);
+      const expected = [
+        ops.cache,
+        "test.ori/_refs//etc/passwd",
+        [[ops.rootDirectory], [ops.literal, "etc/"], [ops.literal, "passwd"]],
+      ];
+      assertCodeEqual(optimize(code, { cachePath: "test.ori" }), expected);
     });
 
     test("home directory", () => {
       // Compilation of `<~>`
       const code = createCode([markers.traverse, [ops.homeDirectory]]);
-      const expected = [ops.cache, {}, "~", [ops.homeDirectory]];
-      assertCodeEqual(optimize(code), expected);
+      const expected = [ops.cache, "test.ori/_refs/~", [ops.homeDirectory]];
+      assertCodeEqual(optimize(code, { cachePath: "test.ori" }), expected);
     });
   });
 
@@ -259,16 +260,18 @@ describe("optimize", () => {
       const parent = {};
       const expected = [
         ops.cache,
-        {},
-        "path/to/file",
+        "test.ori/_refs/path/to/file",
         [
-          [ops.scope, parent],
+          [ops.scope],
           [ops.literal, "path/"],
           [ops.literal, "to/"],
           [ops.literal, "file"],
         ],
       ];
-      assertCodeEqual(optimize(code, { parent }), expected);
+      assertCodeEqual(
+        optimize(code, { cachePath: "test.ori", parent }),
+        expected,
+      );
     });
 
     test("implicit external path", () => {
@@ -282,15 +285,13 @@ describe("optimize", () => {
       const parent = {};
       const expected = [
         ops.cache,
-        {},
-        "package.json/name",
-        [
-          [ops.scope, parent],
-          [ops.literal, "package.json/"],
-          [ops.literal, "name"],
-        ],
+        "test.ori/_refs/package.json/name",
+        [[ops.scope], [ops.literal, "package.json/"], [ops.literal, "name"]],
       ];
-      assertCodeEqual(optimize(code, { globals, parent }), expected);
+      assertCodeEqual(
+        optimize(code, { cachePath: "test.ori", globals, parent }),
+        expected,
+      );
     });
 
     test("local path", () => {
@@ -314,9 +315,16 @@ describe("optimize", () => {
 });
 
 function assertCompile(expression, expected, mode = "shell") {
+  const source =
+    typeof expression !== "string"
+      ? expression
+      : {
+          text: expression,
+          relativePath: "test.ori",
+        };
   const parent = new SyncMap();
   const globals = {};
-  const fn = compile.expression(expression, { globals, mode, parent });
+  const fn = compile.expression(source, { globals, mode, parent });
   const actual = fn.code;
   assertCodeLocations(actual);
   assertCodeEqual(actual, expected);

package/test/handlers/ori_handler.test.js

@@ -3,9 +3,11 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import ori_handler from "../../src/handlers/ori_handler.js";
 import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
+import { cachePathSymbol } from "../../src/runtime/symbols.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
 const fixtures = new OrigamiFileMap(fixturesUrl);
+await fixtures.initializeGlobals();
 
 describe(".ori handler", async () => {
   test("loads a string expression", async () => {
@@ -38,16 +40,18 @@ describe(".ori handler", async () => {
     const tree = await ori_handler.unpack(source);
     assert.deepEqual(
       await Tree.traverse(tree, "public", "message"),
-      "Hello, world!"
+      "Hello, world!",
     );
   });
 
   test("loads an object containing an object shorthand", async () => {
-    const assets = new ObjectMap({});
+    const assets = new ObjectMap({ a: 1, b: 2 });
     const parent = new ObjectMap({ assets });
     const source = `{ assets }`;
     const object = await ori_handler.unpack(source, { parent });
-    assert.equal(object.assets, assets);
+    const expectedValues = Array.from(assets.values());
+    const actualValues = Array.from(object.assets.values());
+    assert.deepEqual(actualValues, expectedValues);
   });
 
   test("loads a template literal", async () => {
@@ -84,4 +88,19 @@ describe(".ori handler", async () => {
     const indexHtml = await tree["index.html"];
     assert.equal(indexHtml, "Hello, world!");
   });
+
+  test("enables caching for top-level object", async () => {
+    const parent = new ObjectMap({});
+    const source = `{
+      message = "Hello"
+    }`;
+    const object = await ori_handler.unpack(source, {
+      key: "test.ori",
+      parent,
+    });
+    assert.equal(object[cachePathSymbol], "test.ori/");
+    assert.deepEqual(await Tree.plain(object), {
+      message: "Hello",
+    });
+  });
 });

package/test/handlers/oridocument_handler.test.js

@@ -22,7 +22,7 @@ describe("Origami document handler", () => {
 
   test("Argument to template document available as underscore", async () => {
     const text = "<h1>${ _ }</h1>";
-    const fn = await oridocument_handler.unpack(text);
+    const fn = await oridocument_handler.unpack(text, { key: "test.ori.html" });
     const result = await fn("Home");
     assert.equal(result, "<h1>Home</h1>");
   });

package/test/protocols/https.test.js

@@ -0,0 +1,19 @@
+import assert from "node:assert";
+import { beforeEach, describe, test } from "node:test";
+import https from "../../src/protocols/https.js";
+import systemCache from "../../src/runtime/systemCache.js";
+
+describe("https", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
+  test("caches fetched resources", async () => {
+    const result1 = await https("example.com", {});
+    assert(systemCache.has("https://example.com"));
+    const text = new TextDecoder().decode(result1);
+    assert(text.includes("Example Domain"));
+    const result2 = await https("example.com", {});
+    assert.strictEqual(result1, result2);
+  });
+});

package/test/protocols/package.test.js

@@ -1,16 +1,21 @@
 import assert from "node:assert";
 import process from "node:process";
 import { describe, test } from "node:test";
+import coreGlobals from "../../src/project/coreGlobals.js";
 import projectRootFromPath from "../../src/project/projectRootFromPath.js";
 import packageProtocol from "../../src/protocols/package.js";
 
 describe("package: protocol", () => {
   test("returns a package's main export(s)", async () => {
     // Reproduce the type of evaluation context object the runtime would create
-    const projectRoot = await projectRootFromPath(process.cwd());
-    const state = { parent: projectRoot };
+    const parent = await projectRootFromPath(process.cwd());
+    const globals = await coreGlobals();
+    /** @type {any} */ (parent).globals = globals;
+    const state = { globals, parent };
 
     const result = await packageProtocol("@weborigami", "async-tree", state);
+
+    // Try a method from the package
     const { toString } = result;
     assert.equal(toString(123), "123");
   });

package/test/runtime/AsyncCacheTransform.test.js

@@ -0,0 +1,91 @@
+import assert from "node:assert";
+import { beforeEach, describe, test } from "node:test";
+import systemCache from "../../src/runtime/systemCache.js";
+
+// We test AsyncCacheTransform via asyncCalcs since it's a fairly small
+// application of the transform.
+import { Tree } from "@weborigami/async-tree";
+import asyncCalcs from "./asyncCalcs.js";
+
+describe("AsyncCacheTransform", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
+  test("caches values and records dependencies", async () => {
+    // { a = 2 * b, b = c + 1, c = 3 }
+    let log = [];
+    const { calcs, data } = asyncCalcs([
+      [
+        "a",
+        async () => {
+          log.push("a");
+          const b = await calcs.get("b");
+          return 2 * b;
+        },
+      ],
+      [
+        "b",
+        async () => {
+          log.push("b");
+          const c = await calcs.get("c");
+          return c + 1;
+        },
+      ],
+      [
+        "c",
+        async () => {
+          log.push("c");
+          return 3;
+        },
+      ],
+    ]);
+
+    assert.deepEqual(await Tree.entries(calcs), [
+      ["a", 8],
+      ["b", 4],
+      ["c", 3],
+    ]);
+    assert.deepEqual(log, ["a", "b", "c"]);
+
+    log = [];
+    const a1 = await calcs.get("a");
+    assert.strictEqual(a1, 8);
+    assert.deepEqual(log, []); // a is cached, no new calcs
+
+    // Replace formula for a
+    // { a = 3 * b, b = c + 1, c = 3 }
+    data.set("a", async () => {
+      log.push("a");
+      const b = await calcs.get("b");
+      return 3 * b;
+    });
+    log = [];
+    const a2 = await calcs.get("a");
+    assert.strictEqual(a2, 12);
+    assert.deepEqual(log, ["a"]); // recalc only a
+
+    // Replace formula for b
+    // { a = 3 * b, b = c + 10, c = 3 }
+    data.set("b", async () => {
+      log.push("b");
+      const c = await calcs.get("c");
+      return c + 10;
+    });
+    log = [];
+    const a3 = await calcs.get("a");
+    assert.strictEqual(a3, 39);
+    assert.deepEqual(log, ["a", "b"]); // recalc a and b
+
+    // Replace value of c
+    // { a = 3 * b, b = c + 10, c = 100 }
+    data.set("c", async () => {
+      log.push("c");
+      return 100;
+    });
+    log = [];
+    const a4 = await calcs.get("a");
+    assert.strictEqual(a4, 330);
+    assert.deepEqual(log, ["a", "b", "c"]); // recalc all
+  });
+});

package/test/runtime/OrigamiFileMap.test.js

@@ -1,40 +1,43 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
 import path from "node:path";
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
 import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
-const tempDirectory = path.join(dirname, "fixtures/temp/OrigamiFileMap");
+const tempDirectory = path.join(dirname, "fixtures/temp");
 
 describe("OrigamiFileMap", () => {
-  test.skip("can watch its folder for changes", { timeout: 2000 }, async () => {
-    createTempDirectory();
+  let tempFiles;
 
-    const tempFiles = new OrigamiFileMap(tempDirectory);
-    const changedFileName = await new Promise(async (resolve) => {
+  beforeEach(() => {
+    // Remove any existing files or directories inside the temp directory so
+    // tests start from a clean slate. Use force so this is safe if the
+    // directory doesn't exist.
+    fs.rmSync(tempDirectory, { force: true, recursive: true });
+    fs.mkdirSync(tempDirectory, { recursive: true });
+    tempFiles = new OrigamiFileMap(tempDirectory);
+  });
+
+  afterEach(() => {
+    // HACK: should removeEventListener, which should stop watching
+    tempFiles.unwatch();
+    fs.rmSync(tempDirectory, { force: true, recursive: true });
+  });
+
+  test("can watch its folder for changes", { timeout: 2000 }, async () => {
+    const changedFilePath = await new Promise(async (resolve) => {
       tempFiles.addEventListener("change", (event) => {
-        resolve(/** @type {any} */ (event).options.key);
+        resolve(/** @type {any} */ (event).options.filePath);
       });
+      await tempFiles.watch();
       tempFiles.set(
-        "foo.txt",
-        "This file is left over from testing and can be removed."
+        "temp.txt",
+        "This file is left over from testing and can be removed.",
       );
     });
-    removeTempDirectory();
-    assert.equal(changedFileName, "foo.txt");
+
+    assert.equal(path.basename(changedFilePath), "temp.txt");
   });
 });
-
-function createTempDirectory() {
-  // Remove any existing files or directories inside the temp directory so
-  // tests start from a clean slate. Use force so this is safe if the
-  // directory doesn't exist.
-  fs.rmSync(tempDirectory, { force: true, recursive: true });
-  fs.mkdirSync(tempDirectory, { recursive: true });
-}
-
-function removeTempDirectory() {
-  fs.rmSync(tempDirectory, { force: true, recursive: true });
-}

package/test/runtime/ScopeMap.test.js

@@ -0,0 +1,49 @@
+import { ObjectMap } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ScopeMap from "../../src/runtime/ScopeMap.js";
+import { cachePathSymbol } from "../../src/runtime/symbols.js";
+import SyncCacheTransform from "../../src/runtime/SyncCacheTransform.js";
+import systemCache from "../../src/runtime/systemCache.js";
+
+describe("scope", () => {
+  test("gets the first defined value from the scope trees", async () => {
+    class SyncCacheObjectMap extends SyncCacheTransform(ObjectMap) {}
+
+    /** @type {any} */
+    const outer = new SyncCacheObjectMap({
+      a: 1,
+      b: 2,
+    });
+    outer[cachePathSymbol] = "outer";
+
+    /** @type {any} */
+    const inner = new SyncCacheObjectMap({
+      a: 3,
+    });
+    inner[cachePathSymbol] = "outer/inner";
+
+    inner.parent = outer;
+    const innerScope = new ScopeMap(inner);
+
+    // Inner tree has precedence
+    const a = systemCache.getOrInsertComputed("test/a", () =>
+      innerScope.get("a"),
+    );
+    assert.equal(a, 3);
+
+    // If tree doesn't have value, finds value from parent
+    const b = systemCache.getOrInsertComputed("test/b", () =>
+      innerScope.get("b"),
+    );
+    assert.equal(b, 2);
+
+    const c = systemCache.getOrInsertComputed("test/c", () =>
+      innerScope.get("c"),
+    );
+    assert.equal(c, undefined);
+
+    assert.deepEqual([...innerScope.keys()], ["a", "b"]);
+    assert.deepEqual(/** @type {any} */ (innerScope).trees, [inner, outer]);
+  });
+});

package/test/runtime/SyncCacheTransform.test.js

@@ -0,0 +1,93 @@
+import assert from "node:assert";
+import { beforeEach, describe, test } from "node:test";
+import systemCache from "../../src/runtime/systemCache.js";
+
+// We test SyncCacheTransform via syncCalcs since it's a fairly small
+// application of the transform.
+import syncCalcs from "./syncCalcs.js";
+
+describe("SyncCacheTransform", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
+  test("caches values and records dependencies", () => {
+    // { a = 2 * b, b = c + 1, c = 3 }
+    let log = [];
+    const { calcs, data } = syncCalcs([
+      [
+        "a",
+        () => {
+          log.push("a");
+          const b = calcs.get("b");
+          return 2 * b;
+        },
+      ],
+      [
+        "b",
+        () => {
+          log.push("b");
+          const c = calcs.get("c");
+          return c + 1;
+        },
+      ],
+      [
+        "c",
+        () => {
+          log.push("c");
+          return 3;
+        },
+      ],
+    ]);
+
+    assert.deepEqual(
+      [...calcs.entries()],
+      [
+        ["a", 8],
+        ["b", 4],
+        ["c", 3],
+      ],
+    );
+    assert.deepEqual(log, ["a", "b", "c"]);
+
+    log = [];
+    const a1 = calcs.get("a");
+    assert.strictEqual(a1, 8);
+    assert.deepEqual(log, []); // a is cached, no new calcs
+
+    // Replace formula for a
+    // { a = 3 * b, b = c + 1, c = 3 }
+    data.set("a", () => {
+      log.push("a");
+      const b = calcs.get("b");
+      return 3 * b;
+    });
+    log = [];
+    const a2 = calcs.get("a");
+    assert.strictEqual(a2, 12);
+    assert.deepEqual(log, ["a"]); // recalc only a
+
+    // Replace formula for b
+    // { a = 3 * b, b = c + 10, c = 3 }
+    data.set("b", () => {
+      log.push("b");
+      const c = calcs.get("c");
+      return c + 10;
+    });
+    log = [];
+    const a3 = calcs.get("a");
+    assert.strictEqual(a3, 39);
+    assert.deepEqual(log, ["a", "b"]); // recalc a and b
+
+    // Replace value of c
+    // { a = 3 * b, b = c + 10, c = 100 }
+    data.set("c", () => {
+      log.push("c");
+      return 100;
+    });
+    log = [];
+    const a4 = calcs.get("a");
+    assert.strictEqual(a4, 330);
+    assert.deepEqual(log, ["a", "b", "c"]); // recalc all
+  });
+});