@weborigami/language 0.6.0 → 0.6.1

package/main.js

@@ -8,7 +8,7 @@ export { default as jsGlobals } from "./src/project/jsGlobals.js";
 export { default as projectGlobals } from "./src/project/projectGlobals.js";
 export { default as projectRoot } from "./src/project/projectRoot.js";
 export * as Protocols from "./src/protocols/protocols.js";
-export { formatError } from "./src/runtime/errors.js";
+export { formatError, highlightError } from "./src/runtime/errors.js";
 export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.0",
+    "@weborigami/async-tree": "0.6.1",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/optimize.js

@@ -2,7 +2,7 @@ import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
 import jsGlobals from "../project/jsGlobals.js";
 import { entryKey } from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.js";
-import { annotate, markers } from "./parserHelpers.js";
+import { annotate, markers, spanLocations } from "./parserHelpers.js";
 
 export const REFERENCE_PARAM = 1;
 export const REFERENCE_INHERITED = 2;
@@ -334,6 +334,8 @@ function resolvePath(code, globals, parent, locals, cache) {
         result[0][0] === ops.inherited);
     if (extendResult) {
       result.push(...tail);
+      result.location = spanLocations(args);
+      result.source = code.source;
     } else {
       result = annotate([result, ...tail], code.location);
     }

package/src/compiler/parserHelpers.js

@@ -1,4 +1,3 @@
-import { trailingSlash } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 import codeFragment from "../runtime/codeFragment.js";
 import * as ops from "../runtime/ops.js";
@@ -380,11 +379,6 @@ export function makePath(keys) {
   const location = spanLocations(code);
   code = annotate(code, location);
 
-  // Last key has trailing slash implies unpack operation
-  if (trailingSlash.has(args.at(-1)[1])) {
-    code = annotate([ops.unpack, code], location);
-  }
-
   return code;
 }
 
@@ -518,7 +512,7 @@ export function makeYamlObject(text, location) {
 
 // Create a locations that spans those in the array. This assumes the locations
 // are in order and non-overlapping.
-function spanLocations(code) {
+export function spanLocations(code) {
   const first = code.find((item) => item.location).location;
   const last = code[code.findLastIndex((item) => item.location)].location;
   return {

package/src/handlers/getSource.js

@@ -0,0 +1,36 @@
+import { getParent, toString } from "@weborigami/async-tree";
+
+/**
+ * Given packed source text and a handler's options, return a source
+ * object that can be passed to the compiler.
+ */
+export default function getSource(packed, options = {}) {
+  const parent = getParent(packed, options);
+
+  // Try to determine a URL for error messages
+  const sourceName = options.key;
+  let url;
+  if (sourceName) {
+    if (/** @type {any} */ (parent)?.url) {
+      let parentHref = /** @type {any} */ (parent).url.href;
+      if (!parentHref.endsWith("/")) {
+        parentHref += "/";
+      }
+      url = new URL(sourceName, parentHref);
+    } else if (/** @type {any} */ (parent)?.path) {
+      let parentHref = new URL(/** @type {any} */ (parent).path, "file:///")
+        .href;
+      if (!parentHref.endsWith("/")) {
+        parentHref += "/";
+      }
+      url = new URL(sourceName, parentHref);
+    }
+  }
+
+  const source = {
+    text: toString(packed),
+    name: options.key,
+    url,
+  };
+  return source;
+}

package/src/handlers/ori_handler.js

@@ -1,6 +1,7 @@
-import { getParent, setParent, toString } from "@weborigami/async-tree";
+import { getParent, setParent } from "@weborigami/async-tree";
 import * as compile from "../compiler/compile.js";
 import projectGlobals from "../project/projectGlobals.js";
+import getSource from "./getSource.js";
 
 /**
  * An Origami expression file
@@ -13,34 +14,18 @@ export default {
   /** @type {import("@weborigami/async-tree").UnpackFunction} */
   async unpack(packed, options = {}) {
     const parent = getParent(packed, options);
+    const source = getSource(packed, options);
 
-    // Construct an object to represent the source code.
-    const sourceName = options.key;
-    let url;
-    if (sourceName && /** @type {any} */ (parent)?.url) {
-      let parentHref = /** @type {any} */ (parent).url.href;
-      if (!parentHref.endsWith("/")) {
-        parentHref += "/";
-      }
-      url = new URL(sourceName, parentHref);
-    }
-
-    const source = {
-      text: toString(packed),
-      name: options.key,
-      url,
-    };
-
-    // Compile the source code as an Origami program and evaluate it.
+    // Compile the source code as an Origami program
     const compiler = options.compiler ?? compile.program;
     const globals = options.globals ?? (await projectGlobals());
-
     const fn = compiler(source, {
       globals,
       mode: "program",
       parent,
     });
 
+    // Evaluate the program
     const result = await fn();
 
     if (parent) {

package/src/handlers/oridocument_handler.js

@@ -1,11 +1,7 @@
-import {
-  extension,
-  getParent,
-  toString,
-  trailingSlash,
-} from "@weborigami/async-tree";
+import { extension, getParent, trailingSlash } from "@weborigami/async-tree";
 import * as compile from "../compiler/compile.js";
 import projectGlobals from "../project/projectGlobals.js";
+import getSource from "./getSource.js";
 
 /**
  * An Origami template document: a plain text file that contains Origami
@@ -17,30 +13,10 @@ export default {
   /** @type {import("@weborigami/async-tree").UnpackFunction} */
   async unpack(packed, options = {}) {
     const parent = getParent(packed, options);
+    const source = getSource(packed, options);
 
-    // Unpack as a text document
-    const text = toString(packed);
-
-    // See if we can construct a URL to use in error messages
-    const key = options.key;
-    let url;
-    if (key && /** @type {any} */ (parent)?.url) {
-      let parentHref = /** @type {any} */ (parent).url.href;
-      if (!parentHref.endsWith("/")) {
-        parentHref += "/";
-      }
-      url = new URL(key, parentHref);
-    }
-
-    // Compile the text as an Origami template document
-    const source = {
-      name: key,
-      text,
-      url,
-    };
-
+    // Compile the source code as an Origami template document
     const globals = options.globals ?? (await projectGlobals());
-
     const defineFn = compile.templateDocument(source, {
       front: options.front,
       globals,
@@ -51,6 +27,7 @@ export default {
     // Invoke the definition to get back the template function
     const result = await defineFn();
 
+    const key = options.key;
     const resultExtension = key ? extension.extname(key) : null;
     if (resultExtension && Object.isExtensible(result)) {
       // Add sidecar function so this template can be used in a map.

package/src/handlers/yaml_handler.js

@@ -1,5 +1,14 @@
-import { symbols, toString } from "@weborigami/async-tree";
+import {
+  getParent,
+  isUnpackable,
+  symbols,
+  toString,
+} from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
+import * as compile from "../compiler/compile.js";
+import projectGlobals from "../project/projectGlobals.js";
+import * as expressionFunction from "../runtime/expressionFunction.js";
+import getSource from "./getSource.js";
 
 // The "yaml" package doesn't seem to provide a default export that the browser can
 // recognize, so we have to handle two ways to accommodate Node and the browser.
@@ -16,12 +25,20 @@ export default {
   mediaType: "application/yaml",
 
   /** @type {import("@weborigami/async-tree").UnpackFunction} */
-  unpack(packed) {
+  async unpack(packed, options = {}) {
     const yaml = toString(packed);
     if (!yaml) {
       throw new Error("Tried to parse something as YAML but it wasn't text.");
     }
-    const data = YAML.parse(yaml);
+    const parent = getParent(packed, options);
+    const oriCallTag = await oriCallTagForParent(parent, options);
+    const oriTag = await oriTagForParent(parent, options);
+    // YAML parser is sync, but top-level !ori or !ori.call tags will return a
+    // promise.
+    // @ts-ignore TypeScript complains customTags isn't valid here but it is.
+    const data = await YAML.parse(yaml, {
+      customTags: [oriCallTag, oriTag],
+    });
     if (data && typeof data === "object" && Object.isExtensible(data)) {
       Object.defineProperty(data, symbols.deep, {
         enumerable: false,
@@ -31,3 +48,58 @@ export default {
     return data;
   },
 };
+
+async function oriCallTagForParent(parent, options) {
+  const globals = await projectGlobals();
+  return {
+    collection: "seq",
+
+    tag: "!ori.call",
+
+    identify: (value) => false,
+
+    async resolve(value) {
+      /** @type {any[]} */
+      const args = typeof value?.toJSON === "function" ? value.toJSON() : value;
+
+      // First arg is Origami source
+      const text = args.shift();
+      const source = getSource(text, options);
+
+      const codeFn = compile.expression(source, {
+        globals,
+        parent,
+      });
+
+      // Evaluate the code to get a function
+      let fn = await codeFn.call(parent);
+
+      // Call the function with the rest of the args
+      if (isUnpackable(fn)) {
+        fn = await fn.unpack();
+      }
+
+      return fn.call(null, ...args);
+    },
+  };
+}
+
+// Define the !ori tag for YAML parsing. This will run in the context of the
+// supplied parent.
+async function oriTagForParent(parent, options) {
+  const globals = await projectGlobals();
+  return {
+    identify: expressionFunction.isExpressionFunction,
+
+    resolve(text) {
+      const source = getSource(text, options);
+      const fn = compile.expression(source, {
+        globals,
+        parent,
+      });
+      return fn.call(parent);
+    },
+
+    tag: "!ori",
+  };
+}

package/src/runtime/errors.js

@@ -95,7 +95,9 @@ export function formatError(error) {
         error.message === "A null or undefined value can't be traversed"
       ) {
         // Provide more meaningful message for TraverseError
-        line = `TraverseError: This part of the path is null or undefined: ${fragment}`;
+        line = `TraverseError: This part of the path is null or undefined: ${highlightError(
+          fragment
+        )}`;
         fragmentInMessage = true;
       }
       if (message) {
@@ -110,7 +112,7 @@ export function formatError(error) {
   // Add location
   if (location) {
     if (!fragmentInMessage) {
-      message += `\nevaluating: ${fragment}`;
+      message += `\nevaluating: ${highlightError(fragment)}`;
     }
     message += lineInfo(location);
   }
@@ -130,6 +132,11 @@ export async function formatScopeTypos(scope, key) {
   return `Maybe you meant ${list}?`;
 }
 
+export function highlightError(text) {
+  // ANSI escape sequence to highlight text in red
+  return `\x1b[31m${text}\x1b[0m`;
+}
+
 export function maybeOrigamiSourceCode(text) {
   return origamiSourceSignals.some((signal) => text.includes(signal));
 }

package/src/runtime/evaluate.js

@@ -36,7 +36,7 @@ export default async function evaluate(code, state = {}) {
     const error = ReferenceError(
       `${codeFragment(code[0].location)} is not defined`
     );
-    /** @type {any} */ (error).location = code.location;
+    /** @type {any} */ (error).location = code[0].location;
     throw error;
   }
 

package/src/runtime/handleExtension.js

@@ -41,11 +41,6 @@ export default async function handleExtension(value, key, parent) {
           handler = await handler.unpack();
         }
 
-        if (hasSlash && handler.unpack) {
-          // Key like `data.json/` ends in slash -- unpack immediately
-          return handler.unpack(value, { key, parent });
-        }
-
         // If the value is a primitive, box it so we can attach data to it.
         value = box(value);
 

package/test/compiler/parse.test.js

@@ -233,8 +233,8 @@ describe("Origami parser", () => {
 
     test("with paths", () => {
       assertParse("callExpression", "tree/", [
-        ops.unpack,
-        [markers.traverse, [markers.reference, "tree/"]],
+        markers.traverse,
+        [markers.reference, "tree/"],
       ]);
       assertParse("callExpression", "tree/foo/bar", [
         markers.traverse,
@@ -243,13 +243,10 @@ describe("Origami parser", () => {
         [ops.literal, "bar"],
       ]);
       assertParse("callExpression", "tree/foo/bar/", [
-        ops.unpack,
-        [
-          markers.traverse,
-          [markers.reference, "tree/"],
-          [ops.literal, "foo/"],
-          [ops.literal, "bar/"],
-        ],
+        markers.traverse,
+        [markers.reference, "tree/"],
+        [ops.literal, "foo/"],
+        [ops.literal, "bar/"],
       ]);
       // Consecutive slahes in a path are removed
       assertParse("callExpression", "tree//key", [
@@ -1032,7 +1029,7 @@ Body`,
       ]);
       assertParse("objectEntry", "folder/", [
         "folder/",
-        [ops.unpack, [markers.traverse, [markers.reference, "folder/"]]],
+        [markers.traverse, [markers.reference, "folder/"]],
       ]);
       assertParse("objectEntry", "path/to/file.txt", [
         "file.txt",
@@ -1202,8 +1199,8 @@ Body`,
       [markers.reference, "tree"],
     ]);
     assertParse("pathLiteral", "tree/", [
-      ops.unpack,
-      [markers.traverse, [markers.reference, "tree/"]],
+      markers.traverse,
+      [markers.reference, "tree/"],
     ]);
     assertParse("pathLiteral", "month/12", [
       markers.traverse,
@@ -1211,13 +1208,10 @@ Body`,
       [ops.literal, "12"],
     ]);
     assertParse("pathLiteral", "a/b/c/", [
-      ops.unpack,
-      [
-        markers.traverse,
-        [markers.reference, "a/"],
-        [ops.literal, "b/"],
-        [ops.literal, "c/"],
-      ],
+      markers.traverse,
+      [markers.reference, "a/"],
+      [ops.literal, "b/"],
+      [ops.literal, "c/"],
     ]);
     assertParse("pathLiteral", "~/.cshrc", [
       markers.traverse,

package/test/handlers/yaml_handler.test.js

@@ -1,3 +1,4 @@
+import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import yaml_handler from "../../src/handlers/yaml_handler.js";
@@ -8,10 +9,39 @@ describe(".yaml handler", () => {
 a: 1
 b: 2
 `;
-    const data = yaml_handler.unpack(text);
+    const data = await yaml_handler.unpack(text);
     assert.deepEqual(data, {
       a: 1,
       b: 2,
     });
   });
+
+  test("defines !ori tag for Origami expressions", async () => {
+    const text = `
+message: Hello
+answer: !ori 1 + 1
+`;
+    const data = await yaml_handler.unpack(text);
+    const plain = await Tree.plain(data);
+    assert.deepEqual(plain, {
+      message: "Hello",
+      answer: 2,
+    });
+  });
+
+  test("defines !ori.call tag for Origami function invocation", async () => {
+    const text = `
+message: Hello
+answer: !ori.call
+  - (a, b) => a + b
+  - 2
+  - 3
+`;
+    const data = await yaml_handler.unpack(text);
+    const plain = await Tree.plain(data);
+    assert.deepEqual(plain, {
+      message: "Hello",
+      answer: 5,
+    });
+  });
 });

package/test/runtime/handleExtension.test.js

@@ -15,13 +15,6 @@ describe("handleExtension", () => {
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });
   });
-
-  test("immediately unpacks if key ends in slash", async () => {
-    const fixture = createFixture();
-    const jsonFile = await fixture.get("bar.json");
-    const data = await handleExtension(jsonFile, "bar.json/", fixture);
-    assert.deepEqual(data, { bar: 2 });
-  });
 });
 
 function createFixture() {

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectMap, ObjectMap, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -156,11 +156,14 @@ describe("ops", () => {
   });
 
   test("ops.inherited walks up the object parent chain", async () => {
-    const tree = new DeepObjectMap({
-      a: {
-        b: {},
+    const tree = new ObjectMap(
+      {
+        a: {
+          b: {},
+        },
       },
-    });
+      { deep: true }
+    );
     const b = await Tree.traverse(tree, "a", "b");
     assert.equal(await ops.inherited(2, { object: b }), tree);
   });
@@ -368,12 +371,15 @@ describe("ops", () => {
 
   describe("ops.scope", () => {
     test("returns the scope of the given tree", async () => {
-      const tree = new DeepObjectMap({
-        a: {
-          b: {},
+      const tree = new ObjectMap(
+        {
+          a: {
+            b: {},
+          },
+          c: 1,
         },
-        c: 1,
-      });
+        { deep: true }
+      );
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope(b);