@weborigami/language 0.5.5 → 0.5.7

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/{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,

package/test/runtime/ops.test.js

@@ -21,7 +21,7 @@ describe("ops", () => {
 
   test("ops.array creates an array", async () => {
     const code = createCode([ops.array, 1, 2, 3]);
-    const result = await evaluate.call(null, code);
+    const result = await evaluate(code);
     assert.deepEqual(result, [1, 2, 3]);
   });
 
@@ -44,23 +44,22 @@ describe("ops", () => {
 
   test("ops.comma returns the last value", async () => {
     const code = createCode([ops.comma, 1, 2, 3]);
-    const result = await evaluate.call(null, code);
+    const result = await evaluate(code);
     assert.strictEqual(result, 3);
   });
 
   test("ops.concat concatenates tree value text", async () => {
-    const scope = new ObjectTree({
+    const container = {
       name: "world",
-    });
-
+    };
     const code = createCode([
       ops.concat,
       "Hello, ",
-      [[ops.scope], "name"],
+      [[ops.scope, container], "name"],
       ".",
     ]);
 
-    const result = await evaluate.call(scope, code);
+    const result = await evaluate(code);
     assert.strictEqual(result, "Hello, world.");
   });
 
@@ -78,20 +77,6 @@ describe("ops", () => {
     assert.equal(await ops.construct(String, "hello"), "hello");
   });
 
-  test("ops.context", async () => {
-    const tree = new DeepObjectTree({
-      a: {
-        b: {
-          c: {},
-        },
-      },
-    });
-    const b = await Tree.traverse(tree, "a", "b");
-    const c = await b.get("c");
-    assert.equal(ops.context.call(c), c);
-    assert.equal(ops.context.call(c, 1), b);
-  });
-
   test("ops.division divides two numbers", async () => {
     assert.strictEqual(ops.division(12, 2), 6);
     assert.strictEqual(ops.division(3, 2), 1.5);
@@ -114,23 +99,27 @@ describe("ops", () => {
 
   test("ops.cache evaluates code and cache its result", async () => {
     let count = 0;
-    const tree = new DeepObjectTree({
+    const container = {
       group: {
         get count() {
           // Use promise to test async behavior
           return Promise.resolve(++count);
         },
       },
-    });
+    };
     const code = createCode([
       ops.cache,
       {},
       "group/count",
-      [[ops.scope], [ops.literal, "group"], [ops.literal, "count"]],
+      [
+        [ops.scope, container],
+        [ops.literal, "group"],
+        [ops.literal, "count"],
+      ],
     ]);
-    const result = await evaluate.call(tree, code);
+    const result = await evaluate(code);
     assert.strictEqual(result, 1);
-    const result2 = await evaluate.call(tree, code);
+    const result2 = await evaluate(code);
     assert.strictEqual(result2, 1);
   });
 
@@ -166,22 +155,36 @@ describe("ops", () => {
     assert(ops.greaterThanOrEqual("ab", "aa"));
   });
 
+  test("ops.inherited walks up the object parent chain", async () => {
+    const tree = new DeepObjectTree({
+      a: {
+        b: {},
+      },
+    });
+    const b = await Tree.traverse(tree, "a", "b");
+    assert.equal(await ops.inherited(2, { object: b }), tree);
+  });
+
   test("ops.lambda defines a function with no inputs", async () => {
     const code = createCode([ops.lambda, [], [ops.literal, "result"]]);
-    const fn = await evaluate.call(null, code);
-    const result = await fn.call();
+    const fn = await evaluate(code);
+    const result = await fn();
     assert.strictEqual(result, "result");
   });
 
   test("ops.lambda defines a function with underscore input", async () => {
-    const scope = new ObjectTree({
+    const container = {
       message: "Hello",
-    });
+    };
 
-    const code = createCode([ops.lambda, ["_"], [[ops.scope], "message"]]);
+    const code = createCode([
+      ops.lambda,
+      ["_"],
+      [[ops.scope, container], "message"],
+    ]);
 
-    const fn = await evaluate.call(scope, code);
-    const result = await fn.call(scope);
+    const fn = await evaluate(code);
+    const result = await fn();
     assert.strictEqual(result, "Hello");
   });
 
@@ -192,9 +195,9 @@ describe("ops", () => {
         [ops.literal, "a"],
         [ops.literal, "b"],
       ],
-      [ops.concat, [[ops.scope], "b"], [[ops.scope], "a"]],
+      [ops.concat, [[ops.params, 0], "b"], [[ops.params, 0], "a"]],
     ]);
-    const fn = await evaluate.call(null, code);
+    const fn = await evaluate(code);
     const result = await fn("x", "y");
     assert.strictEqual(result, "yx");
   });
@@ -249,27 +252,27 @@ describe("ops", () => {
     //   ...more
     //   c: a
     // }
-    const scope = new ObjectTree({
+    const container = {
       more: { b: 2 },
-    });
+    };
     const code = createCode([
       [
         ops.object,
         ["a", [ops.literal, 1]],
-        ["c", [[ops.context], "a"]],
+        ["c", [[ops.inherited, 0], "a"]],
         [
           "_result",
           [
             ops.merge,
-            [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
-            [[ops.scope], "more"],
-            [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
+            [ops.object, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
+            [[ops.scope, container], "more"],
+            [ops.object, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
           ],
         ],
       ],
       "_result",
     ]);
-    const result = await evaluate.call(scope, code);
+    const result = await evaluate(code);
     assert.deepEqual(await Tree.plain(result), { a: 1, b: 2, c: 1 });
   });
 
@@ -311,35 +314,44 @@ describe("ops", () => {
   });
 
   test("ops.object instantiates an object", async () => {
-    const scope = new ObjectTree({
+    const container = {
       upper: (s) => s.toUpperCase(),
-    });
+    };
 
     const code = createCode([
       ops.object,
-      ["hello", [[[ops.scope], "upper"], "hello"]],
-      ["world", [[[ops.scope], "upper"], "world"]],
+      ["hello", [[[ops.scope, container], "upper"], "hello"]],
+      ["world", [[[ops.scope, container], "upper"], "world"]],
     ]);
 
-    const result = await evaluate.call(scope, code);
+    const result = await evaluate(code);
     assert.strictEqual(result.hello, "HELLO");
     assert.strictEqual(result.world, "WORLD");
   });
 
   test("ops.object instantiates an array", async () => {
-    const scope = new ObjectTree({
+    const container = {
       upper: (s) => s.toUpperCase(),
-    });
+    };
     const code = createCode([
       ops.array,
       "Hello",
       1,
-      [[[ops.scope], "upper"], "world"],
+      [[[ops.scope, container], "upper"], "world"],
     ]);
-    const result = await evaluate.call(scope, code);
+    const result = await evaluate(code);
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
   });
 
+  test("ops.params returns a stack frame", async () => {
+    const code = createCode([ops.params, 1]);
+    const frame1 = { a: 1 };
+    const frame2 = { b: 2 };
+    const stack = [frame1, frame2];
+    const result = await evaluate(code, { stack });
+    assert.strictEqual(result, frame1);
+  });
+
   test("ops.property returns a property if defined, otherwise traverses", async () => {
     assert.equal(await ops.property({ a: 1 }, "a"), 1);
     assert.equal(await ops.property({ a: 1 }, "b"), undefined);
@@ -355,30 +367,16 @@ describe("ops", () => {
   });
 
   describe("ops.scope", () => {
-    test("returns the scope of the current tree", async () => {
-      const tree = new DeepObjectTree({
-        a: {
-          b: {},
-        },
-        c: 1,
-      });
-      const a = await tree.get("a");
-      const b = await a.get("b");
-      const scope = await ops.scope.call(b);
-      assert.equal(await scope?.get("c"), 1);
-    });
-
-    test("accepts an optional context", async () => {
+    test("returns the scope of the given tree", async () => {
       const tree = new DeepObjectTree({
         a: {
           b: {},
-          c: 0, // shouldn't get this
         },
         c: 1,
       });
       const a = await tree.get("a");
       const b = await a.get("b");
-      const scope = await ops.scope.call(b, tree);
+      const scope = await ops.scope(b);
       assert.equal(await scope?.get("c"), 1);
     });
   });
@@ -439,7 +437,7 @@ describe("ops", () => {
   test("ops.unpack unpacks a value", async () => {
     const fixture = new String("packed");
     /** @type {any} */ (fixture).unpack = async () => "unpacked";
-    const result = await ops.unpack.call(null, fixture);
+    const result = await ops.unpack(fixture);
     assert.strictEqual(result, "unpacked");
   });