@weborigami/language 0.0.73 → 0.1.0

package/test/runtime/fixtures/templates/greet.orit

@@ -1,4 +1,4 @@
 Greetings:
 
-{{ @map(=`Hello, {{ _ }}.
+{{ map(=`Hello, {{ _ }}.
 `)(names.yaml) }}

package/test/runtime/{extensions.test.js → handlers.test.js}

@@ -1,9 +1,9 @@
 import { ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { handleExtension } from "../../src/runtime/extensions.js";
+import { handleExtension } from "../../src/runtime/handlers.js";
 
-describe("extensions", () => {
+describe("handlers", () => {
   test("attaches an unpack method to a value with an extension", async () => {
     const fixture = createFixture();
     const numberValue = await fixture.get("foo");

package/test/runtime/ops.test.js

@@ -11,6 +11,17 @@ describe("ops", () => {
     assert.deepEqual(result, [1, 2, 3]);
   });
 
+  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.equal(result, 1);
+  });
+
   test("ops.cache looks up a value in scope and memoizes it", async () => {
     let count = 0;
     const tree = new ObjectTree({
@@ -36,18 +47,6 @@ describe("ops", () => {
     assert.equal(result, "Hello, world.");
   });
 
-  test("ops.constructor returns a constructor", async () => {
-    const scope = new ObjectTree({
-      "@js": {
-        Number: Number,
-      },
-    });
-    const fn = await ops.constructor.call(scope, "@js", "Number");
-    const number = fn("1");
-    assert(number instanceof Number);
-    assert.equal(number, 1);
-  });
-
   test("ops.inherited searches inherited scope", async () => {
     const parent = new ObjectTree({
       a: 1, // This is the inherited value we want

package/test/runtime/typos.test.js

@@ -0,0 +1,21 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { isTypo, typos } from "../../src/runtime/typos.js";
+
+describe("typos", () => {
+  test("isTypo", () => {
+    assert(isTypo("cat", "bat")); // substitution
+    assert(isTypo("cat", "cats")); // insertion
+    assert(isTypo("cat", "cast")); // insertion
+    assert(isTypo("cat", "at")); // deletion
+    assert(isTypo("cat", "ca")); // deletion
+    assert(isTypo("cat", "cta")); // transposition
+    assert(isTypo("cat", "act")); // transposition
+    assert(!isTypo("cat", "dog")); // more than 1 edit
+  });
+
+  test("typos", () => {
+    const result = typos("cas", ["ask", "cat", "cast", "cats", "cart"]);
+    assert.deepEqual(result, ["cat", "cast", "cats"]);
+  });
+});

package/src/runtime/formatError.js

@@ -1,56 +0,0 @@
-// Text we look for in an error stack to guess whether a given line represents a
-
-import codeFragment from "./codeFragment.js";
-
-// function in the Origami source code.
-const origamiSourceSignals = [
-  "async-tree/src/",
-  "language/src/",
-  "origami/src/",
-  "at Scope.evaluate",
-];
-
-/**
- * Format an error for display in the console.
- *
- * @param {Error} error
- */
-export default function formatError(error) {
-  let message;
-  if (error.stack) {
-    // Display the stack only until we reach the Origami source code.
-    message = "";
-    let lines = error.stack.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (maybeOrigamiSourceCode(line)) {
-        break;
-      }
-      if (message) {
-        message += "\n";
-      }
-      message += lines[i];
-    }
-  } else {
-    message = error.toString();
-  }
-
-  // Add location
-  let location = /** @type {any} */ (error).location;
-  if (location) {
-    const fragment = codeFragment(location);
-    let { source, start } = location;
-
-    message += `\nevaluating: ${fragment}`;
-    if (typeof source === "object" && source.url) {
-      message += `\n    at ${source.url.href}:${start.line}:${start.column}`;
-    } else if (source.text.includes("\n")) {
-      message += `\n    at line ${start.line}, column ${start.column}`;
-    }
-  }
-  return message;
-}
-
-export function maybeOrigamiSourceCode(text) {
-  return origamiSourceSignals.some((signal) => text.includes(signal));
-}