@weborigami/language 0.5.4 → 0.5.6

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 });
   });
 
@@ -280,10 +283,10 @@ describe("ops", () => {
     assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  test("ops.optionalTraverse", async () => {
-    assert.equal(await ops.optionalTraverse(null, "a"), undefined);
-    assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
-  });
+  // test("ops.optionalTraverse", async () => {
+  //   assert.equal(await ops.optionalTraverse(null, "a"), undefined);
+  //   assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
+  // });
 
   test("ops.notEqual", () => {
     assert(!ops.notEqual(1, 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");
   });
 

package/src/runtime/getHandlers.js

@@ -1,10 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-// Return the extension handlers for the given tree
-export default function getHandlers(tree) {
-  if (!tree) {
-    return null;
-  }
-  const root = Tree.root(tree);
-  return /** @type {any} */ (root).handlers;
-}