@weborigami/language 0.5.4 → 0.5.6

package/test/handlers/wasm.handler.test.js

@@ -0,0 +1,20 @@
+import { FileTree } 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);
+
+describe(".wasm handler", () => {
+  test("loads .wasm file that exports a function", async () => {
+    const buffer = await fixturesTree.get("add.wasm");
+    const { add } = await wasm_handler.unpack(buffer, {
+      key: "add.wasm",
+      parent: fixturesTree,
+    });
+    const sum = add(1, 2);
+    assert.strictEqual(sum, 3);
+  });
+});

package/test/handlers/yaml.handler.test.js

@@ -0,0 +1,17 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import yaml_handler from "../../src/handlers/yaml_handler.js";
+
+describe(".yaml handler", () => {
+  test("loads input as a YAML file", async () => {
+    const text = `
+a: 1
+b: 2
+`;
+    const data = yaml_handler.unpack(text);
+    assert.deepEqual(data, {
+      a: 1,
+      b: 2,
+    });
+  });
+});

package/test/project/fixtures/withConfig/config.ori

@@ -0,0 +1,4 @@
+{
+  greet = subfolder/greet.js
+  message = "Hello"
+}

package/test/project/fixtures/withConfig/subfolder/greet.js

@@ -0,0 +1 @@
+export default (name) => `Hello, ${name}!`;

package/test/project/jsGlobals.test.js

@@ -0,0 +1,21 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import jsGlobals from "../../src/project/jsGlobals.js";
+
+describe("jsGlobals", () => {
+  test("can invoke static methods", async () => {
+    const { Promise } = jsGlobals;
+    const { all } = Promise;
+    const result = (
+      await all(["fruit", "computer", "park"].map((item) => `Apple ${item}`))
+    ).join(", ");
+    assert.equal(result, "Apple fruit, Apple computer, Apple park");
+  });
+
+  test("can invoke a method on a static method", () => {
+    const { Math } = jsGlobals;
+    const a = [1, 3, 2];
+    const b = Math.max.apply(null, a);
+    assert.equal(b, 3);
+  });
+});

package/test/project/projectConfig.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import projectConfig from "../../src/project/projectConfig.js";
+
+describe("projectConfig", () => {
+  test("finds Origami configuration file", async () => {
+    // Find the folder that represents the project root.
+    const projectUrl = new URL("fixtures/withConfig/", import.meta.url);
+    // Find subfolder inside project root.
+    const subfolderUrl = new URL("./subfolder/", projectUrl);
+    const subfolderPath = fileURLToPath(subfolderUrl);
+
+    const config = await projectConfig(subfolderPath);
+    assert.equal(config.message, "Hello");
+  });
+
+  test("defaults to an empty object", async () => {
+    // Find the folder that represents the project root.
+    const projectUrl = new URL("fixtures/withPackageJson/", import.meta.url);
+    // Find subfolder inside project root.
+    const subfolderUrl = new URL("./subfolder/", projectUrl);
+    const subfolderPath = fileURLToPath(subfolderUrl);
+
+    const config = await projectConfig(subfolderPath);
+    assert.deepEqual(config, {});
+  });
+});

package/test/project/projectRoot.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert";
+import path from "node:path";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import projectRoot from "../../src/project/projectRoot.js";
+
+describe("projectRoot", () => {
+  test("finds Origami configuration file", async () => {
+    // Find the folder that represents the project root.
+    const projectUrl = new URL("fixtures/withConfig/", import.meta.url);
+    // Find subfolder inside project root.
+    const subfolderUrl = new URL("./subfolder/", projectUrl);
+    const subfolderPath = fileURLToPath(subfolderUrl);
+
+    const root = await projectRoot(subfolderPath);
+
+    // Get result path, it'll need a trailing slash to compare.
+    const resultPath = root.path + path.sep;
+    assert.equal(resultPath, fileURLToPath(projectUrl));
+  });
+
+  test("finds package.json file", async () => {
+    // Find the folder that represents the project root.
+    const projectUrl = new URL("fixtures/withPackageJson/", import.meta.url);
+    // Find subfolder inside project root.
+    const subfolderUrl = new URL("./subfolder/", projectUrl);
+    const subfolderPath = fileURLToPath(subfolderUrl);
+
+    const root = await projectRoot(subfolderPath);
+
+    // Get result path, it'll need a trailing slash to compare.
+    const resultPath = root.path + path.sep;
+    assert.equal(resultPath, fileURLToPath(projectUrl));
+  });
+
+  test("defaults to current working directory", async () => {
+    const root = await projectRoot("/");
+    assert.equal(root.path, process.cwd());
+  });
+});

package/test/protocols/package.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import packageProtocol from "../../src/protocols/package.js";
+
+describe("package: protocol", () => {
+  test("returns a package's main export(s)", async () => {
+    const result = await packageProtocol("@weborigami", "async-tree");
+    const { toString } = result;
+    assert.equal(toString(123), "123");
+  });
+});

package/test/runtime/evaluate.test.js

@@ -1,57 +1,41 @@
-import { ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as ops from "../../src/runtime/ops.js";
 
+import { ObjectTree } from "@weborigami/async-tree";
 import evaluate from "../../src/runtime/evaluate.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
 describe("evaluate", () => {
-  test("can retrieve values from scope", async () => {
-    const code = createCode([[ops.scope], "message"]);
-    const parent = new ObjectTree({
-      message: "Hello",
-    });
-    const tree = new ObjectTree({});
-    tree.parent = parent;
-    const result = await evaluate.call(tree, code);
-    assert.equal(result, "Hello");
-  });
-
-  test("can invoke functions in scope", async () => {
-    // Match the array representation of code generated by the parser.
-    const code = createCode([
-      [[ops.scope], "greet"],
-      [[ops.scope], "name"],
-    ]);
-
-    const tree = new ObjectTree({
-      async greet(name) {
-        return `Hello ${name}`;
-      },
-      name: "world",
-    });
-
-    const result = await evaluate.call(tree, code);
-    assert.equal(result, "Hello world");
-  });
-
-  test("passes context to invoked functions", async () => {
-    const code = createCode([[ops.scope], "fn"]);
-    const tree = new ObjectTree({
-      async fn() {
-        assert.equal(this, tree);
-      },
-    });
-    await evaluate.call(tree, code);
-  });
-
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
     const packed = new String();
     /** @type {any} */ (packed).unpack = async () => fn;
     const code = createCode([packed, "a", "b", "c"]);
-    const result = await evaluate.call(null, code);
+    const result = await evaluate(code);
     assert.equal(result, "a,b,c");
   });
+
+  test("if function has needsState, it gets the state", async () => {
+    const fn = (state) => {
+      return state;
+    };
+    fn.needsState = true;
+    const state = {};
+    const code = createCode([fn]);
+    const result = await evaluate(code, state);
+    assert.equal(result, state);
+  });
+
+  test("if function has containerAsTarget, it gets bound to state.container", async () => {
+    /** @this {import("@weborigami/types").AsyncTree} */
+    const fn = function () {
+      return this;
+    };
+    fn.containerAsTarget = true;
+    const container = new ObjectTree({});
+    const state = { container };
+    const code = createCode([fn]);
+    const result = await evaluate(code, state);
+    assert.equal(result, container);
+  });
 });

package/test/runtime/expressionObject.test.js

@@ -7,59 +7,55 @@ import { ops } from "../../src/runtime/internal.js";
 
 describe("expressionObject", () => {
   test("can instantiate an object", async () => {
-    const scope = new ObjectTree({
+    const container = new ObjectTree({
       upper: (s) => s.toUpperCase(),
     });
 
     const entries = [
-      ["hello", [[[ops.scope], "upper"], "hello"]],
-      ["world", [[[ops.scope], "upper"], "world"]],
+      ["hello", [[[ops.scope, container], "upper"], "hello"]],
+      ["world", [[[ops.scope, container], "upper"], "world"]],
     ];
+    const context = new ObjectTree({});
 
-    const object = await expressionObject(entries, scope);
+    const object = await expressionObject(entries, { object: context });
     assert.equal(await object.hello, "HELLO");
     assert.equal(await object.world, "WORLD");
-    assert.equal(object[symbols.parent], scope);
+    assert.equal(object[symbols.parent], context);
   });
 
   test("can define a property getter", async () => {
     let count = 0;
     const increment = () => count++;
     const entries = [["count", [ops.getter, [increment]]]];
-    const object = await expressionObject(entries, null);
+    const object = await expressionObject(entries);
     assert.equal(await object.count, 0);
     assert.equal(await object.count, 1);
   });
 
   test("treats a getter for a primitive value as a regular property", async () => {
     const entries = [["name", [ops.getter, "world"]]];
-    const object = await expressionObject(entries, null);
+    const object = await expressionObject(entries);
     assert.equal(object.name, "world");
   });
 
   test("can instantiate an Origami tree", async () => {
     const entries = [
       ["name", "world"],
-      ["message", [ops.concat, "Hello, ", [[ops.scope], "name"], "!"]],
+      ["message", [ops.concat, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
     ];
-    const parent = new ObjectTree({});
-    const object = await expressionObject(entries, parent);
+    const context = new ObjectTree({});
+    const object = await expressionObject(entries, { object: context });
     assert.deepEqual(await Tree.plain(object), {
       name: "world",
       message: "Hello, world!",
     });
-    assert.equal(object[symbols.parent], parent);
+    assert.equal(object[symbols.parent], context);
   });
 
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
-    const parent = new ObjectTree({});
-    /** @type {any} */ (parent).handlers = {
-      "json.handler": {
-        unpack: JSON.parse,
-      },
-    };
-    const result = await expressionObject(entries, parent);
+    const context = new ObjectTree({});
+    const result = await expressionObject(entries, { object: context });
     const dataJson = await result["data.json"];
     const json = await dataJson.unpack();
     assert.deepEqual(json, { a: 1 });
@@ -70,7 +66,7 @@ describe("expressionObject", () => {
       ["(hidden)", "shh"],
       ["visible", "hey"],
     ];
-    const object = await expressionObject(entries, null);
+    const object = await expressionObject(entries);
     assert.deepEqual(Object.keys(object), ["visible"]);
     assert.equal(object["hidden"], "shh");
   });
@@ -84,7 +80,7 @@ describe("expressionObject", () => {
       // Immediate treelike value, should have a slash
       ["object", [ops.object, ["b", [ops.literal, 2]]]],
     ];
-    const object = await expressionObject(entries, null);
+    const object = await expressionObject(entries);
     assert.deepEqual(object[symbols.keys](), [
       "getter/",
       "hasSlash/",

package/test/runtime/functionResultsMap.test.js

@@ -1,21 +1,17 @@
-import { ObjectTree, Tree, scope } from "@weborigami/async-tree";
+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 using scope, returns other values as is", async () => {
-    const parent = new ObjectTree({
-      message: "Hello",
-    });
+  test("get() invokes functions, returns other values as is", async () => {
     const tree = new ObjectTree({
-      fn: /** @this {import("@weborigami/types").AsyncTree} */ function () {
-        return scope(this).get("message");
+      fn: function () {
+        return "Hello";
       },
       string: "string",
     });
-    tree.parent = parent;
-    const fixture = functionResultsMap(tree);
+    const fixture = await functionResultsMap(tree);
     assert.deepEqual(await Tree.plain(fixture), {
       fn: "Hello",
       string: "string",

package/test/runtime/{handlers.test.js → handleExtension.test.js}

@@ -1,27 +1,16 @@
 import { ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { handleExtension } from "../../src/runtime/handlers.js";
+import handleExtension from "../../src/runtime/handleExtension.js";
 
-const handlers = {
-  "json.handler": {
-    unpack: (buffer) => JSON.parse(String(buffer)),
-  },
-};
-
-describe("handlers", () => {
+describe("handleExtension", () => {
   test("attaches an unpack method to a value with an extension", async () => {
     const fixture = createFixture();
     const numberValue = await fixture.get("foo");
     assert(typeof numberValue === "number");
     assert.equal(numberValue, 1);
     const jsonFile = await fixture.get("bar.json");
-    const withHandler = await handleExtension(
-      fixture,
-      jsonFile,
-      "bar.json",
-      handlers
-    );
+    const withHandler = await handleExtension(jsonFile, "bar.json", fixture);
     assert.equal(String(withHandler), `{ "bar": 2 }`);
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });
@@ -30,12 +19,7 @@ describe("handlers", () => {
   test("immediately unpacks if key ends in slash", async () => {
     const fixture = createFixture();
     const jsonFile = await fixture.get("bar.json");
-    const data = await handleExtension(
-      fixture,
-      jsonFile,
-      "bar.json/",
-      handlers
-    );
+    const data = await handleExtension(jsonFile, "bar.json/", fixture);
     assert.deepEqual(data, { bar: 2 });
   });
 });

package/test/runtime/jsGlobals.test.js

@@ -1,13 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import jsGlobals from "../../src/runtime/jsGlobals.js";
+import jsGlobals from "../../src/project/jsGlobals.js";
 
 describe("jsGlobals", () => {
-  test("wraps static methods to drop the call target", async () => {
-    const { Promise: fixture } = jsGlobals;
-    const target = {};
-    const promise = fixture.resolve.call(target, "hi");
-    const value = await promise;
+  test("wraps static methods to bind them to defining object", async () => {
+    const all = jsGlobals.Promise.all;
+    const value = await all([Promise.resolve("hi")]);
     assert.equal(value, "hi");
   });
 

package/test/runtime/mergeTrees.test.js

@@ -7,8 +7,7 @@ describe("mergeTrees", () => {
   test("if all arguments are plain objects, result is a plain object", async () => {
     let calledFoo = false;
     let calledBar = false;
-    const result = await mergeTrees.call(
-      null,
+    const result = await mergeTrees(
       {
         a: 1,
         b: 2,
@@ -42,8 +41,7 @@ describe("mergeTrees", () => {
   });
 
   test("merges heterogenous arguments as trees", async () => {
-    const tree = await mergeTrees.call(
-      null,
+    const tree = await mergeTrees(
       new ObjectTree({
         a: 1,
         b: 2,