@weborigami/language 0.0.41 → 0.0.42

package/src/compiler/parserHelpers.js

@@ -17,6 +17,16 @@ export function makeFunctionCall(target, chain) {
   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;
+}
+
 export function makeTemplate(parts) {
   // Drop empty/null strings.
   const filtered = parts.filter((part) => part);

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;
@@ -42,9 +42,7 @@ export default async function evaluate(code) {
 
   if (!fn) {
     // The code wants to invoke something that's couldn't be found in scope.
-    throw ReferenceError(
-      `Couldn't find function or tree key: ${format(code[0])}`
-    );
+    throw ReferenceError(`${codeFragment(code[0])} is not defined`);
   }
 
   if (
@@ -57,9 +55,7 @@ export default async function evaluate(code) {
 
   if (!Tree.isTreelike(fn)) {
     throw TypeError(
-      `Expect to invoke a function or a tree but instead got: ${format(
-        code[0]
-      )}`
+      `${codeFragment(code[0])} didn't return a function that can be called`
     );
   }
 
@@ -71,26 +67,34 @@ export default async function evaluate(code) {
         ? 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;
 }
 

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

@@ -128,7 +128,7 @@ 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

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";
@@ -15,6 +16,7 @@ describe("Origami parser", () => {
   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", () => {
@@ -73,6 +75,10 @@ describe("Origami parser", () => {
       [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", () => {
@@ -116,6 +122,11 @@ 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"],
@@ -167,36 +178,16 @@ describe("Origami parser", () => {
       [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"],
@@ -204,20 +195,42 @@ 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,
@@ -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]);
@@ -326,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/", [
@@ -417,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/src/compiler/code.d.ts

@@ -1,3 +0,0 @@
-import type { Treelike } from "@weborigami/async-tree";
-
-type Code = [Treelike, ...any[]] | any;

package/src/runtime/format.js

@@ -1,127 +0,0 @@
-import { ops } from "./internal.js";
-
-export default function format(code, implicitFunctionCall = false) {
-  if (code === null) {
-    return "";
-  } else if (typeof code === "string") {
-    return `'${code}'`;
-  } else if (typeof code === "symbol") {
-    return `«${code.description}»`;
-  } else if (!(code instanceof Array)) {
-    return code;
-  } else {
-    switch (code[0]) {
-      case ops.assign:
-        return formatAssignment(code);
-
-      case ops.concat:
-        return formatTemplate(code);
-
-      case ops.lambda:
-        return formatLambda(code);
-
-      case ops.object:
-        return formatObject(code);
-
-      case ops.scope:
-        return formatScopeTraversal(code, implicitFunctionCall);
-
-      case ops.tree:
-        return formatTree(code);
-
-      default:
-        return code[0] instanceof Array
-          ? formatFunctionCall(code)
-          : "** Unknown Origami code **";
-    }
-  }
-}
-
-function formatArgument(arg) {
-  return typeof arg === "string" ? `'${arg}'` : format(arg);
-}
-
-function formatArguments(args) {
-  const allStrings = args.every((arg) => typeof arg === "string");
-  return allStrings
-    ? // Use tree traversal syntax.
-      formatSlashPath(args)
-    : // Use function invocation syntax.
-      formatArgumentsList(args);
-}
-
-function formatArgumentsList(args) {
-  const formatted = args.map((arg) => formatArgument(arg));
-  const list = formatted.join(", ");
-  return `(${list})`;
-}
-
-function formatAssignment(code) {
-  const [_, declaration, expression] = code;
-  return `${declaration} = ${format(expression)}`;
-}
-
-function formatFunctionCall(code) {
-  const [fn, ...args] = code;
-  let formattedFn = format(fn);
-  if (formattedFn.includes("/") || formattedFn.includes("(")) {
-    formattedFn = `(${formattedFn})`;
-  }
-  return `${formattedFn}${formatArguments(args)}`;
-}
-
-function formatObject(code) {
-  const [_, ...entries] = code;
-  const formatted = entries.map(([key, value]) => {
-    return value === null ? key : `${key}: ${format(value)}`;
-  });
-  return formatted ? `{ ${formatted.join(", ")} }` : "{}";
-}
-
-function formatName(name) {
-  return typeof name === "string"
-    ? name
-    : name instanceof Array
-    ? `(${format(name)})`
-    : format(name);
-}
-
-function formatLambda(code) {
-  // TODO: named parameters
-  return `=${format(code[2])}`;
-}
-
-function formatScopeTraversal(code, implicitFunctionCall = false) {
-  const operands = code.slice(1);
-  const name = formatName(operands[0]);
-  if (operands.length === 1) {
-    return implicitFunctionCall ? `${name}()` : name;
-  }
-
-  const args = formatArguments(operands.slice(1));
-  return `${name}${args}`;
-}
-
-function formatSlashPath(args) {
-  return "/" + args.join("/");
-}
-
-function formatTemplate(code) {
-  const args = code.slice(1);
-  const formatted = args.map((arg) =>
-    typeof arg === "string" ? arg : `{{${format(arg)}}}`
-  );
-  return `\`${formatted.join("")}\``;
-}
-
-function formatTree(code) {
-  const [_, ...entries] = code;
-  const formatted = entries.map(([key, value]) => {
-    const rhs =
-      typeof value === "function" && value.code !== undefined
-        ? value.code
-        : value;
-    return `${key} = ${format(rhs)}`;
-  });
-  return formatted ? `{ ${formatted.join(", ")} }` : "{}";
-}

package/test/runtime/format.test.js

@@ -1,66 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import format from "../../src/runtime/format.js";
-import * as ops from "../../src/runtime/ops.js";
-
-describe("Origami language code formatter", () => {
-  test("assignment", () => {
-    const code = [ops.assign, "foo", [ops.scope, "bar"]];
-    assert.equal(format(code), "foo = bar");
-  });
-
-  test("scope reference", () => {
-    const code = [ops.scope, "foo"];
-    assert.equal(format(code), "foo");
-  });
-
-  test("implicit function call", () => {
-    const code = [ops.scope, "foo"];
-    assert.equal(format(code, true), "foo()");
-  });
-
-  test("function call", () => {
-    const code = [[ops.scope, "foo"], undefined];
-    assert.equal(format(code, true), "foo()");
-  });
-
-  test("tree traversal with string args", () => {
-    const code = [[ops.scope, "a"], "b", "c"];
-    assert.equal(format(code), "a/b/c");
-  });
-
-  test("tree traversal with numeric and string args", () => {
-    const code = [ops.scope, "fn", "x", 1, 2];
-    assert.equal(format(code), "fn('x', 1, 2)");
-  });
-
-  test("tree traversal with function arg and string arg", () => {
-    const code = [ops.scope, "fn", [ops.scope, "foo"], "bar"];
-    assert.equal(format(code), "fn(foo, 'bar')");
-  });
-
-  test("function composition", () => {
-    const code = [[[ops.scope, "fn"], "a"], "b"];
-    assert.equal(format(code), "(fn/a)/b");
-  });
-
-  test("lambda", () => {
-    const code = [ops.lambda, null, [ops.scope, "message"]];
-    assert.equal(format(code), "=message");
-  });
-
-  test("object", () => {
-    const code = [ops.object, ["a", "Hello"], ["b", "Goodbye"]];
-    assert.equal(format(code), "{ a: 'Hello', b: 'Goodbye' }");
-  });
-
-  test("template", () => {
-    const code = [ops.concat, "Hello, ", [ops.scope, "name"], "."];
-    assert.equal(format(code), "`Hello, {{name}}.`");
-  });
-
-  test("tree", () => {
-    const code = [ops.tree, ["x", [[ops.scope, "fn"], undefined]]];
-    assert.equal(format(code), "{ x = fn() }");
-  });
-});