@weborigami/language 0.6.9 → 0.6.10

package/test/runtime/errors.test.js

@@ -0,0 +1,296 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import coreGlobals from "../../src/project/coreGlobals.js";
+import { formatError } from "../../src/runtime/errors.js";
+import evaluate from "../../src/runtime/evaluate.js";
+
+const globals = await coreGlobals();
+
+describe("formatError", () => {
+  describe("ReferenceError", () => {
+    test("identifies an undefined function", async () => {
+      await assertError(
+        `doesntExist()`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"doesntExist" is not in scope.
+evaluating: \x1b[31mdoesntExist\x1b[0m`,
+      );
+    });
+
+    test("identifies the argument that produced an error", async () => {
+      await assertError(
+        `Tree.map(foo, (_) => _)`,
+        `ReferenceError: Tree.map: The map argument wasn't defined.
+"foo" is not in scope.
+For documentation, see https://weborigami.org/builtins/Tree/map
+evaluating: \x1b[31mfoo\x1b[0m`,
+      );
+    });
+
+    test("references the Origami file that produced the error", async () => {
+      await assertError(
+        {
+          text: `foo()`,
+          name: "test.ori",
+          url: "file:///path/to/test.ori",
+        },
+        `ReferenceError: Couldn't find the function or map to execute.
+"foo" is not in scope.
+evaluating: \x1b[31mfoo\x1b[0m
+    at /path/to/test.ori:1:1`,
+      );
+    });
+
+    test("proposes typos using globals", async () => {
+      await assertError(
+        `Mat.max(1, 2)`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"Mat.max" is not in scope.
+Perhaps you intended one of these: Map, Math
+evaluating: \x1B[31mMat.max\x1B[0m`,
+      );
+    });
+
+    test("proposes typos using inherited keys", async () => {
+      await assertError(
+        `
+          {
+            data: 1
+            sub: {
+              date: 2
+              more: {
+                result: datu.toString()
+              }
+            }
+          }.sub.more.result
+        `,
+        `ReferenceError: Couldn't find the function or map to execute.
+"datu.toString" is not in scope.
+Perhaps you intended one of these: data, date
+evaluating: \x1B[31mdatu.toString\x1B[0m
+    at line 7, column 25`,
+      );
+    });
+
+    test("proposes typos using scope keys", async () => {
+      const parent = {
+        "index.ori": "Index page",
+      };
+      await assertError(
+        `index.orj(1, 2, 3)`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"index.orj" is not in scope.
+Perhaps you intended: index.ori
+evaluating: \x1B[31mindex.orj\x1B[0m`,
+        { parent },
+      );
+    });
+
+    test("proposes typos using stack keys", async () => {
+      await assertError(
+        `((userName) => userNme.toString())("Alice")`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"userNme.toString" is not in scope.
+Perhaps you intended: userName
+evaluating: \x1B[31muserNme.toString\x1B[0m`,
+      );
+    });
+
+    test("suggests spaces around math operations", async () => {
+      await assertError(
+        `(1+2).toString()`,
+        `ReferenceError: Tried to get a property of something that doesn't exist.
+"1+2" is not in scope.
+If you intended a math operation, Origami requires spaces around the operator: "1 + 2"
+evaluating: \x1B[31m1+2\x1B[0m`,
+      );
+    });
+
+    test("suggests angle brackets for global with extensions", async () => {
+      // code with error: [ops.property, Performance, "ori"]
+      await assertError(
+        `performance.ori()`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"performance" is a global, but "ori" looks like a file extension.
+If you intended to reference a file, use angle brackets: <performance.ori>
+evaluating: \x1B[31mperformance.ori\x1B[0m`,
+      );
+    });
+
+    test("suggests angle brackets for property of global with extensions", async () => {
+      // code with error: [ops.property, Performance, "html"]
+      await assertError(
+        `(performance.html).toString()`,
+        `ReferenceError: Tried to get a property of something that doesn't exist.
+"performance" is a global, but "html" looks like a file extension.
+If you intended to reference a file, use angle brackets: <performance.html>
+evaluating: \x1B[31mperformance.html\x1B[0m`,
+      );
+    });
+
+    test("suggests angle brackets for accidental local key", async () => {
+      // code with error: [ops.property, [[ops.inherited, 0], "posts"], ".ori"]
+      await assertError(
+        `{
+        posts: {}
+        index.html: posts.ori()
+      }`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"posts.ori" looks like a file reference, but is matching the local object property "posts".
+If you intended to reference a file, use angle brackets: <posts.ori>
+evaluating: \x1B[31mposts.ori\x1B[0m
+    at line 3, column 21`,
+      );
+    });
+
+    test("suggests angle brackets for accidental local parameter", async () => {
+      // code with error: [ops.property, [[ops.inherited, 0], "posts"], ".ori"]
+      await assertError(
+        `((posts) => posts.ori())(1)`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"posts.ori" looks like a file reference, but is matching the local parameter "posts".
+If you intended to reference a file, use angle brackets: <posts.ori>
+evaluating: \x1B[31mposts.ori\x1B[0m`,
+      );
+    });
+
+    test("suggests angle brackets for property of accidental local key", async () => {
+      // code with error: [ops.property, [[ops.inherited, 0], "posts"], "md"]
+      await assertError(
+        `{
+        posts: {}
+        index.html: (posts.md).toString()
+      }`,
+        `ReferenceError: Tried to get a property of something that doesn't exist.
+"posts.md" looks like a file reference, but is matching the local object property "posts".
+If you intended to reference a file, use angle brackets: <posts.md>
+evaluating: \x1B[31mposts.md\x1B[0m
+    at line 3, column 22`,
+      );
+    });
+
+    test("handles a traversal failure inside a reference error", async () => {
+      const parent = {
+        post1: {
+          title: "First post",
+        },
+      };
+      await assertError(
+        `(post1/totle).toUpperCase()`,
+        `ReferenceError: Tried to get a property of something that doesn't exist.
+This path returned undefined: post1/totle
+evaluating: \x1B[31mpost1/totle\x1B[0m`,
+        { parent },
+      );
+    });
+
+    test("suggests a fully-qualified name", async () => {
+      await assertError(
+        `repeat(3, "hi")`,
+        `ReferenceError: Couldn't find the function or map to execute.
+"repeat" is not in scope.
+Perhaps you intended: Origami.repeat
+evaluating: \x1B[31mrepeat\x1B[0m`,
+      );
+    });
+  });
+
+  describe("TraverseError", () => {
+    test("suggests typos for failed path", async () => {
+      const parent = {
+        a: {
+          b: {
+            sub: {
+              // need 2+ characters for typos
+              c: 1,
+            },
+          },
+        },
+      };
+      await assertError(
+        `a/b/sup/c`,
+        `TraverseError: A path hit a null or undefined value.
+The path traversal ended unexpectedly at: a/b/sup/
+Perhaps you intended: sub/
+evaluating: \x1B[31msup/\x1B[0m`,
+        { parent },
+      );
+    });
+
+    test("identifies when a numeric key failed", async () => {
+      const parent = {
+        map: new Map([[1, new Map([["a", true]])]]),
+      };
+      await assertError(
+        `map/1/a`,
+        `TraverseError: A path hit a null or undefined value.
+The path traversal ended unexpectedly at: map/1/
+Slash-separated keys are searched as strings. Here there's no string "1" key, but there is a number 1 key.
+To get the value for that number key, use parentheses: map/(1)
+evaluating: \x1B[31m1/\x1B[0m`,
+        { parent },
+      );
+    });
+
+    test("identifies when a value couldn't be unpacked due to a missing extension handler", async () => {
+      const parent = {
+        "file.foo": Uint8Array.from("hello"),
+      };
+      await assertError(
+        `file.foo/bar`,
+        `TraverseError: A path hit binary file data that can't be unpacked.
+The path traversal ended unexpectedly at: file.foo/
+The value couldn't be unpacked because no file extension handler is registered for ".foo".
+evaluating: \x1B[31mfile.foo/\x1B[0m`,
+        { parent },
+      );
+    });
+
+    test("identifies when a value didn't need to be unpacked", async () => {
+      const parent = {
+        a: {
+          b: 1,
+        },
+      };
+      await assertError(
+        `a/b/`,
+        `TraverseError: A path tried to unpack data that's already unpacked.
+The path traversal ended unexpectedly at: a/b/
+You can drop the trailing slash and just use: b
+evaluating: \x1B[31mb/\x1B[0m`,
+        { parent },
+      );
+    });
+
+    test("identifies when a value didn't exist to be unpacked", async () => {
+      const parent = {
+        a: {},
+      };
+      await assertError(
+        `a/b/`,
+        `TraverseError: A path tried to unpack a value that doesn't exist.
+The path traversal ended unexpectedly at: a/b/
+evaluating: \x1B[31mb/\x1B[0m`,
+        { parent },
+      );
+    });
+  });
+});
+
+async function assertError(source, expectedMessage, options) {
+  try {
+    await evaluate(source, {
+      globals,
+      object: null,
+      parent: {},
+      stack: [],
+      ...options,
+    });
+  } catch (/** @type {any} */ error) {
+    const actualMessage = await formatError(error);
+    assert.strictEqual(actualMessage, expectedMessage);
+    return;
+  }
+
+  throw new Error("Expected an error to be thrown");
+}

package/test/runtime/evaluate.test.js

@@ -1,41 +1,117 @@
+import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-
-import { SyncMap } from "@weborigami/async-tree";
 import evaluate from "../../src/runtime/evaluate.js";
-import { createCode } from "../compiler/codeHelpers.js";
+
+const globals = {
+  concat: (...args) => args.join(""),
+  greet: (name) => `Hello, ${name}!`,
+  name: "Alice",
+};
 
 describe("evaluate", () => {
-  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(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/async-tree").SyncOrAsyncMap} */
-    const fn = function () {
-      return this;
-    };
-    fn.containerAsTarget = true;
-    const parent = new SyncMap();
-    const state = { parent };
-    const code = createCode([fn]);
-    const result = await evaluate(code, state);
-    assert.equal(result, parent);
+  test("array", async () => {
+    await assertEvaluation("[]", []);
+    await assertEvaluation("[ 1, 2, 3, ]", [1, 2, 3]);
+    await assertEvaluation("[\n'a'\n'b'\n'c'\n]", ["a", "b", "c"]);
+  });
+
+  test("functionComposition", async () => {
+    await assertEvaluation("greet()", "Hello, undefined!");
+    await assertEvaluation("greet(name)", "Hello, Alice!");
+    await assertEvaluation("greet 'world'", "Hello, world!", { mode: "shell" });
+  });
+
+  test("function call with spread", async () => {
+    await assertEvaluation(
+      `concat("Hello", ...[", ", name], "!")`,
+      "Hello, Alice!",
+    );
+  });
+
+  test("angle bracket path", async () => {
+    await assertEvaluation("<data>", "Bob", {
+      parent: {
+        data: "Bob",
+      },
+    });
+  });
+
+  test("object literal", async () => {
+    await assertEvaluation("{ message = greet(name) }", {
+      message: "Hello, Alice!",
+    });
+    await assertEvaluation(
+      "{ message = greet(name) }",
+      {
+        message: "Hello, Alice!",
+      },
+      { mode: "shell" },
+    );
+  });
+
+  test("object with computed property key", async () => {
+    await assertEvaluation("{ [name] = greet(name) }", {
+      Alice: "Hello, Alice!",
+    });
+  });
+
+  test("number", async () => {
+    await assertEvaluation("1", 1);
+    await assertEvaluation("3.14159", 3.14159);
+    await assertEvaluation("-1", -1);
+  });
+
+  test("sync object", async () => {
+    await assertEvaluation("{a:1, b:2}", { a: 1, b: 2 });
+    await assertEvaluation("{ a: { b: { c: 0 } } }", { a: { b: { c: 0 } } });
+  });
+
+  test("templateLiteral", async () => {
+    await assertEvaluation("`Hello, ${name}!`", "Hello, Alice!");
+    await assertEvaluation(
+      "`escape characters with \\`backslash\\``",
+      "escape characters with `backslash`",
+    );
+  });
+
+  test("merge", async () => {
+    {
+      assertEvaluation(
+        `
+        {
+          a: 1
+          ...more
+          c: a
+        }
+      `,
+        {
+          a: 1,
+          b: 2,
+          c: 1,
+        },
+        {
+          globals: {
+            more: {
+              b: 2,
+            },
+          },
+        },
+      );
+    }
   });
 });
+
+async function assertEvaluation(text, expected, options = {}) {
+  let result = await evaluate(text, {
+    globals,
+    ...options,
+  });
+  if (result instanceof Function) {
+    result = await result();
+  }
+  if (Tree.isMaplike(result)) {
+    result = await Tree.plain(result);
+  }
+  assert.deepEqual(result, expected);
+}

package/test/runtime/execute.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+
+import { SyncMap } from "@weborigami/async-tree";
+import execute from "../../src/runtime/execute.js";
+import { createCode } from "../compiler/codeHelpers.js";
+
+describe("execute", () => {
+  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 execute(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 execute(code, state);
+    assert.equal(result, state);
+  });
+
+  test("if function has parentAsTarget, it gets bound to state.container", async () => {
+    /** @this {import("@weborigami/async-tree").SyncOrAsyncMap} */
+    const fn = function () {
+      return this;
+    };
+    fn.parentAsTarget = true;
+    const parent = new SyncMap();
+    const state = { parent };
+    const code = createCode([fn]);
+    const result = await execute(code, state);
+    assert.equal(result, parent);
+  });
+});

package/test/runtime/expressionObject.test.js

@@ -41,7 +41,7 @@ describe("expressionObject", () => {
   test("can instantiate an Origami tree", async () => {
     const entries = [
       ["name", "world"],
-      ["message", [ops.concat, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
+      ["message", [ops.deepText, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
     ];
     const context = new SyncMap();
     const object = await expressionObject(entries, { object: context });
@@ -56,7 +56,7 @@ describe("expressionObject", () => {
     const entries = [
       [
         [
-          ops.concat,
+          ops.deepText,
           [
             [ops.inherited, 0],
             [ops.literal, "name"], // references `name` on same object
@@ -103,7 +103,7 @@ describe("expressionObject", () => {
       // Immediate maplike value, should have a slash
       ["object", [ops.object, ["b", [ops.literal, 2]]]],
       // Computed key
-      [[ops.concat, [ops.array, "data", ".json"]], 1],
+      [[ops.deepText, [ops.array, "data", ".json"]], 1],
     ];
     const object = await expressionObject(entries);
     assert.deepEqual(object[symbols.keys](), [