@weborigami/language 0.5.8 → 0.6.1

package/test/handlers/wasm_handler.test.js

@@ -1,11 +1,11 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import wasm_handler from "../../src/handlers/wasm_handler.js";
 import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+const fixturesTree = new (ImportModulesMixin(FileMap))(fixturesUrl);
 
 describe(".wasm handler", () => {
   test("loads .wasm file that exports a function", async () => {

package/test/handlers/yaml_handler.test.js

@@ -1,3 +1,4 @@
+import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import yaml_handler from "../../src/handlers/yaml_handler.js";
@@ -8,10 +9,39 @@ describe(".yaml handler", () => {
 a: 1
 b: 2
 `;
-    const data = yaml_handler.unpack(text);
+    const data = await yaml_handler.unpack(text);
     assert.deepEqual(data, {
       a: 1,
       b: 2,
     });
   });
+
+  test("defines !ori tag for Origami expressions", async () => {
+    const text = `
+message: Hello
+answer: !ori 1 + 1
+`;
+    const data = await yaml_handler.unpack(text);
+    const plain = await Tree.plain(data);
+    assert.deepEqual(plain, {
+      message: "Hello",
+      answer: 2,
+    });
+  });
+
+  test("defines !ori.call tag for Origami function invocation", async () => {
+    const text = `
+message: Hello
+answer: !ori.call
+  - (a, b) => a + b
+  - 2
+  - 3
+`;
+    const data = await yaml_handler.unpack(text);
+    const plain = await Tree.plain(data);
+    assert.deepEqual(plain, {
+      message: "Hello",
+      answer: 5,
+    });
+  });
 });

package/test/runtime/OrigamiFileMap.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import path from "node:path";
+import { 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");
+
+describe("OrigamiFileMap", () => {
+  test.skip("can watch its folder for changes", { timeout: 2000 }, async () => {
+    createTempDirectory();
+
+    const tempFiles = new OrigamiFileMap(tempDirectory);
+    const changedFileName = await new Promise(async (resolve) => {
+      tempFiles.addEventListener("change", (event) => {
+        resolve(/** @type {any} */ (event).options.key);
+      });
+      tempFiles.set(
+        "foo.txt",
+        "This file is left over from testing and can be removed."
+      );
+    });
+    removeTempDirectory();
+    assert.equal(changedFileName, "foo.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/evaluate.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
-import { ObjectTree } from "@weborigami/async-tree";
+import { SyncMap } from "@weborigami/async-tree";
 import evaluate from "../../src/runtime/evaluate.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
@@ -27,12 +27,12 @@ describe("evaluate", () => {
   });
 
   test("if function has containerAsTarget, it gets bound to state.container", async () => {
-    /** @this {import("@weborigami/types").AsyncTree} */
+    /** @this {import("@weborigami/async-tree").SyncOrAsyncMap} */
     const fn = function () {
       return this;
     };
     fn.containerAsTarget = true;
-    const container = new ObjectTree({});
+    const container = new SyncMap();
     const state = { container };
     const code = createCode([fn]);
     const result = await evaluate(code, state);

package/test/runtime/expressionObject.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import { ObjectMap, symbols, SyncMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -7,7 +7,7 @@ import { ops } from "../../src/runtime/internal.js";
 
 describe("expressionObject", () => {
   test("can instantiate an object", async () => {
-    const container = new ObjectTree({
+    const container = new ObjectMap({
       upper: (s) => s.toUpperCase(),
     });
 
@@ -15,7 +15,7 @@ describe("expressionObject", () => {
       ["hello", [[[ops.scope, container], "upper"], "hello"]],
       ["world", [[[ops.scope, container], "upper"], "world"]],
     ];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
 
     const object = await expressionObject(entries, { object: context });
     assert.equal(await object.hello, "HELLO");
@@ -43,7 +43,7 @@ describe("expressionObject", () => {
       ["name", "world"],
       ["message", [ops.concat, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
     ];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
     const object = await expressionObject(entries, { object: context });
     assert.deepEqual(await Tree.plain(object), {
       name: "world",
@@ -54,7 +54,7 @@ describe("expressionObject", () => {
 
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
     const result = await expressionObject(entries, { object: context });
     const dataJson = await result["data.json"];
     const json = await dataJson.unpack();
@@ -77,7 +77,7 @@ describe("expressionObject", () => {
       ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
       ["hasSlash/", "This isn't really a tree but says it is"],
       ["message", "Hello"],
-      // Immediate treelike value, should have a slash
+      // Immediate maplike value, should have a slash
       ["object", [ops.object, ["b", [ops.literal, 2]]]],
     ];
     const object = await expressionObject(entries);
@@ -88,4 +88,12 @@ describe("expressionObject", () => {
       "object/",
     ]);
   });
+
+  test("sets symbols.async on objects with getters", async () => {
+    const noGetter = await expressionObject([["eager", 1]]);
+    assert.equal(noGetter[symbols.async], undefined);
+
+    const hasGetter = await expressionObject([["lazy", [ops.getter, [2]]]]);
+    assert.equal(hasGetter[symbols.async], true);
+  });
 });

package/test/runtime/handleExtension.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import handleExtension from "../../src/runtime/handleExtension.js";
@@ -15,17 +15,10 @@ describe("handleExtension", () => {
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });
   });
-
-  test("immediately unpacks if key ends in slash", async () => {
-    const fixture = createFixture();
-    const jsonFile = await fixture.get("bar.json");
-    const data = await handleExtension(jsonFile, "bar.json/", fixture);
-    assert.deepEqual(data, { bar: 2 });
-  });
 });
 
 function createFixture() {
-  return new ObjectTree({
+  return new ObjectMap({
     foo: 1, // No extension, should be left alone
     "bar.json": `{ "bar": 2 }`,
   });

package/test/runtime/mergeTrees.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import mergeTrees from "../../src/runtime/mergeTrees.js";
@@ -42,7 +42,7 @@ describe("mergeTrees", () => {
 
   test("merges heterogenous arguments as trees", async () => {
     const tree = await mergeTrees(
-      new ObjectTree({
+      new ObjectMap({
         a: 1,
         b: 2,
       }),

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -128,12 +128,12 @@ describe("ops", () => {
       assert.deepEqual(await ops.flat(1, 2, [3]), [1, 2, 3]);
     });
 
-    test("flattens treelike objects", async () => {
+    test("flattens maplike objects", async () => {
       const object = {
         a: 1,
         b: 2,
       };
-      const tree = new ObjectTree({
+      const tree = new ObjectMap({
         c: 3,
         d: 4,
       });
@@ -156,11 +156,14 @@ describe("ops", () => {
   });
 
   test("ops.inherited walks up the object parent chain", async () => {
-    const tree = new DeepObjectTree({
-      a: {
-        b: {},
+    const tree = new ObjectMap(
+      {
+        a: {
+          b: {},
+        },
       },
-    });
+      { deep: true }
+    );
     const b = await Tree.traverse(tree, "a", "b");
     assert.equal(await ops.inherited(2, { object: b }), tree);
   });
@@ -368,12 +371,15 @@ describe("ops", () => {
 
   describe("ops.scope", () => {
     test("returns the scope of the given tree", async () => {
-      const tree = new DeepObjectTree({
-        a: {
-          b: {},
+      const tree = new ObjectMap(
+        {
+          a: {
+            b: {},
+          },
+          c: 1,
         },
-        c: 1,
-      });
+        { deep: true }
+      );
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope(b);

package/src/runtime/InvokeFunctionsTransform.d.ts

@@ -1,5 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-declare const InvokeFunctionsTransform: Mixin<{}>;
-
-export default InvokeFunctionsTransform;

package/src/runtime/InvokeFunctionsTransform.js

@@ -1,25 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * When using `get` to retrieve a value from a tree, if the value is a
- * function, invoke it and return the result.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function InvokeFunctionsTransform(Base) {
-  return class InvokeFunctions extends Base {
-    async get(key) {
-      let value = await super.get(key);
-      if (typeof value === "function") {
-        value = await value();
-
-        if (Tree.isAsyncTree(value) && !value.parent) {
-          value.parent = this;
-        }
-      }
-      return value;
-    }
-  };
-}

package/src/runtime/functionResultsMap.js

@@ -1,17 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * When using `get` to retrieve a value from a tree, if the value is a
- * function, invoke it and return the result.
- */
-export default async function functionResultsMap(treelike) {
-  return Tree.map(treelike, {
-    description: "functionResultsMap",
-
-    value: async (sourceValue, sourceKey, tree) => {
-      const resultValue =
-        typeof sourceValue === "function" ? await sourceValue() : sourceValue;
-      return resultValue;
-    },
-  });
-}

package/test/runtime/OrigamiFiles.test.js

@@ -1,35 +0,0 @@
-import assert from "node:assert";
-import * as fs from "node:fs/promises";
-import path from "node:path";
-import { describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
-import OrigamiFiles from "../../src/runtime/OrigamiFiles.js";
-
-const dirname = path.dirname(fileURLToPath(import.meta.url));
-const tempDirectory = path.join(dirname, "fixtures/temp");
-
-describe("OrigamiFiles", () => {
-  test("can watch its folder for changes", { timeout: 2000 }, async () => {
-    await createTempDirectory();
-    const tempFiles = new OrigamiFiles(tempDirectory);
-    const changedFileName = await new Promise(async (resolve) => {
-      tempFiles.addEventListener("change", (event) => {
-        resolve(/** @type {any} */ (event).options.key);
-      });
-      await tempFiles.set(
-        "foo.txt",
-        "This file is left over from testing and can be removed."
-      );
-    });
-    await removeTempDirectory();
-    assert.equal(changedFileName, "foo.txt");
-  });
-});
-
-async function createTempDirectory() {
-  await fs.mkdir(tempDirectory, { recursive: true });
-}
-
-async function removeTempDirectory() {
-  await fs.rm(tempDirectory, { recursive: true });
-}

package/test/runtime/fixtures/subgraph = this.js

@@ -1,5 +0,0 @@
-import { ObjectTree } from "@weborigami/async-tree";
-export default new ObjectTree({
-  a: "Hello, a.",
-  b: "Hello, b.",
-});

package/test/runtime/functionResultsMap.test.js

@@ -1,20 +0,0 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import functionResultsMap from "../../src/runtime/functionResultsMap.js";
-
-describe("functionResultsMap", () => {
-  test("get() invokes functions, returns other values as is", async () => {
-    const tree = new ObjectTree({
-      fn: function () {
-        return "Hello";
-      },
-      string: "string",
-    });
-    const fixture = await functionResultsMap(tree);
-    assert.deepEqual(await Tree.plain(fixture), {
-      fn: "Hello",
-      string: "string",
-    });
-  });
-});