@weborigami/language 0.2.9 → 0.2.11

package/src/compiler/parserHelpers.js

@@ -1,7 +1,13 @@
 import { trailingSlash } from "@weborigami/async-tree";
+import * as YAMLModule from "yaml";
 import codeFragment from "../runtime/codeFragment.js";
 import * as ops from "../runtime/ops.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;
+
 // Parser helpers
 
 /** @typedef {import("../../index.ts").AnnotatedCode} AnnotatedCode */
@@ -30,6 +36,28 @@ export function annotate(code, location) {
   return annotated;
 }
 
+/**
+ * In the given code, replace all scope refernces to the given name with the
+ * given macro code.
+ *
+ * @param {AnnotatedCode} code
+ * @param {string} name
+ * @param {AnnotatedCode} macro
+ */
+export function applyMacro(code, name, macro) {
+  if (!(code instanceof Array)) {
+    return code;
+  }
+
+  const [fn, ...args] = code;
+  if (fn === ops.scope && args[0] === name) {
+    return macro;
+  }
+
+  const applied = code.map((child) => applyMacro(child, name, macro));
+  return annotate(applied, code.location);
+}
+
 /**
  * The indicated code is being used to define a property named by the given key.
  * Rewrite any [ops.scope, key] calls to be [ops.inherited, key] to avoid
@@ -50,7 +78,10 @@ function avoidRecursivePropertyCalls(code, key) {
   ) {
     // Rewrite to avoid recursion
     modified = [ops.inherited, code[1]];
-  } else if (code[0] === ops.lambda && code[1].includes(key)) {
+  } else if (
+    code[0] === ops.lambda &&
+    code[1].some((param) => param[1] === key)
+  ) {
     // Lambda that defines the key; don't rewrite
     return code;
   } else {
@@ -382,6 +413,59 @@ export function makeUnaryOperation(operator, value, location) {
   return annotate([operators[operator], value], location);
 }
 
+/**
+ * Make an object from YAML front matter
+ *
+ * @param {string} text
+ * @param {CodeLocation} location
+ */
+export function makeYamlObject(text, location) {
+  // Account for the "---" delimiter at the beginning of the YAML front matter
+  const yamlLineDelta = 1;
+  const yamlOffsetDelta = 4; // 3 dashes + 1 newline
+
+  let parsed;
+  try {
+    parsed = YAML.parse(text);
+  } catch (/** @type {any} */ yamlError) {
+    // Convert YAML error to a SyntaxError
+
+    let { message } = yamlError;
+    // Remove the line number and column if present
+    const lineNumberRegex = /( at line )(\d+)(,)/;
+    const lineNumberMatch = message.match(lineNumberRegex);
+    if (lineNumberMatch) {
+      message = message.slice(0, lineNumberMatch.index);
+    }
+
+    /** @type {any} */
+    const error = new SyntaxError(message);
+    error.location = {
+      end: {
+        column: yamlError.linePos[1].col,
+        line: yamlError.linePos[1].line + yamlLineDelta,
+        offset: yamlError.pos[1] + yamlOffsetDelta,
+      },
+      source: location.source,
+      start: {
+        column: yamlError.linePos[0].col,
+        line: yamlError.linePos[0].line + yamlLineDelta,
+        offset: yamlError.pos[0] + yamlOffsetDelta,
+      },
+    };
+    throw error;
+  }
+
+  if (!(parsed instanceof Object)) {
+    /** @type {any} */
+    const error = new SyntaxError("YAML front matter must be an object.");
+    error.location = location;
+    throw error;
+  }
+
+  return annotate([ops.literal, parsed], location);
+}
+
 /**
  * Upgrade a potential builtin reference to an actual builtin reference.
  *

package/src/runtime/EventTargetMixin.d.ts

@@ -1,9 +1,5 @@
 import { Mixin } from "../../index.ts";
 
-declare const EventTargetMixin: Mixin<{
-  addEventListener(type: string, listener: EventListener): void;
-  dispatchEvent(event: Event): boolean;
-  removeEventListener(type: string, listener: EventListener): void;
-}>;
+declare const EventTargetMixin: Mixin<EventTarget>;
 
 export default EventTargetMixin;

package/src/runtime/errors.js

@@ -5,6 +5,8 @@ import {
   trailingSlash,
   TraverseError,
 } from "@weborigami/async-tree";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import codeFragment from "./codeFragment.js";
 import { typos } from "./typos.js";
 
@@ -85,9 +87,24 @@ export function formatError(error) {
     if (!fragmentInMessage) {
       message += `\nevaluating: ${fragment}`;
     }
+
     if (typeof source === "object" && source.url) {
-      message += `\n    at ${source.url.href}:${line}:${start.column}`;
+      const { url } = source;
+      let fileRef;
+      // If URL is a file: URL, change to a relative path
+      if (url.protocol === "file:") {
+        fileRef = fileURLToPath(url);
+        const relativePath = path.relative(process.cwd(), fileRef);
+        if (!relativePath.startsWith("..")) {
+          fileRef = relativePath;
+        }
+      } else {
+        // Not a file: URL, use as is
+        fileRef = url.href;
+      }
+      message += `\n    at ${fileRef}:${line}:${start.column}`;
     } else if (source.text.includes("\n")) {
+      // Don't know the URL, but has multiple lines so add line number
       message += `\n    at line ${line}, column ${start.column}`;
     }
   }
@@ -113,7 +130,7 @@ export function maybeOrigamiSourceCode(text) {
 
 export async function scopeReferenceError(scope, key) {
   const messages = [
-    `"${key}" is not in scope.`,
+    `"${key}" is not in scope or is undefined.`,
     await formatScopeTypos(scope, key),
   ];
   const message = messages.join(" ");

package/src/runtime/evaluate.js

@@ -1,6 +1,5 @@
 import { Tree, isUnpackable, scope } from "@weborigami/async-tree";
 import codeFragment from "./codeFragment.js";
-import { ops } from "./internal.js";
 import { codeSymbol, scopeSymbol, sourceSymbol } from "./symbols.js";
 
 /**
@@ -20,14 +19,7 @@ export default async function evaluate(code) {
   }
 
   let evaluated;
-  const unevaluatedFns = [
-    ops.external,
-    ops.lambda,
-    ops.merge,
-    ops.object,
-    ops.literal,
-  ];
-  if (unevaluatedFns.includes(code[0])) {
+  if (code[0]?.unevaluatedArgs) {
     // Don't evaluate instructions, use as is.
     evaluated = code;
   } else {

package/src/runtime/ops.js

@@ -10,6 +10,7 @@ import {
   Tree,
   isUnpackable,
   scope as scopeFn,
+  symbols,
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
@@ -113,6 +114,29 @@ export async function conditional(condition, truthy, falsy) {
   return value instanceof Function ? await value() : value;
 }
 
+/**
+ * Construct a document object by invoking the body code (a lambda) and adding
+ * the resulting text to the front data.
+ *
+ * @this {AsyncTree|null}
+ * @param {any} frontData
+ * @param {AnnotatedCode} bodyCode
+ */
+export async function document(frontData, bodyCode) {
+  const context = new ObjectTree(frontData);
+  context.parent = this;
+  const bodyFn = await evaluate.call(context, bodyCode);
+  const body = await bodyFn();
+  const object = {
+    ...frontData,
+    "@text": body,
+  };
+  object[symbols.parent] = this;
+  return object;
+}
+addOpLabel(document, "«ops.document");
+document.unevaluatedArgs = true;
+
 export function division(a, b) {
   return a / b;
 }
@@ -158,6 +182,7 @@ export async function external(path, code, cache) {
   return value;
 }
 addOpLabel(external, "«ops.external»");
+external.unevaluatedArgs = true;
 
 /**
  * This op is only used during parsing. It signals to ops.object that the
@@ -223,7 +248,8 @@ export function lambda(parameters, code) {
       // Add arguments to scope.
       const ambients = {};
       for (const parameter of parameters) {
-        ambients[parameter] = args.shift();
+        const parameterName = parameter[1];
+        ambients[parameterName] = args.shift();
       }
       Object.defineProperty(ambients, codeSymbol, {
         value: code,
@@ -262,6 +288,7 @@ export function lambda(parameters, code) {
   return invoke;
 }
 addOpLabel(lambda, "«ops.lambda");
+lambda.unevaluatedArgs = true;
 
 export function lessThan(a, b) {
   return a < b;
@@ -283,6 +310,7 @@ export async function literal(value) {
   return value;
 }
 addOpLabel(literal, "«ops.literal»");
+literal.unevaluatedArgs = true;
 
 /**
  * Logical AND operator
@@ -376,6 +404,7 @@ export async function merge(...codes) {
   return mergeTrees.call(this, ...trees);
 }
 addOpLabel(merge, "«ops.merge»");
+merge.unevaluatedArgs = true;
 
 export function multiplication(a, b) {
   return a * b;
@@ -424,6 +453,7 @@ export async function object(...entries) {
   return expressionObject(entries, this);
 }
 addOpLabel(object, "«ops.object»");
+object.unevaluatedArgs = true;
 
 export function remainder(a, b) {
   return a % b;

package/test/compiler/codeHelpers.js

@@ -4,7 +4,7 @@ import assert from "node:assert";
 export function assertCodeEqual(actual, expected) {
   const actualStripped = stripCodeLocations(actual);
   const expectedStripped = stripCodeLocations(expected);
-  assert.deepEqual(actualStripped, expectedStripped);
+  assert.deepStrictEqual(actualStripped, expectedStripped);
 }
 
 /**

package/test/compiler/optimize.test.js

@@ -18,7 +18,7 @@ describe("optimize", () => {
     const code = fn.code;
     assertCodeEqual(code, [
       ops.lambda,
-      ["name"],
+      [[ops.literal, "name"]],
       [
         ops.object,
         ["a", 1],

package/test/compiler/parse.test.js

@@ -64,12 +64,16 @@ describe("Origami parser", () => {
     ]);
     assertParse("arrowFunction", "x => y", [
       ops.lambda,
-      ["x"],
+      [[ops.literal, "x"]],
       [ops.scope, "y"],
     ]);
     assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
       ops.lambda,
-      ["a", "b", "c"],
+      [
+        [ops.literal, "a"],
+        [ops.literal, "b"],
+        [ops.literal, "c"],
+      ],
       [
         [ops.builtin, "fn"],
         [ops.scope, "a"],
@@ -79,10 +83,10 @@ describe("Origami parser", () => {
     ]);
     assertParse("arrowFunction", "a => b => fn(a, b)", [
       ops.lambda,
-      ["a"],
+      [[ops.literal, "a"]],
       [
         ops.lambda,
-        ["b"],
+        [[ops.literal, "b"]],
         [
           [ops.builtin, "fn"],
           [ops.scope, "a"],
@@ -247,20 +251,20 @@ describe("Origami parser", () => {
     assertParse("conditionalExpression", "true ? 1 : 0", [
       ops.conditional,
       [ops.scope, "true"],
-      [ops.literal, "1"],
-      [ops.literal, "0"],
+      [ops.literal, 1],
+      [ops.literal, 0],
     ]);
     assertParse("conditionalExpression", "false ? () => 1 : 0", [
       ops.conditional,
       [ops.scope, "false"],
-      [ops.lambda, [], [ops.lambda, [], [ops.literal, "1"]]],
-      [ops.literal, "0"],
+      [ops.lambda, [], [ops.lambda, [], [ops.literal, 1]]],
+      [ops.literal, 0],
     ]);
     assertParse("conditionalExpression", "false ? =1 : 0", [
       ops.conditional,
       [ops.scope, "false"],
-      [ops.lambda, [], [ops.lambda, ["_"], [ops.literal, "1"]]],
-      [ops.literal, "0"],
+      [ops.lambda, [], [ops.lambda, [[ops.literal, "_"]], [ops.literal, 1]]],
+      [ops.literal, 0],
     ]);
   });
 
@@ -282,6 +286,43 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("error thrown for missing token", () => {
+    assertThrows("arrowFunction", "(a) => ", "Expected an expression");
+    assertThrows("arrowFunction", "a ⇒ ", "Expected an expression");
+    assertThrows("callExpression", "fn(a", "Expected right parenthesis");
+    assertThrows("doubleQuoteString", '"foo', "Expected closing quote");
+    assertThrows("guillemetString", "«foo", "Expected closing guillemet");
+    assertThrows("objectGetter", "a =", "Expected an expression");
+    assertThrows("objectProperty", "a:", "Expected an expression");
+    assertThrows("singleQuoteString", "'foo", "Expected closing quote");
+    assertThrows("templateLiteral", "`foo", "Expected closing backtick");
+  });
+
+  test.only("error thrown for invalid Origami front matter expression", () => {
+    assertThrows(
+      "templateDocument",
+      `---
+(name) => foo)
+---
+Body`,
+      'Expected "---"',
+      { line: 2, column: 14 }
+    );
+  });
+
+  test("error thrown for invalid YAML front matter", () => {
+    assertThrows(
+      "templateDocument",
+      `---
+a : 1
+}
+---
+Body`,
+      "Unexpected flow-map-end token",
+      { line: 3, column: 1 }
+    );
+  });
+
   test("exponentiationExpression", () => {
     assertParse("exponentiationExpression", "2 ** 2 ** 3", [
       ops.exponentiation,
@@ -293,12 +334,10 @@ describe("Origami parser", () => {
   test("expression", () => {
     assertParse(
       "expression",
-      `
-        {
-          index.html = index.ori(teamData.yaml)
-          thumbnails = map(images, { value: thumbnail.js })
-        }
-      `,
+      `{
+        index.html = index.ori(teamData.yaml)
+        thumbnails = map(images, { value: thumbnail.js })
+      }`,
       [
         ops.object,
         [
@@ -389,7 +428,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expression", "fn =`x`", [
       [ops.builtin, "fn"],
-      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
+      [ops.lambda, [[ops.literal, "_"]], [ops.template, [ops.literal, ["x"]]]],
     ]);
     assertParse("expression", "copy app.js(formulas), files:snapshot", [
       [ops.builtin, "copy"],
@@ -406,7 +445,7 @@ describe("Origami parser", () => {
       [ops.builtin, "map"],
       [
         ops.lambda,
-        ["_"],
+        [[ops.literal, "_"]],
         [
           ops.template,
           [ops.literal, ["<li>", "</li>"]],
@@ -426,7 +465,10 @@ describe("Origami parser", () => {
     ]);
     assertParse("expression", "(post, slug) => fn.js(post, slug)", [
       ops.lambda,
-      ["post", "slug"],
+      [
+        [ops.literal, "post"],
+        [ops.literal, "slug"],
+      ],
       [
         [ops.scope, "fn.js"],
         [ops.scope, "post"],
@@ -718,7 +760,7 @@ describe("Origami parser", () => {
     assertParse("objectEntry", "a: a", ["a", [ops.inherited, "a"]]);
     assertParse("objectEntry", "a: (a) => a", [
       "a",
-      [ops.lambda, ["a"], [ops.scope, "a"]],
+      [ops.lambda, [[ops.literal, "a"]], [ops.scope, "a"]],
     ]);
     assertParse("objectEntry", "posts/: map(posts, post.ori)", [
       "posts/",
@@ -943,12 +985,12 @@ describe("Origami parser", () => {
   test("shorthandFunction", () => {
     assertParse("shorthandFunction", "=message", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [undetermined, "message"],
     ]);
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         ops.template,
         [ops.literal, ["Hello, ", "."]],
@@ -957,7 +999,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         [ops.builtin, "indent"],
         [ops.literal, ["hello"]],
@@ -988,19 +1030,19 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("templateDocument", () => {
-    assertParse("templateDocument", "hello${foo}world", [
+  test("templateBody", () => {
+    assertParse("templateBody", "hello${foo}world", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         ops.templateIndent,
         [ops.literal, ["hello", "world"]],
         [ops.concat, [ops.scope, "foo"]],
       ],
     ]);
-    assertParse("templateDocument", "Documents can contain ` backticks", [
+    assertParse("templateBody", "Documents can contain ` backticks", [
       ops.lambda,
-      ["_"],
+      [[ops.literal, "_"]],
       [
         ops.templateIndent,
         [ops.literal, ["Documents can contain ` backticks"]],
@@ -1008,6 +1050,66 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("templateDocument with no front matter", () => {
+    assertParse("templateDocument", "Hello, world!", [
+      ops.lambda,
+      [[ops.literal, "_"]],
+      [ops.templateIndent, [ops.literal, ["Hello, world!"]]],
+    ]);
+  });
+
+  test("templateDocument with YAML front matter", () => {
+    assertParse(
+      "templateDocument",
+      `---
+title: Title goes here
+---
+Body text`,
+      [
+        ops.document,
+        [ops.literal, { title: "Title goes here" }],
+        [
+          ops.lambda,
+          [[ops.literal, "_"]],
+          [ops.templateIndent, [ops.literal, ["Body text"]]],
+        ],
+      ]
+    );
+  });
+
+  test("templateDocument with Origami front matter", () => {
+    assertParse(
+      "templateDocument",
+      `---
+{
+  title: "Title"
+  @text: @template()
+}
+---
+<h1>\${ title }</h1>
+`,
+      [
+        ops.object,
+        ["title", [ops.literal, "Title"]],
+        [
+          "@text",
+          [
+            [
+              ops.lambda,
+              [[ops.literal, "_"]],
+              [
+                ops.templateIndent,
+                [ops.literal, ["<h1>", "</h1>\n"]],
+                [ops.concat, [ops.scope, "title"]],
+              ],
+            ],
+            undefined,
+          ],
+        ],
+      ]
+    );
+  });
+
   test("templateLiteral", () => {
     assertParse("templateLiteral", "`Hello, world.`", [
       ops.template,
@@ -1033,7 +1135,7 @@ describe("Origami parser", () => {
           [ops.scope, "people"],
           [
             ops.lambda,
-            ["_"],
+            [[ops.literal, "_"]],
             [
               ops.template,
               [ops.literal, ["", ""]],
@@ -1087,7 +1189,7 @@ function assertParse(startRule, source, expected, checkLocation = true) {
       code.location.start.offset,
       code.location.end.offset
     );
-    assert.equal(resultSource, source.trim());
+    assert.equal(resultSource, source);
   }
 
   assertCodeEqual(code, expected);
@@ -1101,3 +1203,23 @@ function assertCodeLocations(code) {
     }
   }
 }
+
+function assertThrows(startRule, source, message, position) {
+  try {
+    parse(source, {
+      grammarSource: { text: source },
+      startRule,
+    });
+  } catch (/** @type {any} */ error) {
+    assert(
+      error.message.includes(message),
+      `Error message incorrect:\n  expected: "${message}"\n  actual: "${error.message}"`
+    );
+    if (position) {
+      assert.equal(error.location.start.line, position.line);
+      assert.equal(error.location.start.column, position.column);
+    }
+    return;
+  }
+  assert.fail(`Expected error: ${message}`);
+}

package/test/runtime/ops.test.js

@@ -80,6 +80,29 @@ describe("ops", () => {
     assert.strictEqual(await ops.conditional(false, errorFn, trueFn), true);
   });
 
+  test("ops.documentFunction", async () => {
+    const code = createCode([
+      ops.document,
+      {
+        a: 1,
+      },
+      [
+        ops.lambda,
+        [["_"]],
+        [
+          ops.template,
+          [ops.literal, ["a = ", ""]],
+          [ops.concat, [ops.scope, "a"]],
+        ],
+      ],
+    ]);
+    const result = await evaluate.call(null, code);
+    assert.deepEqual(result, {
+      a: 1,
+      "@text": "a = 1",
+    });
+  });
+
   test("ops.division divides two numbers", async () => {
     assert.strictEqual(ops.division(12, 2), 6);
     assert.strictEqual(ops.division(3, 2), 1.5);
@@ -169,7 +192,10 @@ describe("ops", () => {
   test("ops.lambda adds input parameters to scope", async () => {
     const code = createCode([
       ops.lambda,
-      ["a", "b"],
+      [
+        [ops.literal, "a"],
+        [ops.literal, "b"],
+      ],
       [ops.concat, [ops.scope, "b"], [ops.scope, "a"]],
     ]);
     const fn = await evaluate.call(null, code);