@weborigami/language 0.2.10 → 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
@@ -385,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/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
@@ -263,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;
@@ -284,6 +310,7 @@ export async function literal(value) {
   return value;
 }
 addOpLabel(literal, "«ops.literal»");
+literal.unevaluatedArgs = true;
 
 /**
  * Logical AND operator
@@ -377,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;
@@ -425,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/parse.test.js

@@ -251,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, "_"]], [ops.literal, "1"]]],
-      [ops.literal, "0"],
+      [ops.lambda, [], [ops.lambda, [[ops.literal, "_"]], [ops.literal, 1]]],
+      [ops.literal, 0],
     ]);
   });
 
@@ -286,7 +286,7 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("errors for missing pieces", () => {
+  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");
@@ -298,6 +298,31 @@ describe("Origami parser", () => {
     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,
@@ -309,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,
         [
@@ -1007,8 +1030,8 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("templateDocument", () => {
-    assertParse("templateDocument", "hello${foo}world", [
+  test("templateBody", () => {
+    assertParse("templateBody", "hello${foo}world", [
       ops.lambda,
       [[ops.literal, "_"]],
       [
@@ -1017,7 +1040,7 @@ describe("Origami parser", () => {
         [ops.concat, [ops.scope, "foo"]],
       ],
     ]);
-    assertParse("templateDocument", "Documents can contain ` backticks", [
+    assertParse("templateBody", "Documents can contain ` backticks", [
       ops.lambda,
       [[ops.literal, "_"]],
       [
@@ -1027,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,
@@ -1106,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);
@@ -1121,7 +1204,7 @@ function assertCodeLocations(code) {
   }
 }
 
-function assertThrows(startRule, source, message) {
+function assertThrows(startRule, source, message, position) {
   try {
     parse(source, {
       grammarSource: { text: source },
@@ -1132,6 +1215,10 @@ function assertThrows(startRule, source, message) {
       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);