@weborigami/language 0.6.17 → 0.7.0-beta.2

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"

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