@weborigami/language 0.6.9 → 0.6.11

package/test/runtime/ops.test.js

@@ -2,7 +2,8 @@ import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
-import { evaluate, ops } from "../../src/runtime/internal.js";
+import execute from "../../src/runtime/execute.js";
+import { ops } from "../../src/runtime/internal.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
 describe("ops", () => {
@@ -15,13 +16,19 @@ describe("ops", () => {
     assert.strictEqual(ops.addition("hello ", "everyone"), "hello everyone");
     assert.strictEqual(
       ops.addition("2001", ": A Space Odyssey"),
-      "2001: A Space Odyssey"
+      "2001: A Space Odyssey",
     );
   });
 
+  test("ops.apply applies a function to arguments", async () => {
+    const code = createCode([ops.apply, ops.addition, [ops.array, 1, 2]]);
+    const result = await execute(code);
+    assert.strictEqual(result, 3);
+  });
+
   test("ops.array creates an array", async () => {
     const code = createCode([ops.array, 1, 2, 3]);
-    const result = await evaluate(code);
+    const result = await execute(code);
     assert.deepEqual(result, [1, 2, 3]);
   });
 
@@ -44,25 +51,10 @@ describe("ops", () => {
 
   test("ops.comma returns the last value", async () => {
     const code = createCode([ops.comma, 1, 2, 3]);
-    const result = await evaluate(code);
+    const result = await execute(code);
     assert.strictEqual(result, 3);
   });
 
-  test("ops.concat concatenates tree value text", async () => {
-    const container = {
-      name: "world",
-    };
-    const code = createCode([
-      ops.concat,
-      "Hello, ",
-      [[ops.scope, container], "name"],
-      ".",
-    ]);
-
-    const result = await evaluate(code);
-    assert.strictEqual(result, "Hello, world.");
-  });
-
   test("ops.conditional", async () => {
     assert.strictEqual(await ops.conditional(true, trueFn, falseFn), true);
     assert.strictEqual(await ops.conditional(true, falseFn, trueFn), false);
@@ -77,6 +69,21 @@ describe("ops", () => {
     assert.equal(await ops.construct(String, "hello"), "hello");
   });
 
+  test("ops.deepText concatenates tree value text", async () => {
+    const container = {
+      name: "world",
+    };
+    const code = createCode([
+      ops.deepText,
+      "Hello, ",
+      [[ops.scope, container], "name"],
+      ".",
+    ]);
+
+    const result = await execute(code);
+    assert.strictEqual(result, "Hello, world.");
+  });
+
   test("ops.division divides two numbers", async () => {
     assert.strictEqual(ops.division(12, 2), 6);
     assert.strictEqual(ops.division(3, 2), 1.5);
@@ -117,9 +124,9 @@ describe("ops", () => {
         [ops.literal, "count"],
       ],
     ]);
-    const result = await evaluate(code);
+    const result = await execute(code);
     assert.strictEqual(result, 1);
-    const result2 = await evaluate(code);
+    const result2 = await execute(code);
     assert.strictEqual(result2, 1);
   });
 
@@ -183,7 +190,7 @@ describe("ops", () => {
           b: {},
         },
       },
-      { deep: true }
+      { deep: true },
     );
     const b = await Tree.traverse(tree, "a", "b");
     assert.equal(await ops.inherited(2, { object: b }), tree);
@@ -201,7 +208,7 @@ describe("ops", () => {
 
   test("ops.lambda defines a function with no inputs", async () => {
     const code = createCode([ops.lambda, 0, [], [ops.literal, "result"]]);
-    const fn = await evaluate(code);
+    const fn = await execute(code);
     assert.equal(fn.length, 0);
     const result = await fn();
     assert.strictEqual(result, "result");
@@ -219,7 +226,7 @@ describe("ops", () => {
       [[ops.scope, container], "message"],
     ]);
 
-    const fn = await evaluate(code);
+    const fn = await execute(code);
     assert.equal(fn.length, 1);
     const result = await fn();
     assert.strictEqual(result, "Hello");
@@ -233,9 +240,9 @@ describe("ops", () => {
         ["a", [[ops.params, 0], 0]],
         ["b", [[ops.params, 0], 1]],
       ],
-      [ops.concat, [[ops.params, 0], "b"], [[ops.params, 0], "a"]],
+      [ops.deepText, [[ops.params, 0], "b"], [[ops.params, 0], "a"]],
     ]);
-    const fn = await evaluate(code);
+    const fn = await execute(code);
     assert.equal(fn.length, 2);
     const result = await fn("x", "y");
     assert.strictEqual(result, "yx");
@@ -311,7 +318,7 @@ describe("ops", () => {
       ],
       "_result",
     ]);
-    const result = await evaluate(code);
+    const result = await execute(code);
     assert.deepEqual(await Tree.plain(result), { a: 1, b: 2, c: 1 });
   });
 
@@ -335,15 +342,15 @@ describe("ops", () => {
   test("ops.optional", async () => {
     assert.equal(
       ops.optional(null, (x) => x.a),
-      undefined
+      undefined,
     );
     assert.equal(
       ops.optional(undefined, (x) => x.a),
-      undefined
+      undefined,
     );
     assert.equal(
       ops.optional({ a: 1 }, (x) => x.a),
-      1
+      1,
     );
   });
 
@@ -383,7 +390,7 @@ describe("ops", () => {
       ["world", [[[ops.scope, container], "upper"], "world"]],
     ]);
 
-    const result = await evaluate(code);
+    const result = await execute(code);
     assert.strictEqual(result.hello, "HELLO");
     assert.strictEqual(result.world, "WORLD");
   });
@@ -398,7 +405,7 @@ describe("ops", () => {
       1,
       [[[ops.scope, container], "upper"], "world"],
     ]);
-    const result = await evaluate(code);
+    const result = await execute(code);
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
   });
 
@@ -407,7 +414,7 @@ describe("ops", () => {
     const frame1 = { a: 1 };
     const frame2 = { b: 2 };
     const stack = [frame1, frame2];
-    const result = await evaluate(code, { stack });
+    const result = await execute(code, { stack });
     assert.strictEqual(result, frame1);
   });
 
@@ -434,7 +441,7 @@ describe("ops", () => {
           },
           c: 1,
         },
-        { deep: true }
+        { deep: true },
       );
       const a = await tree.get("a");
       const b = await a.get("b");
@@ -481,7 +488,7 @@ describe("ops", () => {
     assert.strictEqual(ops.typeOf(undefined), "undefined");
     assert.strictEqual(
       ops.typeOf(() => null),
-      "function"
+      "function",
     );
   });
 

package/test/runtime/typos.test.js

@@ -13,6 +13,8 @@ describe("typos", () => {
     assert(isTypo("cat", "act")); // transposition
     assert(!isTypo("cat", "dog")); // more than 1 edit
     assert(!isTypo("a", "b")); // single character
+    assert(isTypo("cat", "CAT")); // differ only by case
+    assert(isTypo("café", "cafe")); // differ only by accents
   });
 
   test("typos", () => {