@weborigami/language 0.6.17 → 0.7.0-beta.1

package/test/runtime/SystemCacheMap.test.js

@@ -0,0 +1,239 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import SystemCacheMap from "../../src/runtime/SystemCacheMap.js";
+import volatile from "../../src/runtime/volatile.js";
+
+describe("SystemCacheMap", () => {
+  test("getOrInsertComputed tracks sync dependencies", async () => {
+    const cache = new SystemCacheMap();
+    let log;
+
+    // Create cache entries for
+    // { a = b + 1, b = 2 }
+    let getB = () =>
+      cache.getOrInsertComputed("b", () => {
+        log.push("b");
+        return 2;
+      });
+    let getA = () =>
+      cache.getOrInsertComputed("a", () => {
+        log.push("a");
+        const b = getB();
+        return b + 1;
+      });
+
+    log = [];
+    const a1 = getA();
+    assert.strictEqual(a1, 3);
+    assert.deepEqual(log, ["a", "b"]);
+    assert.deepEqual(cacheEntries(cache), [
+      ["a", { value: 3, upstreams: ["b"] }],
+      ["b", { value: 2, downstreams: ["a"] }],
+    ]);
+
+    log = [];
+    const a2 = getA();
+    assert.strictEqual(a2, 3);
+    assert.deepEqual(log, []); // no recalculation
+
+    // Delete a
+    cache.delete("a");
+    assert.deepEqual(cacheEntries(cache), [["b", { value: 2 }]]);
+  });
+
+  test("getOrInsertComputedAsync tracks async dependencies", async () => {
+    const cache = new SystemCacheMap();
+    let log;
+
+    // Create cache entries for
+    // { a = 2 * b, b = c + 1, c = 3 }
+    let getC = async () =>
+      await cache.getOrInsertComputedAsync("c", async () => {
+        log.push("c");
+        return 3;
+      });
+    let getB = async () =>
+      await cache.getOrInsertComputedAsync("b", async () => {
+        log.push("b");
+        const c = await getC();
+        return c + 1;
+      });
+    let getA = async () =>
+      await cache.getOrInsertComputedAsync("a", async () => {
+        log.push("a");
+        const b = await getB();
+        return 2 * b;
+      });
+
+    // Initial read of `a` populates cache
+    log = [];
+    const a1 = await getA();
+    assert.strictEqual(a1, 8);
+    assert.deepEqual(log, ["a", "b", "c"]);
+    assert.deepEqual(cacheEntries(cache), [
+      ["a", { value: 8, upstreams: ["b"] }],
+      ["b", { value: 4, downstreams: ["a"], upstreams: ["c"] }],
+      ["c", { value: 3, downstreams: ["b"] }],
+    ]);
+
+    // Subsequent read of `a` hits cache
+    log = [];
+    const a2 = await getA();
+    assert.strictEqual(a2, 8);
+    assert.deepEqual(log, []); // no recalculation
+
+    // Delete a
+    cache.delete("a");
+    assert.deepEqual(cacheEntries(cache), [
+      ["b", { value: 4, upstreams: ["c"] }],
+      ["c", { value: 3, downstreams: ["b"] }],
+    ]);
+
+    // Replace formula for a
+    // { a = 3 * b, b = c + 1, c = 3 }
+    getA = async () =>
+      await cache.getOrInsertComputedAsync("a", async () => {
+        log.push("a");
+        const b = await getB();
+        return 3 * b;
+      });
+    log = [];
+    const a3 = await getA();
+    assert.strictEqual(a3, 12);
+    assert.deepEqual(log, ["a"]); // recalc only a
+
+    // Delete b, confirm it's removed as both upstream and downstream
+    cache.delete("b");
+    assert.deepEqual(cacheEntries(cache), [["c", { value: 3 }]]);
+
+    // Replace formula for b
+    // { a = 3 * b, b = c + 10, c = 3 }
+    getB = async () =>
+      await cache.getOrInsertComputedAsync("b", async () => {
+        log.push("b");
+        const c = await getC();
+        return c + 10;
+      });
+    log = [];
+    const a4 = await getA();
+    assert.strictEqual(a4, 39);
+    assert.deepEqual(log, ["a", "b"]); // recalc a and b
+
+    // Replace formula for c
+    // { a = 3 * b, b = c + 10, c = 100 }
+    getC = async () =>
+      await cache.getOrInsertComputedAsync("c", async () => {
+        log.push("c");
+        return 100;
+      });
+    cache.delete("c");
+    log = [];
+    const a5 = await getA();
+    assert.strictEqual(a5, 330);
+    assert.deepEqual(log, ["a", "b", "c"]); // recalc all
+  });
+
+  test("async function can track sync dependency", async () => {
+    const cache = new SystemCacheMap();
+
+    // Create cache entries for
+    // { a = b + 1, b = 2 }
+    const getB = () =>
+      cache.getOrInsertComputed("b", () => {
+        return 2;
+      });
+    const getA = async () =>
+      cache.getOrInsertComputedAsync("a", async () => {
+        const b = getB();
+        return b + 1;
+      });
+
+    const a1 = await getA();
+    assert.strictEqual(a1, 3);
+  });
+
+  test("sync function can't have async dependency", async () => {
+    const cache = new SystemCacheMap();
+
+    // Create cache entries for
+    // { a = b, b = 1 }
+    const getB = async () =>
+      await cache.getOrInsertComputedAsync("b", async () => {
+        return 1;
+      });
+    const getA = () => cache.getOrInsertComputed("a", () => getB());
+
+    // a is sync but b is async
+    await assert.rejects(getA);
+  });
+
+  test("implicit dependency of child path on parent path", async () => {
+    const cache = new SystemCacheMap();
+
+    // Create cache entries
+    // parent = 1, parent/child = 2, other = 3
+    const getParent = () => cache.getOrInsertComputed("parent", () => 1);
+    cache.getOrInsertComputed("parent/child", () => {
+      // Force access of parent, no explicit dependency should be recorded
+      getParent();
+      return 2;
+    });
+    cache.getOrInsertComputed("other", () => 3);
+
+    assert.deepEqual(cacheEntries(cache), [
+      ["parent/child", { value: 2 }],
+      ["parent", { value: 1 }],
+      ["other", { value: 3 }],
+    ]);
+
+    // Deleting parent implicitly deletes all children
+    cache.delete("parent");
+    assert.deepEqual(cacheEntries(cache), [["other", { value: 3 }]]);
+  });
+
+  test("sync volatile values are not cached", async () => {
+    const cache = new SystemCacheMap();
+    let count = 0;
+    const getCount = () =>
+      cache.getOrInsertComputed("count", () => volatile(count++));
+
+    const first = getCount();
+    const second = getCount();
+    assert.strictEqual(Number(first), 0);
+    assert.strictEqual(Number(second), 1);
+    assert.strictEqual(count, 2); // computeFn ran twice, value not cached
+  });
+
+  test("async volatile values are not cached", async () => {
+    const cache = new SystemCacheMap();
+    let count = 0;
+    const getCount = () =>
+      cache.getOrInsertComputedAsync("count", async () => volatile(count++));
+
+    const first = await getCount();
+    const second = await getCount();
+    assert.strictEqual(Number(first), 0);
+    assert.strictEqual(Number(second), 1);
+    assert.strictEqual(count, 2); // computeFn ran twice, value not cached
+  });
+});
+
+export function cacheEntries(cache) {
+  const entries = [...cache.entries()];
+  return entries.map(([key, entry]) => [key, cacheEntry(entry)]);
+}
+
+export function cacheEntry(entry) {
+  const { downstreams, value } = entry;
+
+  const result = { value };
+  if (downstreams?.size > 0) {
+    result.downstreams = [...downstreams];
+  }
+
+  if (entry.upstreams?.size > 0) {
+    result.upstreams = [...entry.upstreams];
+  }
+
+  return result;
+}

package/test/runtime/asyncCalcs.js

@@ -0,0 +1,28 @@
+import { AsyncMap, SyncMap } 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 calcs = new (AsyncCacheTransform(AsyncResultsMap))(data);
+  return { calcs, data };
+}
+
+class AsyncResultsMap extends AsyncMap {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+
+  async get(key) {
+    let value = this.source.get(key);
+    if (typeof value === "function") {
+      value = await value();
+    }
+    return value;
+  }
+
+  async *keys() {
+    yield* this.source.keys();
+  }
+}

package/test/runtime/enableValueCaching.test.js

@@ -0,0 +1,55 @@
+import assert from "node:assert";
+import { beforeEach, describe, test } from "node:test";
+import enableValueCaching from "../../src/runtime/enableValueCaching.js";
+import { cachePathSymbol } from "../../src/runtime/symbols.js";
+import systemCache from "../../src/runtime/systemCache.js";
+
+describe("enableValueCaching", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
+  test("leaves primitive values as is", () => {
+    const value1 = enableValueCaching(1, "foo.ori/");
+    assert.equal(value1, 1);
+
+    const value2 = enableValueCaching("hello", "foo.ori/");
+    assert.equal(value2, "hello");
+  });
+
+  test("adds cachePath to plain object", () => {
+    const obj = { a: 1, b: 2 };
+    const value = enableValueCaching(obj, "foo.ori/");
+    assert.equal(value, obj);
+    assert.equal(value[cachePathSymbol], "foo.ori/");
+  });
+
+  test("adds cachePath to array", () => {
+    const arr = [1, 2, 3];
+    const value = enableValueCaching(arr, "foo.ori/");
+    assert.equal(value, arr);
+    assert.equal(value[cachePathSymbol], "foo.ori/");
+  });
+
+  test("applies cache transform to Map", () => {
+    const map = new Map([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const value = enableValueCaching(map, "foo.ori/");
+    assert(value instanceof Map);
+    assert.equal(value[cachePathSymbol], "foo.ori/");
+    assert.equal(value.get("a"), 1);
+    assert(systemCache.has("foo.ori/a"));
+  });
+
+  test("applies cache to function with string arguments", () => {
+    function fn(x, y) {
+      return `${x} ${y}`;
+    }
+    const value = enableValueCaching(fn, "foo.ori/");
+    assert(typeof value === "function");
+    assert.equal(value("Hello", "world"), "Hello world");
+    assert.equal(value[cachePathSymbol], "foo.ori/");
+  });
+});

package/test/runtime/errors.test.js

@@ -1,12 +1,18 @@
+import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
-import { describe, test } from "node:test";
+import { beforeEach, describe, test } from "node:test";
 import coreGlobals from "../../src/project/coreGlobals.js";
 import { formatError } from "../../src/runtime/errors.js";
 import evaluate from "../../src/runtime/evaluate.js";
+import systemCache from "../../src/runtime/systemCache.js";
 
 const globals = await coreGlobals();
 
 describe("formatError", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
   describe("ReferenceError", () => {
     test("identifies an undefined function", async () => {
       await assertError(
@@ -17,7 +23,7 @@ evaluating: \x1b[31mdoesntExist\x1b[0m`,
       );
     });
 
-    test("identifies the argument that produced an error", async () => {
+    test.skip("identifies the argument that produced an error", async () => {
       await assertError(
         `Tree.map(foo, (_) => _)`,
         `ReferenceError: Tree.map: The map argument wasn't defined.
@@ -73,9 +79,9 @@ evaluating: \x1B[31mdatu.toString\x1B[0m
     });
 
     test("proposes typos using scope keys", async () => {
-      const parent = {
+      const parent = new ObjectMap({
         "index.ori": "Index page",
-      };
+      });
       await assertError(
         `index.orj(1, 2, 3)`,
         `ReferenceError: Couldn't find the function or map to execute.
@@ -170,11 +176,14 @@ evaluating: \x1B[31mposts.md\x1B[0m
     });
 
     test("handles a traversal failure inside a reference error", async () => {
-      const parent = {
-        post1: {
-          title: "First post",
+      const parent = new ObjectMap(
+        {
+          post1: {
+            title: "First post",
+          },
         },
-      };
+        { deep: true },
+      );
       await assertError(
         `(post1/totle).toUpperCase()`,
         `ReferenceError: Tried to get a property of something that doesn't exist.
@@ -197,16 +206,19 @@ evaluating: \x1B[31mrepeat\x1B[0m`,
 
   describe("TraverseError", () => {
     test("suggests typos for failed path", async () => {
-      const parent = {
-        a: {
-          b: {
-            sub: {
-              // need 2+ characters for typos
-              c: 1,
+      const parent = new ObjectMap(
+        {
+          a: {
+            b: {
+              sub: {
+                // need 2+ characters for typos
+                c: 1,
+              },
             },
           },
         },
-      };
+        { deep: true },
+      );
       await assertError(
         `a/b/sup/c`,
         `TraverseError: A path hit a null or undefined value.
@@ -219,9 +231,7 @@ evaluating: \x1B[31msup/\x1B[0m`,
     });
 
     test("identifies when a numeric key failed", async () => {
-      const parent = {
-        map: new Map([[1, new Map([["a", true]])]]),
-      };
+      const parent = new Map([["map", new Map([[1, new Map([["a", true]])]])]]);
       await assertError(
         `map/1/a`,
         `TraverseError: A path hit a null or undefined value.
@@ -235,12 +245,12 @@ evaluating: \x1B[31m1/\x1B[0m`,
     });
 
     test("identifies when a value couldn't be unpacked due to a missing extension handler", async () => {
-      const parent = {
+      const parent = new ObjectMap({
         "file.foo": Uint8Array.from("hello"),
-      };
+      });
       await assertError(
         `file.foo/bar`,
-        `TraverseError: A path hit binary file data that can't be unpacked.
+        `TraverseError: A path hit binary data that can't be unpacked.
 Tried to traverse path:  file.foo/bar
 Stopped unexpectedly at: file.foo/
 The value couldn't be unpacked because no file extension handler is registered for ".foo".
@@ -250,11 +260,14 @@ evaluating: \x1B[31mfile.foo/\x1B[0m`,
     });
 
     test("identifies when data was already unpacked", async () => {
-      const parent = {
-        a: {
-          "b.json": 1,
+      const parent = new ObjectMap(
+        {
+          a: {
+            "b.json": 1,
+          },
         },
-      };
+        { deep: true },
+      );
       await assertError(
         `a/b.json/`,
         `TraverseError: A path tried to unpack data that's already unpacked.
@@ -267,9 +280,12 @@ evaluating: \x1B[31mb.json/\x1B[0m`,
     });
 
     test("identifies when a value didn't exist to be unpacked", async () => {
-      const parent = {
-        a: {},
-      };
+      const parent = new ObjectMap(
+        {
+          a: {},
+        },
+        { deep: true },
+      );
       await assertError(
         `a/b/`,
         `TraverseError: A path tried to unpack a value that doesn't exist.
@@ -282,12 +298,19 @@ evaluating: \x1B[31mb/\x1B[0m`,
   });
 });
 
-async function assertError(source, expectedMessage, options) {
+async function assertError(expression, expectedMessage, options) {
   try {
+    const source =
+      typeof expression !== "string"
+        ? expression
+        : {
+            text: expression,
+            relativePath: "test.ori",
+          };
     await evaluate(source, {
       globals,
       object: null,
-      parent: {},
+      parent: null,
       stack: [],
       ...options,
     });

package/test/runtime/evaluate.test.js

@@ -1,7 +1,8 @@
-import { Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
-import { describe, test } from "node:test";
+import { beforeEach, describe, test } from "node:test";
 import evaluate from "../../src/runtime/evaluate.js";
+import systemCache from "../../src/runtime/systemCache.js";
 
 const globals = {
   concat: (...args) => args.join(""),
@@ -10,6 +11,10 @@ const globals = {
 };
 
 describe("evaluate", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
   test("array", async () => {
     await assertEvaluation("[]", []);
     await assertEvaluation("[ 1, 2, 3, ]", [1, 2, 3]);
@@ -31,9 +36,9 @@ describe("evaluate", () => {
 
   test("angle bracket path", async () => {
     await assertEvaluation("<data>", "Bob", {
-      parent: {
+      parent: new ObjectMap({
         data: "Bob",
-      },
+      }),
     });
   });
 

package/test/runtime/execute.test.js

@@ -1,11 +1,16 @@
 import assert from "node:assert";
-import { describe, test } from "node:test";
+import { beforeEach, describe, test } from "node:test";
 
 import { SyncMap } from "@weborigami/async-tree";
 import execute from "../../src/runtime/execute.js";
+import systemCache from "../../src/runtime/systemCache.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
 describe("execute", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
     const packed = new String();

package/test/runtime/expressionObject.test.js

@@ -1,35 +1,59 @@
 import { ObjectMap, symbols, SyncMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
-import { describe, test } from "node:test";
+import { beforeEach, describe, test } from "node:test";
 
 import expressionObject from "../../src/runtime/expressionObject.js";
 import { ops } from "../../src/runtime/internal.js";
+import { cachePathSymbol } from "../../src/runtime/symbols.js";
+import systemCache from "../../src/runtime/systemCache.js";
 
 describe("expressionObject", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
   test("can instantiate an object", async () => {
-    const container = new ObjectMap({
+    const parent = new ObjectMap({
       upper: (s) => s.toUpperCase(),
     });
 
     const entries = [
-      ["hello", [[[ops.scope, container], "upper"], "hello"]],
-      ["world", [[[ops.scope, container], "upper"], "world"]],
+      ["hello", [[[ops.scope], "upper"], "hello"]],
+      ["world", [[[ops.scope], "upper"], "world"]],
     ];
     const context = new SyncMap();
 
-    const object = await expressionObject(entries, { object: context });
+    const object = await expressionObject(entries, {
+      object: context,
+      parent,
+    });
     assert.equal(await object.hello, "HELLO");
     assert.equal(await object.world, "WORLD");
     assert.equal(object[symbols.parent], context);
   });
 
-  test("can define a property getter", async () => {
+  test("static property", async () => {
+    let count = 0;
+    const increment = () => count++;
+    const entries = [["count", [increment]]];
+    const object = await expressionObject(entries);
+    const propertyDescriptor = Object.getOwnPropertyDescriptor(object, "count");
+    assert.equal(propertyDescriptor?.value, 0);
+    assert.equal(object.count, 0);
+    assert.equal(count, 1); // getter should have been called
+  });
+
+  test("with caching on, property getter uses system cache", async () => {
     let count = 0;
     const increment = () => count++;
     const entries = [["count", [ops.getter, [increment]]]];
     const object = await expressionObject(entries);
+    object[cachePathSymbol] = "foo.ori/"; // enable caching on this object tree
     assert.equal(await object.count, 0);
-    assert.equal(await object.count, 1);
+    const propertyDescriptor = Object.getOwnPropertyDescriptor(object, "count");
+    assert(propertyDescriptor?.get); // should still be a getter
+    assert.equal(count, 1); // getter should have been called
+    assert.equal(await object.count, 0); // getter result should be cached
   });
 
   test("treats a getter for a primitive value as a regular property", async () => {
@@ -75,10 +99,16 @@ describe("expressionObject", () => {
     });
   });
 
-  test.only("returned object values can be unpacked", async () => {
+  test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
     const context = new SyncMap();
-    const result = await expressionObject(entries, { object: context });
+    const globals = {
+      json_handler: { unpack: (data) => JSON.parse(data) },
+    };
+    const result = await expressionObject(entries, {
+      object: context,
+      globals,
+    });
     const dataJson = await result["data.json"];
     const json = await dataJson.unpack();
     assert.deepEqual(json, { a: 1 });
@@ -115,11 +145,21 @@ describe("expressionObject", () => {
     ]);
   });
 
-  // test("sets symbols.async on objects with getters", async () => {
-  //   const noGetter = await expressionObject([["eager", 1]]);
-  //   assert.equal(noGetter[symbols.async], undefined);
+  test("tracks dependencies on upstream values", async () => {
+    systemCache.clear();
 
-  //   const hasGetter = await expressionObject([["lazy", [ops.getter, [2]]]]);
-  //   assert.equal(hasGetter[symbols.async], true);
-  // });
+    // The `number` property gets a value from the cache
+    const getNumber = () =>
+      systemCache.getOrInsertComputed("dependency", () => 1);
+    const entries = [["number", [ops.getter, [getNumber]]]];
+    const object = await expressionObject(entries);
+    object[cachePathSymbol] = "src/test.ori/"; // enable caching on this object tree
+    const number = await object.number;
+    assert.equal(number, 1);
+
+    const dependencyEntry = systemCache.get("dependency");
+    const objectEntry = systemCache.get("src/test.ori/number");
+    assert(dependencyEntry.downstreams.has("src/test.ori/number"));
+    assert(objectEntry.upstreams.has("dependency"));
+  });
 });

package/test/runtime/fetchAndHandleExtension.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import json_handler from "../../src/handlers/json_handler.js";
+import fetchAndHandleExtension from "../../src/protocols/fetchAndHandleExtension.js";
+
+describe("fetchAndHandleExtension", () => {
+  test("can unpack based on MIME content type", async () => {
+    /** @type {any} */
+    const parent = new Map();
+    parent.globals = {
+      json_handler,
+    };
+    const buffer = await fetchAndHandleExtension(
+      "https://weborigami.org/samples/help/pet.json",
+      null,
+      {
+        parent,
+      },
+    );
+    // @ts-ignore
+    const data = await buffer.unpack();
+    assert.strictEqual(data.name, "Fluffy");
+  });
+});

package/test/runtime/fixtures/unpack/hello.json

@@ -0,0 +1 @@
+"Hello"