@weborigami/language 0.3.3-jse.2 → 0.3.3-jse.3

package/test/runtime/evaluate.test.js

@@ -8,7 +8,7 @@ import { createCode } from "../compiler/codeHelpers.js";
 
 describe("evaluate", () => {
   test("can retrieve values from scope", async () => {
-    const code = createCode([ops.scope, "message"]);
+    const code = createCode([[ops.scope], "message"]);
     const parent = new ObjectTree({
       message: "Hello",
     });
@@ -21,8 +21,8 @@ describe("evaluate", () => {
   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"],
+      [[ops.scope], "greet"],
+      [[ops.scope], "name"],
     ]);
 
     const tree = new ObjectTree({
@@ -37,7 +37,7 @@ describe("evaluate", () => {
   });
 
   test("passes context to invoked functions", async () => {
-    const code = createCode([ops.scope, "fn"]);
+    const code = createCode([[ops.scope], "fn"]);
     const tree = new ObjectTree({
       async fn() {
         assert.equal(this, tree);
@@ -46,14 +46,6 @@ describe("evaluate", () => {
     await evaluate.call(tree, code);
   });
 
-  test("evaluates a function with fixed number of arguments", async () => {
-    const fn = (x, y) => ({
-      c: `${x}${y}c`,
-    });
-    const code = createCode([ops.traverse, fn, "a", "b", "c"]);
-    assert.equal(await evaluate.call(null, code), "abc");
-  });
-
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
     const packed = new String();
@@ -62,12 +54,4 @@ describe("evaluate", () => {
     const result = await evaluate.call(null, code);
     assert.equal(result, "a,b,c");
   });
-
-  test("by defalut sets the parent of a returned tree to the current tree", async () => {
-    const fn = () => new ObjectTree({});
-    const code = createCode([fn]);
-    const tree = new ObjectTree({});
-    const result = await evaluate.call(tree, code);
-    assert.equal(result.parent, tree);
-  });
 });

package/test/runtime/expressionObject.test.js

@@ -12,8 +12,8 @@ describe("expressionObject", () => {
     });
 
     const entries = [
-      ["hello", [[ops.scope, "upper"], "hello"]],
-      ["world", [[ops.scope, "upper"], "world"]],
+      ["hello", [[[ops.scope], "upper"], "hello"]],
+      ["world", [[[ops.scope], "upper"], "world"]],
     ];
 
     const object = await expressionObject(entries, scope);
@@ -40,7 +40,7 @@ describe("expressionObject", () => {
   test("can instantiate an Origami tree", async () => {
     const entries = [
       ["name", "world"],
-      ["message", [ops.concat, "Hello, ", [ops.scope, "name"], "!"]],
+      ["message", [ops.concat, "Hello, ", [[ops.scope], "name"], "!"]],
     ];
     const parent = new ObjectTree({});
     const object = await expressionObject(entries, parent);
@@ -53,7 +53,8 @@ describe("expressionObject", () => {
 
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
-    const parent = new ObjectTree({
+    const parent = new ObjectTree({});
+    parent.handlers = new ObjectTree({
       "json.handler": {
         unpack: JSON.parse,
       },

package/test/runtime/handlers.test.js

@@ -3,6 +3,12 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import { handleExtension } from "../../src/runtime/handlers.js";
 
+const handlers = new ObjectTree({
+  "json.handler": {
+    unpack: (buffer) => JSON.parse(String(buffer)),
+  },
+});
+
 describe("handlers", () => {
   test("attaches an unpack method to a value with an extension", async () => {
     const fixture = createFixture();
@@ -10,7 +16,12 @@ describe("handlers", () => {
     assert(typeof numberValue === "number");
     assert.equal(numberValue, 1);
     const jsonFile = await fixture.get("bar.json");
-    const withHandler = await handleExtension(fixture, jsonFile, "bar.json");
+    const withHandler = await handleExtension(
+      fixture,
+      jsonFile,
+      "bar.json",
+      handlers
+    );
     assert.equal(String(withHandler), `{ "bar": 2 }`);
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });
@@ -19,21 +30,19 @@ 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/");
+    const data = await handleExtension(
+      fixture,
+      jsonFile,
+      "bar.json/",
+      handlers
+    );
     assert.deepEqual(data, { bar: 2 });
   });
 });
 
 function createFixture() {
-  const parent = new ObjectTree({
-    "json.handler": {
-      unpack: (buffer) => JSON.parse(String(buffer)),
-    },
-  });
-  let tree = new ObjectTree({
+  return new ObjectTree({
     foo: 1, // No extension, should be left alone
     "bar.json": `{ "bar": 2 }`,
   });
-  tree.parent = parent;
-  return tree;
 }

package/test/runtime/mergeTrees.test.js

@@ -41,11 +41,6 @@ describe("mergeTrees", () => {
     });
   });
 
-  test("if all arguments are arrays, result is an array", async () => {
-    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
-    assert.deepEqual(result, [1, 2, 3, 4]);
-  });
-
   test("merges heterogenous arguments as trees", async () => {
     const tree = await mergeTrees.call(
       null,

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, ObjectTree } from "@weborigami/async-tree";
+import { DeepObjectTree, ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -42,17 +42,6 @@ describe("ops", () => {
     assert.strictEqual(ops.bitwiseXor(5, 3), 6);
   });
 
-  test("ops.builtin gets a value from the top of the scope chain", async () => {
-    const root = new ObjectTree({
-      a: 1,
-    });
-    const tree = new ObjectTree({});
-    tree.parent = root;
-    const code = createCode([ops.builtin, "a"]);
-    const result = await evaluate.call(tree, code);
-    assert.strictEqual(result, 1);
-  });
-
   test("ops.comma returns the last value", async () => {
     const code = createCode([ops.comma, 1, 2, 3]);
     const result = await evaluate.call(null, code);
@@ -64,7 +53,12 @@ describe("ops", () => {
       name: "world",
     });
 
-    const code = createCode([ops.concat, "Hello, ", [ops.scope, "name"], "."]);
+    const code = createCode([
+      ops.concat,
+      "Hello, ",
+      [[ops.scope], "name"],
+      ".",
+    ]);
 
     const result = await evaluate.call(scope, code);
     assert.strictEqual(result, "Hello, world.");
@@ -84,27 +78,18 @@ describe("ops", () => {
     assert.equal(await ops.construct(String, "hello"), "hello");
   });
 
-  test("ops.document", async () => {
-    const code = createCode([
-      ops.document,
-      {
-        a: 1,
+  test("ops.context", async () => {
+    const tree = new DeepObjectTree({
+      a: {
+        b: {
+          c: {},
+        },
       },
-      [
-        ops.lambda,
-        [["_"]],
-        [
-          ops.templateIndent,
-          [ops.literal, ["a = ", ""]],
-          [ops.concat, [ops.scope, "a"]],
-        ],
-      ],
-    ]);
-    const result = await evaluate.call(null, code);
-    assert.deepEqual(result, {
-      a: 1,
-      "@text": "a = 1",
     });
+    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 () => {
@@ -127,20 +112,21 @@ describe("ops", () => {
     assert.strictEqual(ops.exponentiation(2, 0), 1);
   });
 
-  test("ops.external evaluates code and cache its result", async () => {
+  test("ops.cache evaluates code and cache its result", async () => {
     let count = 0;
     const tree = new DeepObjectTree({
       group: {
         get count() {
-          return ++count;
+          // Use promise to test async behavior
+          return Promise.resolve(++count);
         },
       },
     });
     const code = createCode([
-      ops.external,
-      "group/count",
-      [ops.traverse, [ops.scope, "group"], [ops.literal, "count"]],
+      ops.cache,
       {},
+      "group/count",
+      [[ops.scope], [ops.literal, "group"], [ops.literal, "count"]],
     ]);
     const result = await evaluate.call(tree, code);
     assert.strictEqual(result, 1);
@@ -148,6 +134,26 @@ describe("ops", () => {
     assert.strictEqual(result2, 1);
   });
 
+  describe("ops.flat", () => {
+    test("flattens arrays", async () => {
+      assert.deepEqual(await ops.flat(1, 2, [3]), [1, 2, 3]);
+    });
+
+    test("flattens treelike objects", async () => {
+      const object = {
+        a: 1,
+        b: 2,
+      };
+      const tree = new ObjectTree({
+        c: 3,
+        d: 4,
+      });
+      const array = [5, 6];
+      const result = await ops.flat(object, tree, array);
+      assert.deepEqual(result, [1, 2, 3, 4, 5, 6]);
+    });
+  });
+
   test("ops.greaterThan", () => {
     assert(ops.greaterThan(5, 3));
     assert(!ops.greaterThan(3, 3));
@@ -160,20 +166,6 @@ describe("ops", () => {
     assert(ops.greaterThanOrEqual("ab", "aa"));
   });
 
-  test("ops.inherited searches inherited scope", async () => {
-    const parent = new ObjectTree({
-      a: 1, // This is the inherited value we want
-    });
-    /** @type {any} */
-    const child = new ObjectTree({
-      a: 2, // Should be ignored
-    });
-    child.parent = parent;
-    const code = createCode([ops.inherited, "a"]);
-    const result = await evaluate.call(child, code);
-    assert.strictEqual(result, 1);
-  });
-
   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);
@@ -186,7 +178,7 @@ describe("ops", () => {
       message: "Hello",
     });
 
-    const code = createCode([ops.lambda, ["_"], [ops.scope, "message"]]);
+    const code = createCode([ops.lambda, ["_"], [[ops.scope], "message"]]);
 
     const fn = await evaluate.call(scope, code);
     const result = await fn.call(scope);
@@ -200,7 +192,7 @@ describe("ops", () => {
         [ops.literal, "a"],
         [ops.literal, "b"],
       ],
-      [ops.concat, [ops.scope, "b"], [ops.scope, "a"]],
+      [ops.concat, [[ops.scope], "b"], [[ops.scope], "a"]],
     ]);
     const fn = await evaluate.call(null, code);
     const result = await fn("x", "y");
@@ -254,40 +246,31 @@ describe("ops", () => {
   test("ops.merge", async () => {
     // {
     //   a: 1
-    //   …fn(a)
-    // }
-    const scope = new ObjectTree({
-      fn: (a) => ({ b: 2 * a }),
-    });
-    const code = createCode([
-      ops.merge,
-      [ops.object, ["a", [ops.literal, 1]]],
-      [
-        [ops.builtin, "fn"],
-        [ops.scope, "a"],
-      ],
-    ]);
-    const result = await evaluate.call(scope, code);
-    assert.deepEqual(result, { a: 1, b: 2 });
-  });
-
-  test("ops.merge lets all direct properties see each other", async () => {
-    // {
-    //   a: 1
-    //   ...more
+    //   …more
     //   c: a
     // }
     const scope = new ObjectTree({
       more: { b: 2 },
     });
     const code = createCode([
-      ops.merge,
-      [ops.object, ["a", [ops.literal, 1]]],
-      [ops.scope, "more"],
-      [ops.object, ["c", [ops.scope, "a"]]],
+      [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["c", [[ops.context], "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"]]]],
+          ],
+        ],
+      ],
+      "_result",
     ]);
     const result = await evaluate.call(scope, code);
-    assert.deepEqual(result, { a: 1, b: 2, c: 1 });
+    assert.deepEqual(await Tree.plain(result), { a: 1, b: 2, c: 1 });
   });
 
   test("ops.multiplication multiplies two numbers", async () => {
@@ -334,8 +317,8 @@ describe("ops", () => {
 
     const code = createCode([
       ops.object,
-      ["hello", [[ops.scope, "upper"], "hello"]],
-      ["world", [[ops.scope, "upper"], "world"]],
+      ["hello", [[[ops.scope], "upper"], "hello"]],
+      ["world", [[[ops.scope], "upper"], "world"]],
     ]);
 
     const result = await evaluate.call(scope, code);
@@ -351,7 +334,7 @@ describe("ops", () => {
       ops.array,
       "Hello",
       1,
-      [[ops.scope, "upper"], "world"],
+      [[[ops.scope], "upper"], "world"],
     ]);
     const result = await evaluate.call(scope, code);
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
@@ -364,6 +347,35 @@ describe("ops", () => {
     assert.strictEqual(ops.remainder(-4, 2), -0);
   });
 
+  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 () => {
+      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);
+      assert.equal(await scope.get("c"), 1);
+    });
+  });
+
   test("ops.shiftLeft", () => {
     assert.strictEqual(ops.shiftLeft(5, 2), 20);
   });