@weborigami/language 0.6.17 → 0.7.0-beta.1

package/test/runtime/handleExtension.test.js

@@ -1,7 +1,15 @@
 import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import * as handlers from "../../src/handlers/handlers.js";
 import handleExtension from "../../src/runtime/handleExtension.js";
+import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
+import { cachePathSymbol } from "../../src/runtime/symbols.js";
+
+const fixturesUrl = new URL("fixtures/unpack", import.meta.url);
+const fixtureFiles = new OrigamiFileMap(fixturesUrl);
+fixtureFiles[cachePathSymbol] = "fixtures";
+fixtureFiles.globals = handlers;
 
 describe("handleExtension", () => {
   test("attaches an unpack method to a value with an extension", async () => {
@@ -10,7 +18,10 @@ describe("handleExtension", () => {
     assert(typeof numberValue === "number");
     assert.equal(numberValue, 1);
     const jsonFile = await fixture.get("bar.json");
-    const withHandler = await handleExtension(jsonFile, "bar.json", fixture);
+    const globals = {
+      json_handler: { unpack: async (data) => JSON.parse(data) },
+    };
+    const withHandler = handleExtension(jsonFile, "bar.json", globals, fixture);
     assert.equal(String(withHandler), `{ "bar": 2 }`);
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });

package/test/runtime/ops.test.js

@@ -1,12 +1,17 @@
 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 execute from "../../src/runtime/execute.js";
 import { ops } from "../../src/runtime/internal.js";
+import systemCache from "../../src/runtime/systemCache.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
 describe("ops", () => {
+  beforeEach(() => {
+    systemCache.clear();
+  });
+
   test("ops.addition adds two numbers", async () => {
     assert.strictEqual(ops.addition(2, 2), 4);
     assert.strictEqual(ops.addition(2, true), 3);
@@ -49,6 +54,15 @@ describe("ops", () => {
     assert.strictEqual(ops.bitwiseXor(5, 3), 6);
   });
 
+  test("ops.cache", async () => {
+    const fn = () => 1;
+    const code = createCode([ops.object, ["a", [ops.getter, [fn]]]]);
+    const result = await ops.cache("a.ori/_refs/b.ori/", code, {});
+    assert.deepEqual(await Tree.plain(result), { a: 1 });
+    const cachedResult = await systemCache.get("a.ori/_refs/b.ori/");
+    assert.strictEqual(await cachedResult.value.a, 1);
+  });
+
   test("ops.comma returns the last value", async () => {
     const code = createCode([ops.comma, 1, 2, 3]);
     const result = await execute(code);
@@ -70,17 +84,17 @@ describe("ops", () => {
   });
 
   test("ops.deepText concatenates tree value text", async () => {
-    const container = {
+    const parent = new ObjectMap({
       name: "world",
-    };
+    });
     const code = createCode([
       ops.deepText,
       "Hello, ",
-      [[ops.scope, container], "name"],
+      [[ops.scope], "name"],
       ".",
     ]);
 
-    const result = await execute(code);
+    const result = await execute(code, { parent });
     assert.strictEqual(result, "Hello, world.");
   });
 
@@ -106,27 +120,22 @@ describe("ops", () => {
 
   test("ops.cache evaluates code and cache its result", async () => {
     let count = 0;
-    const container = {
+    const parent = new ObjectMap({
       group: {
         get count() {
           // Use promise to test async behavior
           return Promise.resolve(++count);
         },
       },
-    };
+    });
     const code = createCode([
       ops.cache,
-      {},
-      "group/count",
-      [
-        [ops.scope, container],
-        [ops.literal, "group"],
-        [ops.literal, "count"],
-      ],
+      "_refs/test.ori/group/count",
+      [[ops.scope], [ops.literal, "group"], [ops.literal, "count"]],
     ]);
-    const result = await execute(code);
+    const result = await execute(code, { parent });
     assert.strictEqual(result, 1);
-    const result2 = await execute(code);
+    const result2 = await execute(code, { parent });
     assert.strictEqual(result2, 1);
   });
 
@@ -146,6 +155,7 @@ describe("ops", () => {
   describe("ops.flat", () => {
     test("flattens arrays", async () => {
       assert.deepEqual(await ops.flat(1, 2, [3]), [1, 2, 3]);
+      assert.deepEqual(await ops.flat([1], [2], [[3]]), [1, 2, [3]]);
     });
 
     test("flattens maplike objects", async () => {
@@ -171,6 +181,15 @@ describe("ops", () => {
         3: 8,
       });
     });
+
+    test("flattens arrays of objects", async () => {
+      const result = await ops.flat([{ a: 1 }], [{ b: 2 }, { c: 3 }]);
+      assert.deepEqual(await Tree.plain(result), [
+        { a: 1 },
+        { b: 2 },
+        { c: 3 },
+      ]);
+    });
   });
 
   test("ops.greaterThan", () => {
@@ -225,18 +244,18 @@ describe("ops", () => {
   });
 
   test("ops.lambda defines a function with underscore input", async () => {
-    const container = {
+    const parent = new ObjectMap({
       message: "Hello",
-    };
+    });
 
     const code = createCode([
       ops.lambda,
       1,
       [["_", [[ops.params, 0], 0]]],
-      [[ops.scope, container], "message"],
+      [[ops.scope], "message"],
     ]);
 
-    const fn = await execute(code);
+    const fn = await execute(code, { parent });
     assert.equal(fn.length, 1);
     const result = await fn();
     assert.strictEqual(result, "Hello");
@@ -308,9 +327,9 @@ describe("ops", () => {
     //   ...more
     //   c: a
     // }
-    const container = {
+    const parent = new ObjectMap({
       more: { b: 2 },
-    };
+    });
     const code = createCode([
       [
         ops.object,
@@ -321,14 +340,14 @@ describe("ops", () => {
           [
             ops.merge,
             [ops.object, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
-            [[ops.scope, container], "more"],
+            [[ops.scope], "more"],
             [ops.object, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
           ],
         ],
       ],
       "_result",
     ]);
-    const result = await execute(code);
+    const result = await execute(code, { parent });
     assert.deepEqual(await Tree.plain(result), { a: 1, b: 2, c: 1 });
   });
 
@@ -339,31 +358,6 @@ describe("ops", () => {
     assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  test("ops.objectRest returns an object without specified keys", async () => {
-    const obj = {
-      a: 1,
-      b: 2,
-      c: 3,
-    };
-    const result = await ops.objectRest(obj, ["a", "b"]);
-    assert.deepEqual(result, { c: 3 });
-  });
-
-  test("ops.optional", async () => {
-    assert.equal(
-      ops.optional(null, (x) => x.a),
-      undefined,
-    );
-    assert.equal(
-      ops.optional(undefined, (x) => x.a),
-      undefined,
-    );
-    assert.equal(
-      ops.optional({ a: 1 }, (x) => x.a),
-      1,
-    );
-  });
-
   test("ops.notEqual", () => {
     assert(!ops.notEqual(1, 1));
     assert(ops.notEqual(1, 2));
@@ -390,33 +384,44 @@ describe("ops", () => {
   });
 
   test("ops.object instantiates an object", async () => {
-    const container = {
+    const parent = new ObjectMap({
       upper: (s) => s.toUpperCase(),
-    };
+    });
 
     const code = createCode([
       ops.object,
-      ["hello", [[[ops.scope, container], "upper"], "hello"]],
-      ["world", [[[ops.scope, container], "upper"], "world"]],
+      ["hello", [[[ops.scope], "upper"], "hello"]],
+      ["world", [[[ops.scope], "upper"], "world"]],
     ]);
 
-    const result = await execute(code);
+    const result = await execute(code, { parent });
     assert.strictEqual(result.hello, "HELLO");
     assert.strictEqual(result.world, "WORLD");
   });
 
-  test("ops.object instantiates an array", async () => {
-    const container = {
-      upper: (s) => s.toUpperCase(),
+  test("ops.objectRest returns an object without specified keys", async () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
     };
-    const code = createCode([
-      ops.array,
-      "Hello",
+    const result = await ops.objectRest(obj, ["a", "b"]);
+    assert.deepEqual(result, { c: 3 });
+  });
+
+  test("ops.optional", async () => {
+    assert.equal(
+      ops.optional(null, (x) => x.a),
+      undefined,
+    );
+    assert.equal(
+      ops.optional(undefined, (x) => x.a),
+      undefined,
+    );
+    assert.equal(
+      ops.optional({ a: 1 }, (x) => x.a),
       1,
-      [[[ops.scope, container], "upper"], "world"],
-    ]);
-    const result = await execute(code);
-    assert.deepEqual(result, ["Hello", 1, "WORLD"]);
+    );
   });
 
   test("ops.params returns a stack frame", async () => {
@@ -455,7 +460,7 @@ describe("ops", () => {
       );
       const a = await tree.get("a");
       const b = await a.get("b");
-      const scope = await ops.scope(b);
+      const scope = await ops.scope({ parent: b });
       assert.equal(await scope?.get("c"), 1);
     });
   });

package/test/runtime/syncCalcs.js

@@ -0,0 +1,27 @@
+import { SyncMap } from "@weborigami/async-tree";
+import SyncCacheTransform from "../../src/runtime/SyncCacheTransform.js";
+
+export default function syncCalcs(iterable) {
+  const data = new (SyncCacheTransform(SyncMap))(iterable);
+  const calcs = new (SyncCacheTransform(SyncResultsMap))(data);
+  return { calcs, data };
+}
+
+class SyncResultsMap extends SyncMap {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+
+  get(key) {
+    let value = this.source.get(key);
+    if (typeof value === "function") {
+      value = value();
+    }
+    return value;
+  }
+
+  keys() {
+    return this.source.keys();
+  }
+}

package/test/runtime/systemCache.test.js

@@ -0,0 +1,66 @@
+/**
+ * Integration tests of several forms of caching using the system cache
+ */
+
+import { SyncMap, Tree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as handlers from "../../src/handlers/handlers.js";
+import HandleExtensionsTransform from "../../src/runtime/HandleExtensionsTransform.js";
+import SyncCacheTransform from "../../src/runtime/SyncCacheTransform.js";
+import { cachePathSymbol } from "../../src/runtime/symbols.js";
+
+describe("systemCache", () => {
+  test("property based on external scope recalculates when scope changes", async () => {
+    // Virtual src folder
+    const src = new OrigamiSyncMap([
+      [
+        "site.ori",
+        `
+        {
+          value = data.json/
+        }
+      `,
+      ],
+    ]);
+
+    // Virtual project root folder
+    const project = new OrigamiSyncMap([
+      ["data.json", "1"],
+      ["src", src],
+    ]);
+
+    // Make src a child of the project root
+    src.parent = project;
+
+    // Paths are optional but make cache keys more meaningful
+    src[cachePathSymbol] = "project/src";
+    project[cachePathSymbol] = "project";
+
+    // Add handlers so we can unpack values
+    // @ts-ignore
+    project.globals = handlers;
+
+    const site = await Tree.traverseOrThrow(project, "src/", "site.ori/");
+
+    const value1 = await site.value;
+    assert.equal(value1, 1);
+
+    // Add new data.json to src folder, overriding the one in project root
+    src.set("data.json", "2");
+
+    const value2 = await site.value;
+    assert.equal(value2, 2);
+
+    // Delete data.json from src folder, reverting to the one in project root
+    src.delete("data.json");
+
+    const value3 = await site.value;
+    assert.equal(value3, 1);
+  });
+});
+
+// Like OrigamiFileMap, but in memory
+class OrigamiSyncMap extends SyncCacheTransform(
+  HandleExtensionsTransform(SyncMap),
+) {}

package/src/runtime/assignPropertyDescriptors.js

@@ -1,23 +0,0 @@
-/**
- * This is an analogue of Object.assign that destructively copies properties to
- * a target object -- but avoids invoking property getters. Instead, it copies
- * property descriptors over to the target object.
- *
- * @param {any} target
- * @param  {...any} sources
- */
-export default function assignPropertyDescriptors(target, ...sources) {
-  for (const source of sources) {
-    const descriptors = Object.getOwnPropertyDescriptors(source);
-    for (const [key, descriptor] of Object.entries(descriptors)) {
-      if (descriptor.value !== undefined) {
-        // Simple value, copy it
-        target[key] = descriptor.value;
-      } else {
-        // Getter and/or setter, copy the descriptor
-        Object.defineProperty(target, key, descriptor);
-      }
-    }
-  }
-  return target;
-}

package/src/runtime/asyncStorage.js

@@ -1,7 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-/**
- * Storage maintained by the execute() function and accessible to async
- * functions called during evaluation.
- */
-export default new AsyncLocalStorage();