@weborigami/language 0.0.40 → 0.0.42

package/src/compiler/parserHelpers.js

@@ -8,7 +8,21 @@ export function makeFunctionCall(target, chain) {
   // successively apply the top-level elements of that chain to build up the
   // function composition.
   for (const args of chain) {
-    value = [value, ...args];
+    if (args[0] === ops.traverse) {
+      value = [ops.traverse, value, ...args.slice(1)];
+    } else {
+      value = [value, ...args];
+    }
+  }
+  return value;
+}
+
+// Similar to a function call, but the order is reversed.
+export function makePipeline(steps) {
+  const [first, ...rest] = steps;
+  let value = first;
+  for (const args of rest) {
+    value = [args, value];
   }
   return value;
 }

package/src/runtime/concatTreeValues.js

@@ -4,6 +4,9 @@ import {
   isPlainObject,
 } from "@weborigami/async-tree";
 
+const textDecoder = new TextDecoder();
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+
 /**
  * Concatenate the text values in a tree.
  *
@@ -52,6 +55,9 @@ async function getText(value, scope) {
     text = "";
   } else if (typeof value === "string") {
     text = value;
+  } else if (value instanceof ArrayBuffer || value instanceof TypedArray) {
+    // Serialize data as UTF-8.
+    text = textDecoder.decode(value);
   } else if (
     !(value instanceof Array) &&
     value.toString !== getRealmObjectPrototype(value).toString

package/src/runtime/evaluate.js

@@ -1,7 +1,8 @@
 import { Tree, isPlainObject } from "@weborigami/async-tree";
-import { format, ops } from "./internal.js";
+import { ops } from "./internal.js";
 
-const expressionSymbol = Symbol("expression");
+const codeSymbol = Symbol("code");
+const sourceSymbol = Symbol("source");
 
 /**
  * Evaluate the given code and return the result.
@@ -9,10 +10,9 @@ const expressionSymbol = Symbol("expression");
  * `this` should be the scope used to look up references found in the code.
  *
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../../language/src/compiler/code.js").Code} Code
  *
  * @this {Treelike|null}
- * @param {Code} code
+ * @param {any} code
  */
 export default async function evaluate(code) {
   const scope = this;
@@ -37,22 +37,26 @@ export default async function evaluate(code) {
     );
   }
 
-  // The head of the array is a tree or function, the rest are args or keys.
+  // The head of the array is a function or a tree; the rest are args or keys.
   let [fn, ...args] = evaluated;
 
   if (!fn) {
-    // The code wants to invoke something that's not in scope.
-    throw ReferenceError(
-      `Couldn't find function or tree key: ${format(code[0])}`
+    // The code wants to invoke something that's couldn't be found in scope.
+    throw ReferenceError(`${codeFragment(code[0])} is not defined`);
+  }
+
+  if (
+    !(fn instanceof Function || Tree.isAsyncTree(fn)) &&
+    typeof fn.unpack === "function"
+  ) {
+    // Unpack the object and use the result as the function or tree.
+    fn = await fn.unpack();
+  }
+
+  if (!Tree.isTreelike(fn)) {
+    throw TypeError(
+      `${codeFragment(code[0])} didn't return a function that can be called`
     );
-  } else if (!(fn instanceof Object)) {
-    throw TypeError(`Can't invoke primitive value: ${format(code[0])}`);
-  } else if (!(fn instanceof Function) && typeof fn.unpack === "function") {
-    // The object has a unpack function; see if it returns a function.
-    const unpacked = await fn.unpack();
-    if (unpacked instanceof Function) {
-      fn = unpacked;
-    }
   }
 
   // Execute the function or traverse the tree.
@@ -60,31 +64,37 @@ export default async function evaluate(code) {
   try {
     result =
       fn instanceof Function
-        ? // Invoke the function
-          await fn.call(scope, ...args)
-        : // Traverse the tree.
-          await Tree.traverseOrThrow(fn, ...args);
+        ? await fn.call(scope, ...args) // Invoke the function
+        : await Tree.traverseOrThrow(fn, ...args); // Traverse the tree.
   } catch (/** @type {any} */ error) {
-    const message = `Error triggered by Origami expression: ${format(code)}`;
-    throw new Error(message, { cause: error });
+    if (!error.location) {
+      // Attach the location of the code we were evaluating.
+      error.location = /** @type {any} */ (code).location;
+    }
+    throw error;
   }
 
-  // To aid debugging, add the expression source to the result.
+  // To aid debugging, add the code to the result.
   if (
     result &&
     typeof result === "object" &&
     Object.isExtensible(result) &&
     !isPlainObject(result)
   ) {
-    try {
-      result[expressionSymbol] = format(code);
-    } catch (error) {
-      // Setting a Symbol-keyed property on some objects fails with `TypeError:
-      // Cannot convert a Symbol value to a string` but it's unclear why
-      // implicit casting of the symbol to a string occurs. Since this is not a
-      // vital operation, we ignore such errors.
+    result[codeSymbol] = code;
+    if (/** @type {any} */ (code).location) {
+      result[sourceSymbol] = codeFragment(code);
     }
   }
 
   return result;
 }
+
+function codeFragment(code) {
+  if (code.location) {
+    const { source, start, end } = code.location;
+    return source.text.slice(start.offset, end.offset);
+  } else {
+    return "";
+  }
+}

package/src/runtime/expressionFunction.js

@@ -1,11 +1,11 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 
-import { evaluate, format } from "./internal.js";
+import { evaluate } from "./internal.js";
 
 /**
  * Given parsed Origami code, return a function that executes that code.
  *
- * @param {string|number|Array} code - parsed Origami code
+ * @param {import("../../index.js").Code} code - parsed Origami code
  * @param {string} [name] - optional name of the function
  */
 export function createExpressionFunction(code, name) {
@@ -17,8 +17,7 @@ export function createExpressionFunction(code, name) {
     Object.defineProperty(fn, "name", { value: name });
   }
   fn.code = code;
-  fn.source = format(code);
-  fn.toString = () => fn.source;
+  fn.toString = () => code.source?.text;
   return fn;
 }
 
@@ -27,6 +26,7 @@ export function createExpressionFunction(code, name) {
  * expression.
  *
  * @param {any} obj
+ * @returns {obj is { code: Array }}
  */
 export function isExpressionFunction(obj) {
   return typeof obj === "function" && obj.code;

package/src/runtime/formatError.js

@@ -0,0 +1,52 @@
+// Text we look for in an error stack to guess whether a given line represents a
+// 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 (origamiSourceSignals.some((signal) => line.includes(signal))) {
+        break;
+      }
+      if (message) {
+        message += "\n";
+      }
+      message += lines[i];
+    }
+  } else {
+    message = error.toString();
+  }
+
+  // Add location
+  let location = /** @type {any} */ (error).location;
+  if (location) {
+    let { source, start, end } = location;
+    let fragment = source.text.slice(start.offset, end.offset);
+    if (fragment.length === 0) {
+      // Use entire source.
+      fragment = source.text;
+    }
+    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;
+}

package/src/runtime/internal.js

@@ -11,8 +11,6 @@ export * as ops from "./ops.js";
 
 export { default as evaluate } from "./evaluate.js";
 
-export { default as format } from "./format.js";
-
 export * as expressionFunction from "./expressionFunction.js";
 
 export { default as ExpressionTree } from "./ExpressionTree.js";

package/src/runtime/ops.js

@@ -3,7 +3,7 @@
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  */
 
-import { SiteTree } from "@weborigami/async-tree";
+import { SiteTree, Tree } from "@weborigami/async-tree";
 import FileLoadersTransform from "./FileLoadersTransform.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import Scope from "./Scope.js";
@@ -128,25 +128,53 @@ inherited.toString = () => "«ops.inherited»";
 /**
  * Return a function that will invoke the given code.
  *
- * @typedef {import("../../../language/src/compiler/code.js").Code} Code
+ * @typedef {import("../../index.ts").Code} Code
  * @this {AsyncTree|null}
+ * @param {string[]} parameters
  * @param {Code} code
  */
-export function lambda(code) {
+export function lambda(parameters, code) {
   if (lambdaFnMap.has(code)) {
     return lambdaFnMap.get(code);
   }
+
+  // By default, the first input argument is named `_`.
+  parameters ??= ["_"];
+
   /** @this {AsyncTree|null} */
-  async function invoke(input) {
-    // Add ambients to scope.
-    const ambients = {
-      _: input,
-      "@recurse": invoke,
-    };
+  async function invoke(...args) {
+    // Add arguments and @recurse to scope.
+    const ambients = {};
+    for (const parameter of parameters) {
+      ambients[parameter] = args.shift();
+    }
+    ambients["@recurse"] = invoke;
     const scope = new Scope(ambients, this);
-    const result = await evaluate.call(scope, code);
+
+    let result = await evaluate.call(scope, code);
+
+    // Bind a function result to the scope so that it has access to the
+    // parameter values -- i.e., like a closure.
+    if (result instanceof Function) {
+      const resultCode = result.code;
+      result = result.bind(scope);
+      if (code) {
+        // Copy over Origami code
+        result.code = resultCode;
+      }
+    }
+
     return result;
   }
+
+  // We set the `length` property on the function so that Tree.traverseOrThrow()
+  // will correctly identify how many parameters it wants. This is unorthodox
+  // but doesn't appear to affect other behavior.
+  const fnLength = Object.keys(parameters).length;
+  Object.defineProperty(invoke, "length", {
+    value: fnLength,
+  });
+
   invoke.code = code;
   lambdaFnMap.set(code, invoke);
   return invoke;
@@ -172,6 +200,11 @@ export async function object(...entries) {
 }
 object.toString = () => "«ops.object»";
 
+/**
+ * Traverse a path of keys through a tree.
+ */
+export const traverse = Tree.traverseOrThrow;
+
 /**
  * Construct an tree. This is similar to ops.object but the values are turned
  * into functions rather than being immediately evaluated, and the result is an

package/test/compiler/parse.test.js

@@ -1,3 +1,4 @@
+import { isPlainObject } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
@@ -12,22 +13,10 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("argsChain", () => {
-    assertParse("argsChain", "(a)(b)(c)", [
-      [[ops.scope, "a"]],
-      [[ops.scope, "b"]],
-      [[ops.scope, "c"]],
-    ]);
-    assertParse("argsChain", "(a)/b(c)", [
-      [[ops.scope, "a"]],
-      ["b"],
-      [[ops.scope, "c"]],
-    ]);
-  });
-
   test("array", () => {
     assertParse("array", "[]", [ops.array]);
     assertParse("array", "[1, 2, 3]", [ops.array, 1, 2, 3]);
+    assertParse("array", "[ 1 , 2 , 3 ]", [ops.array, 1, 2, 3]);
   });
 
   test("assignment", () => {
@@ -71,7 +60,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expr", "fn =`x`", [
       [ops.scope, "fn"],
-      [ops.lambda, "x"],
+      [ops.lambda, null, "x"],
     ]);
     assertParse("expr", "copy app(formulas), files 'snapshot'", [
       [ops.scope, "copy"],
@@ -83,9 +72,13 @@ describe("Origami parser", () => {
     ]);
     assertParse("expr", "@map =`<li>{{_}}</li>`", [
       [ops.scope, "@map"],
-      [ops.lambda, [ops.concat, "<li>", [ops.scope, "_"], "</li>"]],
+      [ops.lambda, null, [ops.concat, "<li>", [ops.scope, "_"], "</li>"]],
     ]);
     assertParse("expr", `"https://example.com"`, "https://example.com");
+    assertParse("expr", "'Hello' -> test.orit", [
+      [ops.scope, "test.orit"],
+      "Hello",
+    ]);
   });
 
   test("expression", () => {
@@ -129,30 +122,42 @@ describe("Origami parser", () => {
       [ops.scope, "a"],
       [ops.scope, "b"],
     ]);
+    assertParse("functionComposition", "fn( a , b )", [
+      [ops.scope, "fn"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
     assertParse("functionComposition", "fn()(arg)", [
       [[ops.scope, "fn"], undefined],
       [ops.scope, "arg"],
     ]);
     assertParse("functionComposition", "fn()/key", [
+      ops.traverse,
       [[ops.scope, "fn"], undefined],
       "key",
     ]);
-    assertParse("functionComposition", "tree/", [[ops.scope, "tree"], ""]);
+    assertParse("functionComposition", "tree/", [
+      ops.traverse,
+      [ops.scope, "tree"],
+      "",
+    ]);
     assertParse("functionComposition", "tree/key", [
+      ops.traverse,
       [ops.scope, "tree"],
       "key",
     ]);
     assertParse("functionComposition", "tree/foo/bar", [
+      ops.traverse,
       [ops.scope, "tree"],
       "foo",
       "bar",
     ]);
     assertParse("functionComposition", "tree/key()", [
-      [[ops.scope, "tree"], "key"],
+      [ops.traverse, [ops.scope, "tree"], "key"],
       undefined,
     ]);
     assertParse("functionComposition", "fn()/key()", [
-      [[[ops.scope, "fn"], undefined], "key"],
+      [ops.traverse, [[ops.scope, "fn"], undefined], "key"],
       undefined,
     ]);
     assertParse("functionComposition", "(fn())('arg')", [
@@ -169,39 +174,20 @@ describe("Origami parser", () => {
       [ops.scope, "b"],
     ]);
     assertParse("functionComposition", "{ a: 1, b: 2}/b", [
+      ops.traverse,
       [ops.object, ["a", 1], ["b", 2]],
       "b",
     ]);
-  });
-
-  test("group", () => {
-    assertParse("group", "(hello)", [ops.scope, "hello"]);
-    assertParse("group", "(((nested)))", [ops.scope, "nested"]);
-    assertParse("group", "(fn())", [[ops.scope, "fn"], undefined]);
-  });
-
-  test("host", () => {
-    assertParse("host", "abc", "abc");
-    assertParse("host", "abc:123", "abc:123");
-  });
-
-  test("identifier", () => {
-    assertParse("identifier", "abc", "abc");
-    assertParse("identifier", "index.html", "index.html");
-    assertParse("identifier", "foo\\ bar", "foo bar");
-  });
-
-  test("implicitParensCall", () => {
-    assertParse("implicitParensCall", "fn arg", [
+    assertParse("functionComposition", "fn arg", [
       [ops.scope, "fn"],
       [ops.scope, "arg"],
     ]);
-    assertParse("implicitParensCall", "fn 'a', 'b'", [
+    assertParse("functionComposition", "fn 'a', 'b'", [
       [ops.scope, "fn"],
       "a",
       "b",
     ]);
-    assertParse("implicitParensCall", "fn a(b), c", [
+    assertParse("functionComposition", "fn a(b), c", [
       [ops.scope, "fn"],
       [
         [ops.scope, "a"],
@@ -209,24 +195,51 @@ describe("Origami parser", () => {
       ],
       [ops.scope, "c"],
     ]);
-    assertParse("implicitParensCall", "fn1 fn2 'arg'", [
+    assertParse("functionComposition", "fn1 fn2 'arg'", [
       [ops.scope, "fn1"],
       [[ops.scope, "fn2"], "arg"],
     ]);
-    assertParse("implicitParensCall", "(fn()) 'arg'", [
+    assertParse("functionComposition", "(fn()) 'arg'", [
       [[ops.scope, "fn"], undefined],
       "arg",
     ]);
-    assertParse("implicitParensCall", "https://example.com/tree.yaml 'key'", [
+    assertParse("functionComposition", "tree/key arg", [
+      [ops.traverse, [ops.scope, "tree"], "key"],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("functionComposition", "https://example.com/tree.yaml 'key'", [
       [ops.https, "example.com", "tree.yaml"],
       "key",
     ]);
   });
 
+  test("group", () => {
+    assertParse("group", "(hello)", [ops.scope, "hello"]);
+    assertParse("group", "(((nested)))", [ops.scope, "nested"]);
+    assertParse("group", "(fn())", [[ops.scope, "fn"], undefined]);
+  });
+
+  test("host", () => {
+    assertParse("host", "abc", "abc");
+    assertParse("host", "abc:123", "abc:123");
+  });
+
+  test("identifier", () => {
+    assertParse("identifier", "abc", "abc");
+    assertParse("identifier", "index.html", "index.html");
+    assertParse("identifier", "foo\\ bar", "foo bar");
+    assertParse("identifier", "x-y-z", "x-y-z");
+  });
+
   test("lambda", () => {
-    assertParse("lambda", "=message", [ops.lambda, [ops.scope, "message"]]);
+    assertParse("lambda", "=message", [
+      ops.lambda,
+      null,
+      [ops.scope, "message"],
+    ]);
     assertParse("lambda", "=`Hello, {{name}}.`", [
       ops.lambda,
+      null,
       [ops.concat, "Hello, ", [ops.scope, "name"], "."],
     ]);
   });
@@ -235,7 +248,7 @@ describe("Origami parser", () => {
     assertParse("leadingSlashPath", "/tree/", ["tree", ""]);
   });
 
-  describe("list", () => {
+  test("list", () => {
     assertParse("list", "1", [1]);
     assertParse("list", "1,2,3", [1, 2, 3]);
     assertParse("list", "1, 2, 3,", [1, 2, 3]);
@@ -280,6 +293,37 @@ describe("Origami parser", () => {
     assertParse("objectPropertyOrShorthand", "x: y", ["x", [ops.scope, "y"]]);
   });
 
+  test("parameterizedLambda", () => {
+    assertParse("parameterizedLambda", "() => foo", [
+      ops.lambda,
+      [],
+      [ops.scope, "foo"],
+    ]);
+    assertParse("parameterizedLambda", "(a, b, c) ⇒ fn(a, b, c)", [
+      ops.lambda,
+      ["a", "b", "c"],
+      [
+        [ops.scope, "fn"],
+        [ops.scope, "a"],
+        [ops.scope, "b"],
+        [ops.scope, "c"],
+      ],
+    ]);
+    assertParse("parameterizedLambda", "(a) => (b) => fn(a, b)", [
+      ops.lambda,
+      ["a"],
+      [
+        ops.lambda,
+        ["b"],
+        [
+          [ops.scope, "fn"],
+          [ops.scope, "a"],
+          [ops.scope, "b"],
+        ],
+      ],
+    ]);
+  });
+
   test("parensArgs", () => {
     assertParse("parensArgs", "()", [undefined]);
     assertParse("parensArgs", "(a, b, c)", [
@@ -295,6 +339,20 @@ describe("Origami parser", () => {
     assertParse("path", "tree/foo/bar", ["tree", "foo", "bar"]);
   });
 
+  test("pipeline", () => {
+    assertParse("pipeline", "a -> b", [
+      [ops.scope, "b"],
+      [ops.scope, "a"],
+    ]);
+    assertParse("pipeline", "input → one.js → two.js", [
+      [ops.scope, "two.js"],
+      [
+        [ops.scope, "one.js"],
+        [ops.scope, "input"],
+      ],
+    ]);
+  });
+
   test("protocolCall", () => {
     assertParse("protocolCall", "foo://bar", [[ops.scope, "foo"], "bar"]);
     assertParse("protocolCall", "https://example.com/foo/", [
@@ -327,10 +385,12 @@ describe("Origami parser", () => {
   test("templateDocument", () => {
     assertParse("templateDocument", "hello{{foo}}world", [
       ops.lambda,
+      null,
       [ops.concat, "hello", [ops.scope, "foo"], "world"],
     ]);
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
+      null,
       "Documents can contain ` backticks",
     ]);
   });
@@ -349,7 +409,7 @@ describe("Origami parser", () => {
       [
         [ops.scope, "map"],
         [ops.scope, "people"],
-        [ops.lambda, [ops.concat, [ops.scope, "name"]]],
+        [ops.lambda, null, [ops.concat, [ops.scope, "name"]]],
       ],
     ]);
   });
@@ -384,6 +444,25 @@ describe("Origami parser", () => {
 });
 
 function assertParse(startRule, source, expected) {
-  const actual = parse(source, { startRule });
+  /** @type {any} */
+  const parseResult = parse(source, { grammarSource: source, startRule });
+  const actual = stripLocations(parseResult);
   assert.deepEqual(actual, expected);
 }
+
+// For comparison purposes, strip the `location` property added by the parser.
+function stripLocations(parseResult) {
+  if (Array.isArray(parseResult)) {
+    return parseResult.map(stripLocations);
+  } else if (isPlainObject(parseResult)) {
+    const result = {};
+    for (const key in parseResult) {
+      if (key !== "location") {
+        result[key] = stripLocations(parseResult[key]);
+      }
+    }
+    return result;
+  } else {
+    return parseResult;
+  }
+}

package/test/runtime/evaluate.test.js

@@ -43,6 +43,14 @@ describe("evaluate", () => {
     await evaluate.call(scope, code);
   });
 
+  test("evaluates a function with fixed number of arguments", async () => {
+    const fn = (x, y) => ({
+      c: `${x}${y}c`,
+    });
+    const code = [ops.traverse, fn, "a", "b", "c"];
+    assert.equal(await evaluate.call(null, code), "abc");
+  });
+
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
     const packed = {