@weborigami/language 0.6.17 → 0.7.0-beta.2

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
+  });
+});

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/");
+  });
+});