@weborigami/language 0.6.0 → 0.6.2

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,11 +1,31 @@
-import { symbols, toString } from "@weborigami/async-tree";
+import {
+  getParent,
+  isUnpackable,
+  symbols,
+  toString,
+  Tree,
+} from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
+import * as compile from "../compiler/compile.js";
+import projectGlobals from "../project/projectGlobals.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.
 // @ts-ignore
 const YAML = YAMLModule.default ?? YAMLModule.YAML;
 
+// True if we encountered !ori or !ori.call tags while parsing
+let hasOriTags = false;
+
+// When processing the !ori tag, the YAML parser will convert our compiler
+// errors into YAML syntax errors. We track the last compiler error so we can
+// re-throw it.
+let lastCompilerError = null;
+
+// The source of the last Origami line parsed in a YAML file, used for errors
+let source;
+
 /**
  * A YAML file
  *
@@ -16,18 +36,154 @@ 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, yaml);
+    const oriTag = await oriTagForParent(parent, options, yaml);
+    hasOriTags = false; // Haven't seen any yet
+
+    let data;
+    // YAML parser is sync, but top-level !ori or !ori.call tags will return a
+    // promise.
+    try {
+      // @ts-ignore TypeScript complains customTags isn't valid here but it is.
+      data = YAML.parse(yaml, {
+        customTags: [oriCallTag, oriTag],
+      });
+    } catch (/** @type {any} */ error) {
+      if (error.name === "SyntaxError") {
+        // One of our compiler errors, probably thrown by !ori.call tag
+        throw error;
+      }
+      const errorText = yaml.slice(error.pos[0], error.pos[1]);
+      const isOriError = errorText === "!ori" || errorText === "!ori.call";
+      if (isOriError && lastCompilerError) {
+        // Error is in an Origami tag, probably throw by !ori tag. Find the
+        // position of the Origami source in the YAML text.
+        let offset = error.pos[0] + errorText.length;
+        while (/\s/.test(yaml[offset])) {
+          offset++;
+        }
+        lastCompilerError.location.source.offset = offset;
+        throw lastCompilerError;
+      } else {
+        // Some other YAML parsing error
+        throw error;
+      }
+    }
+
+    if (data instanceof Promise) {
+      // Top-level !ori or !ori.call tag returned a promise
+      data = await data;
+    }
+
+    if (hasOriTags) {
+      // Resolve any promises in the data.
+      data = await Tree.plain(data);
+    }
+
     if (data && typeof data === "object" && Object.isExtensible(data)) {
       Object.defineProperty(data, symbols.deep, {
         enumerable: false,
         value: true,
       });
     }
+
     return data;
   },
 };
+
+async function oriCallTagForParent(parent, options, yaml) {
+  const globals = await projectGlobals();
+  return {
+    collection: "seq",
+
+    tag: "!ori.call",
+
+    resolve(value) {
+      hasOriTags = true;
+      /** @type {any[]} */
+      const args = typeof value?.toJSON === "function" ? value.toJSON() : value;
+
+      // First arg is Origami source
+      const text = args.shift();
+      source = getSource(text, options);
+
+      // Offset the source position to account for its location in YAML text
+      source.context = yaml;
+      const firstItem = value.items[0];
+      source.offset = firstItem.range[0];
+      if (
+        firstItem.type === "QUOTE_DOUBLE" ||
+        firstItem.type === "QUOTE_SINGLE"
+      ) {
+        // Account for opening quote
+        source.offset += 1;
+      }
+
+      lastCompilerError = null;
+      let codeFn;
+      try {
+        codeFn = compile.expression(source, {
+          globals,
+          parent,
+        });
+      } catch (error) {
+        lastCompilerError = error;
+        throw error;
+      }
+
+      // Return a promise for the code's evaluation. If we instead define
+      // resolve() as async, the catch block in unpack() won't catch Origami
+      // parse errors.
+      return new Promise(async (resolve) => {
+        // 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();
+        }
+
+        // Resolve any promise args
+        const resolvedArgs = await Promise.all(args);
+
+        const result = await fn.call(null, ...resolvedArgs);
+        resolve(result);
+      });
+    },
+  };
+}
+
+// Define the !ori tag for YAML parsing. This will run in the context of the
+// supplied parent.
+async function oriTagForParent(parent, options, yaml) {
+  const globals = await projectGlobals();
+  return {
+    resolve(text) {
+      hasOriTags = true;
+      source = getSource(text, options);
+      source.context = yaml;
+
+      lastCompilerError = null;
+      let fn;
+      try {
+        fn = compile.expression(source, {
+          globals,
+          parent,
+        });
+      } catch (error) {
+        lastCompilerError = error;
+        throw error;
+      }
+
+      return fn.call(parent);
+    },
+
+    tag: "!ori",
+  };
+}

package/src/project/jsGlobals.js

@@ -12,7 +12,7 @@ import path from "node:path";
  * Fetch API
  * URL API
  */
-const globals = bindStaticMethodsForGlobals({
+const globals = {
   AbortController,
   AbortSignal,
   AggregateError,
@@ -152,7 +152,7 @@ const globals = bindStaticMethodsForGlobals({
   // Special cases
   fetch: fetchWrapper,
   import: importWrapper,
-});
+};
 
 // Give access to our own custom globals as `globalThis`
 Object.defineProperty(globals, "globalThis", {
@@ -190,64 +190,4 @@ async function importWrapper(modulePath) {
 }
 importWrapper.containerAsTarget = true;
 
-/**
- * Some JavaScript globals like Promise have static methods like Promise.all
- * verify that the call target is the class. This creates an issue because the
- * Origami evaluate() function calls all functions with the evaluation context
- * -- the tree in which the code is running -- as the call target.
- *
- * This function works around the problem. If the indicated object has no static
- * methods, it's returned as is. If it does have static methods, this returns an
- * extension of the object that overrides the static methods with ones that are
- * bound to the object.
- */
-function bindStaticMethods(obj) {
-  if (typeof obj !== "function" && (typeof obj !== "object" || obj === null)) {
-    // Something like `NaN` or `null`
-    return obj;
-  }
-
-  const staticMethodDescriptors = Object.entries(
-    Object.getOwnPropertyDescriptors(obj)
-  )
-    .filter(([key, descriptor]) => descriptor.value instanceof Function)
-    .map(([key, descriptor]) => [
-      key,
-      {
-        ...descriptor,
-        value: descriptor.value.bind(obj),
-      },
-    ]);
-  if (staticMethodDescriptors.length === 0) {
-    // No static methods
-    return obj;
-  }
-
-  let extended;
-  if (typeof obj === "object" || !obj.prototype) {
-    // A regular object or an oddball like Proxy with no prototype
-    extended = Object.create(obj);
-  } else {
-    // A function, possibly a constructor called with or without `new`
-    /** @this {any} */
-    extended = function (...args) {
-      const calledWithNew = this instanceof extended;
-      return calledWithNew ? new obj(...args) : obj(...args);
-    };
-  }
-
-  Object.defineProperties(
-    extended,
-    Object.fromEntries(staticMethodDescriptors)
-  );
-
-  return extended;
-}
-
-function bindStaticMethodsForGlobals(objects) {
-  const entries = Object.entries(objects);
-  const bound = entries.map(([key, value]) => [key, bindStaticMethods(value)]);
-  return Object.fromEntries(bound);
-}
-
 export default globals;

package/src/protocols/constructHref.js

@@ -9,6 +9,9 @@ import { pathFromKeys } from "@weborigami/async-tree";
  */
 export default function constructHref(protocol, host, ...keys) {
   const path = pathFromKeys(keys);
+  if (host.endsWith("/")) {
+    host = host.slice(0, -1);
+  }
   let href = [host, path].join("/");
   if (!href.startsWith(protocol)) {
     if (!href.startsWith("//")) {

package/src/protocols/explorehttp.js

@@ -0,0 +1,13 @@
+import { ExplorableSiteMap } from "@weborigami/async-tree";
+import constructSiteTree from "./constructSiteTree.js";
+
+/**
+ * A site tree with JSON Keys via HTTP.
+ *
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function explorehttp(host, ...keys) {
+  return constructSiteTree("http:", ExplorableSiteMap, host, ...keys);
+}

package/src/protocols/protocolGlobals.js

@@ -2,6 +2,7 @@ import * as protocols from "./protocols.js";
 
 export default {
   "explore:": protocols.explore,
+  "explorehttp:": protocols.explorehttp,
   "files:": protocols.files,
   "http:": protocols.http,
   "https:": protocols.https,

package/src/protocols/protocols.js

@@ -1,4 +1,5 @@
 export { default as explore } from "./explore.js";
+export { default as explorehttp } from "./explorehttp.js";
 export { default as files } from "./files.js";
 export { default as http } from "./http.js";
 export { default as https } from "./https.js";

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));
 }
@@ -137,9 +144,22 @@ export function maybeOrigamiSourceCode(text) {
 // Return user-friendly line information for the error location
 function lineInfo(location) {
   let { source, start } = location;
-  // Adjust line number with offset if present (for example, if the code is in
-  // an Origami template document with front matter that was stripped)
-  let line = start.line + (source.offset ?? 0);
+
+  let line;
+  let column;
+  if (source.offset && source.context) {
+    // Account for source code that was offset within a larger document
+    const offset = source.offset + start.offset;
+    // Calculate line and column from offset
+    const textUpToOffset = source.context.slice(0, offset);
+    const lines = textUpToOffset.split("\n");
+    line = lines.length;
+    column = lines[lines.length - 1].length + 1;
+  } else {
+    // Use indicated start location as is
+    line = start.line;
+    column = start.column;
+  }
 
   if (typeof source === "object" && source.url) {
     const { url } = source;
@@ -155,10 +175,10 @@ function lineInfo(location) {
       // Not a file: URL, use as is
       fileRef = url.href;
     }
-    return `\n    at ${fileRef}:${line}:${start.column}`;
+    return `\n    at ${fileRef}:${line}:${column}`;
   } else if (source.text.includes("\n")) {
     // Don't know the URL, but has multiple lines so add line number
-    return `\n    at line ${line}, column ${start.column}`;
+    return `\n    at line ${line}, column ${column}`;
   } else {
     return "";
   }

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/src/runtime/ops.js

@@ -181,6 +181,11 @@ export async function homeDirectory(...keys) {
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
+export function inOperator(a, b) {
+  return a in b;
+}
+addOpLabel(inOperator, "«ops.inOperator»");
+
 /**
  * Given the tree currently be using as the context for the runtime, walk up the
  * parent chain `depth` levels and return that tree.
@@ -203,6 +208,11 @@ export async function inherited(depth, state) {
 addOpLabel(inherited, "«ops.inherited»");
 inherited.needsState = true;
 
+export function instanceOf(a, b) {
+  return a instanceof b;
+}
+addOpLabel(instanceOf, "«ops.instanceOf»");
+
 /**
  * Return a function that will invoke the given code.
  *

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

@@ -8,10 +8,37 @@ 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);
+    assert.deepEqual(data, {
+      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);
+    assert.deepEqual(data, {
+      message: "Hello",
+      answer: 5,
+    });
+  });
 });

package/test/project/jsGlobals.test.js

@@ -3,19 +3,25 @@ import { describe, test } from "node:test";
 import jsGlobals from "../../src/project/jsGlobals.js";
 
 describe("jsGlobals", () => {
-  test("can invoke static methods", async () => {
-    const { Promise } = jsGlobals;
-    const { all } = Promise;
-    const result = (
-      await all(["fruit", "computer", "park"].map((item) => `Apple ${item}`))
-    ).join(", ");
-    assert.equal(result, "Apple fruit, Apple computer, Apple park");
+  test("can invoke finicky methods like Promise.all that check their receiver", async () => {
+    const value = await jsGlobals.Promise.all([Promise.resolve("hi")]);
+    assert.equal(value, "hi");
   });
 
-  test("can invoke a method on a static method", () => {
+  test("can invoke a static method on a global", () => {
     const { Math } = jsGlobals;
     const a = [1, 3, 2];
     const b = Math.max.apply(null, a);
     assert.equal(b, 3);
   });
+
+  test("can invoke a global constructor", async () => {
+    const { Number: fixture } = jsGlobals;
+    // Without `new`
+    const instance1 = fixture(5);
+    assert.equal(instance1, 5);
+    // With `new`
+    const instance = new fixture();
+    assert(instance instanceof Number);
+  });
 });

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() {