@weborigami/language 0.0.69 → 0.0.71-beta.1

package/test/compiler/stripCodeLocations.js

@@ -0,0 +1,18 @@
+import { isPlainObject } from "@weborigami/async-tree";
+
+// For comparison purposes, strip the `location` property added by the parser.
+export function stripCodeLocations(parseResult) {
+  if (Array.isArray(parseResult)) {
+    return parseResult.map(stripCodeLocations);
+  } else if (isPlainObject(parseResult)) {
+    const result = {};
+    for (const key in parseResult) {
+      if (key !== "location") {
+        result[key] = stripCodeLocations(parseResult[key]);
+      }
+    }
+    return result;
+  } else {
+    return parseResult;
+  }
+}

package/test/runtime/ops.test.js

@@ -5,6 +5,20 @@ import { describe, test } from "node:test";
 import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
+  test("ops.cache looks up a value in scope and memoizes it", async () => {
+    let count = 0;
+    const tree = new ObjectTree({
+      get count() {
+        return ++count;
+      },
+    });
+    const code = createCode([ops.cache, "count", {}]);
+    const result = await evaluate.call(tree, code);
+    assert.equal(result, 1);
+    const result2 = await evaluate.call(tree, code);
+    assert.equal(result2, 1);
+  });
+
   test("ops.concat concatenates tree value text", async () => {
     const scope = new ObjectTree({
       name: "world",
@@ -47,20 +61,13 @@ describe("ops", () => {
       message: "Hello",
     });
 
-    const code = createCode([ops.lambda, null, [ops.scope, "message"]]);
+    const code = createCode([ops.lambda, ["_"], [ops.scope, "message"]]);
 
     const fn = await evaluate.call(scope, code);
     const result = await fn.call(scope);
     assert.equal(result, "Hello");
   });
 
-  test("ops.lambda adds input to scope as `_`", async () => {
-    const code = createCode([ops.lambda, null, [ops.scope, "_"]]);
-    const fn = await evaluate.call(null, code);
-    const result = await fn("Hello");
-    assert.equal(result, "Hello");
-  });
-
   test("ops.lambda adds input parameters to scope", async () => {
     const code = createCode([
       ops.lambda,
@@ -73,7 +80,7 @@ describe("ops", () => {
   });
 
   test("ops.lambda function can reference itself with @recurse", async () => {
-    const code = createCode([ops.lambda, null, [ops.scope, "@recurse"]]);
+    const code = createCode([ops.lambda, ["_"], [ops.scope, "@recurse"]]);
     const fn = await evaluate.call(null, code);
     const result = await fn();
     // We're expecting the function to return itself, but testing recursion is

package/test/runtime/taggedTemplate.test.js

@@ -0,0 +1,10 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import taggedTemplate from "../../src/runtime/taggedTemplate.js";
+
+describe("taggedTemplate", () => {
+  test("joins strings and values together", () => {
+    const result = taggedTemplate`a ${"b"} c`;
+    assert.equal(result, "a b c");
+  });
+});