@weborigami/language 0.4.2 → 0.5.0

package/test/compiler/parse.test.js

@@ -72,16 +72,11 @@ describe("Origami parser", () => {
         [ops.literal, "src/"],
         [ops.literal, "assets"],
       ]);
-      assertParse(
-        "angleBracketLiteral",
-        "<https://example.com/data.yaml>",
-        [
-          [markers.global, "https:"],
-          [ops.literal, "example.com/"],
-          [ops.literal, "data.yaml"],
-        ],
-        "jse"
-      );
+      assertParse("angleBracketLiteral", "<https://example.com/data.yaml>", [
+        [markers.global, "https:"],
+        [ops.literal, "example.com/"],
+        [ops.literal, "data.yaml"],
+      ]);
     });
   });
 
@@ -313,6 +308,7 @@ describe("Origami parser", () => {
         [ops.literal, "assets"],
       ]);
       assertParse("callExpression", "<node:process>.env", [
+        ops.property,
         [
           [markers.global, "node:"],
           [ops.literal, "process"],
@@ -475,17 +471,21 @@ Body`,
 
     test("property acccess", () => {
       assertParse("expression", "(foo).bar", [
+        ops.property,
         [markers.traverse, [markers.reference, "foo"]],
         [ops.literal, "bar"],
       ]);
       assertParse("expression", "(foo).bar.baz", [
+        ops.property,
         [
+          ops.property,
           [markers.traverse, [markers.reference, "foo"]],
           [ops.literal, "bar"],
         ],
         [ops.literal, "baz"],
       ]);
       assertParse("expression", "foo[bar]", [
+        ops.property,
         [markers.traverse, [markers.reference, "foo"]],
         [markers.traverse, [markers.reference, "bar"]],
       ]);
@@ -500,7 +500,7 @@ Body`,
         "expression",
         "x //comment",
         [markers.traverse, [markers.reference, "x"]],
-        "jse",
+        "program",
         false
       );
     });
@@ -557,7 +557,7 @@ Body`,
         [
           ops.lambda,
           [[ops.literal, "_"]],
-          [ops.templateTree, [ops.literal, ["x"]]],
+          [ops.templateText, [ops.literal, ["x"]]],
         ],
       ]);
       assertParse("expression", "copy app.js(formulas), files:snapshot", [
@@ -577,7 +577,7 @@ Body`,
           ops.lambda,
           [[ops.literal, "_"]],
           [
-            ops.templateTree,
+            ops.templateText,
             [ops.literal, ["<li>", "</li>"]],
             [markers.traverse, [markers.reference, "_"]],
           ],
@@ -679,7 +679,7 @@ Body`,
         [[ops.literal, "name"]],
         [[markers.traverse, [markers.reference, "_template"]], undefined],
       ],
-      "jse",
+      "program",
       false
     );
   });
@@ -709,8 +709,8 @@ Body`,
   });
 
   test("identifier", () => {
-    assertParse("identifier", "foo", "foo", "jse", false);
-    assertParse("identifier", "$Δelta", "$Δelta", "jse", false);
+    assertParse("identifier", "foo", "foo", "program", false);
+    assertParse("identifier", "$Δelta", "$Δelta", "program", false);
     assertThrows(
       "identifier",
       "1stCharacterIsNumber",
@@ -841,7 +841,7 @@ Body`,
       "multiLineComment",
       "/*\nHello, world!\n*/",
       null,
-      "jse",
+      "program",
       false
     );
   });
@@ -895,110 +895,87 @@ Body`,
     assertParse("numericLiteral", "123.45", [ops.literal, 123.45]);
   });
 
-  test("objectLiteral", () => {
-    assertParse("objectLiteral", "{}", [ops.object]);
-    assertParse("objectLiteral", "{ a: 1, b }", [
-      ops.object,
-      ["a", [ops.literal, 1]],
-      ["b", [markers.traverse, [markers.reference, "b"]]],
-    ]);
-    assertParse("objectLiteral", "{ sub: { a: 1 } }", [
-      ops.object,
-      ["sub", [ops.object, ["a", [ops.literal, 1]]]],
-    ]);
-    assertParse("objectLiteral", "{ sub: { a/: 1 } }", [
-      ops.object,
-      ["sub", [ops.object, ["a/", [ops.literal, 1]]]],
-    ]);
-    assertParse("objectLiteral", `{ "a": 1, "b": 2 }`, [
-      ops.object,
-      ["a", [ops.literal, 1]],
-      ["b", [ops.literal, 2]],
-    ]);
-    assertParse("objectLiteral", "{ a = b, b = 2 }", [
-      ops.object,
-      ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
-      ["b", [ops.literal, 2]],
-    ]);
-    assertParse(
-      "objectLiteral",
-      `{
-        a = b
-        b = 2
-      }`,
-      [
+  describe("objectLiteral", () => {
+    describe("basic objects", () => {
+      assertParse("objectLiteral", "{}", [ops.object]);
+      assertParse("objectLiteral", "{ a: 1, b }", [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [markers.traverse, [markers.reference, "b"]]],
+      ]);
+      assertParse("objectLiteral", "{ sub: { a: 1 } }", [
+        ops.object,
+        ["sub", [ops.object, ["a", [ops.literal, 1]]]],
+      ]);
+      assertParse("objectLiteral", "{ sub: { a/: 1 } }", [
+        ops.object,
+        ["sub", [ops.object, ["a/", [ops.literal, 1]]]],
+      ]);
+      assertParse("objectLiteral", `{ "a": 1, "b": 2 }`, [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [ops.literal, 2]],
+      ]);
+      assertParse("objectLiteral", "{ a = b, b = 2 }", [
         ops.object,
         ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
         ["b", [ops.literal, 2]],
-      ]
-    );
-    assertParse("objectLiteral", "{ a: { b: 1 } }", [
-      ops.object,
-      ["a", [ops.object, ["b", [ops.literal, 1]]]],
-    ]);
-    assertParse("objectLiteral", "{ a: { b = 1 } }", [
-      ops.object,
-      ["a", [ops.object, ["b", [ops.literal, 1]]]],
-    ]);
-    assertParse("objectLiteral", "{ a: { b = fn() } }", [
-      ops.object,
-      [
-        "a",
+      ]);
+      assertParse(
+        "objectLiteral",
+        `{
+        a = b
+        b = 2
+      }`,
         [
           ops.object,
+          ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
+          ["b", [ops.literal, 2]],
+        ]
+      );
+      assertParse("objectLiteral", "{ a: { b: 1 } }", [
+        ops.object,
+        ["a", [ops.object, ["b", [ops.literal, 1]]]],
+      ]);
+      assertParse("objectLiteral", "{ a: { b = 1 } }", [
+        ops.object,
+        ["a", [ops.object, ["b", [ops.literal, 1]]]],
+      ]);
+      assertParse("objectLiteral", "{ a: { b = fn() } }", [
+        ops.object,
+        [
+          "a",
           [
-            "b",
+            ops.object,
             [
-              ops.getter,
-              [[markers.traverse, [markers.reference, "fn"]], undefined],
+              "b",
+              [
+                ops.getter,
+                [[markers.traverse, [markers.reference, "fn"]], undefined],
+              ],
             ],
           ],
         ],
-      ],
-    ]);
-    assertParse("objectLiteral", "{ x = fn.js('a') }", [
-      ops.object,
-      [
-        "x",
-        [
-          ops.getter,
-          [
-            [markers.traverse, [markers.reference, "fn.js"]],
-            [ops.literal, "a"],
-          ],
-        ],
-      ],
-    ]);
-    assertParse("objectLiteral", "{ a: 1, ...more, c: a }", [
-      [
+      ]);
+      assertParse("objectLiteral", "{ x = fn.js('a') }", [
         ops.object,
-        ["a", [ops.literal, 1]],
-        ["c", [markers.traverse, [markers.reference, "a"]]],
         [
-          "_result",
+          "x",
           [
-            ops.merge,
-            [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
-            [markers.traverse, [markers.reference, "more"]],
-            [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
+            ops.getter,
+            [
+              [markers.traverse, [markers.reference, "fn.js"]],
+              [ops.literal, "a"],
+            ],
           ],
         ],
-      ],
-      "_result",
-    ]);
-    assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
-      ops.object,
-      ["a", [ops.literal, 1]],
-      ["b", [ops.literal, 2]],
-    ]);
-    assertParse("objectLiteral", "{ (a): 1 }", [
-      ops.object,
-      ["(a)", [ops.literal, 1]],
-    ]);
-    assertParse(
-      "objectLiteral",
-      "{ <path/to/file.txt> }",
-      [
+      ]);
+
+      assertParse("objectLiteral", "{ (a): 1 }", [
+        ops.object,
+        ["(a)", [ops.literal, 1]],
+      ]);
+      assertParse("objectLiteral", "{ <path/to/file.txt> }", [
         ops.object,
         [
           "file.txt",
@@ -1009,9 +986,37 @@ Body`,
             [ops.literal, "file.txt"],
           ],
         ],
-      ],
-      "jse"
-    );
+      ]);
+    });
+
+    describe("spreads", () => {
+      assertParse("objectLiteral", "{ ...x }", [
+        ops.unpack,
+        [markers.traverse, [markers.reference, "x"]],
+      ]);
+      assertParse("objectLiteral", "{ a: 1, ...more, c: a }", [
+        [
+          ops.object,
+          ["a", [ops.literal, 1]],
+          ["c", [markers.traverse, [markers.reference, "a"]]],
+          [
+            "_result",
+            [
+              ops.merge,
+              [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
+              [markers.traverse, [markers.reference, "more"]],
+              [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
+            ],
+          ],
+        ],
+        "_result",
+      ]);
+      assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [ops.literal, 2]],
+      ]);
+    });
   });
 
   test("objectEntry", () => {
@@ -1027,20 +1032,15 @@ Body`,
       "a",
       [markers.traverse, [markers.reference, "a"]],
     ]);
-    assertParse(
-      "objectEntry",
-      "<path/to/file.txt>",
+    assertParse("objectEntry", "<path/to/file.txt>", [
+      "file.txt",
       [
-        "file.txt",
-        [
-          markers.traverse,
-          [markers.external, "path/"],
-          [ops.literal, "to/"],
-          [ops.literal, "file.txt"],
-        ],
+        markers.traverse,
+        [markers.external, "path/"],
+        [ops.literal, "to/"],
+        [ops.literal, "file.txt"],
       ],
-      "jse"
-    );
+    ]);
     assertParse("objectEntry", "a: (a) => a", [
       "a",
       [
@@ -1252,7 +1252,7 @@ Body`,
 'Hello'
 `,
       [ops.literal, "Hello"],
-      "jse",
+      "program",
       false
     );
   });
@@ -1312,7 +1312,7 @@ Body`,
       ops.lambda,
       [[ops.literal, "_"]],
       [
-        ops.templateTree,
+        ops.templateText,
         [ops.literal, ["Hello, ", "."]],
         [markers.traverse, [markers.reference, "name"]],
       ],
@@ -1328,7 +1328,13 @@ Body`,
   });
 
   test("singleLineComment", () => {
-    assertParse("singleLineComment", "// Hello, world!", null, "jse", false);
+    assertParse(
+      "singleLineComment",
+      "// Hello, world!",
+      null,
+      "program",
+      false
+    );
   });
 
   test("spreadElement", () => {
@@ -1336,10 +1342,6 @@ Body`,
       ops.spread,
       [markers.traverse, [markers.reference, "a"]],
     ]);
-    assertParse("spreadElement", "…a", [
-      ops.spread,
-      [markers.traverse, [markers.reference, "a"]],
-    ]);
   });
 
   test("stringLiteral", () => {
@@ -1386,7 +1388,6 @@ Body text`,
       [
         ops.object,
         ["title", [ops.literal, "Title goes here"]],
-        ["(@text)", [ops.templateIndent, [ops.literal, ["Body text"]]]],
         ["_body", [ops.templateIndent, [ops.literal, ["Body text"]]]],
       ]
     );
@@ -1398,7 +1399,7 @@ Body text`,
       `---
 {
   title: "Title"
-  @text: @template()
+  _body: _template()
 }
 ---
 <h1>\${ title }</h1>
@@ -1407,7 +1408,7 @@ Body text`,
         ops.object,
         ["title", [ops.literal, "Title"]],
         [
-          "@text",
+          "_body",
           [
             ops.templateIndent,
             [ops.literal, ["<h1>", "</h1>\n"]],
@@ -1441,34 +1442,31 @@ Body text`,
             [markers.traverse, [markers.reference, "title"]],
           ],
         ],
-      ],
-      "jse"
+      ]
     );
   });
 
   test("templateLiteral", () => {
     assertParse("templateLiteral", "`Hello, world.`", [
-      ops.templateTree,
+      ops.templateText,
+      [ops.literal, ["Hello, world."]],
+    ]);
+    assertParse("templateLiteral", "`Hello, world.`", [
+      ops.templateText,
       [ops.literal, ["Hello, world."]],
     ]);
-    assertParse(
-      "templateLiteral",
-      "`Hello, world.`",
-      [ops.templateTree, [ops.literal, ["Hello, world."]]],
-      "jse"
-    );
     assertParse("templateLiteral", "`foo ${x} bar`", [
-      ops.templateTree,
+      ops.templateText,
       [ops.literal, ["foo ", " bar"]],
       [markers.traverse, [markers.reference, "x"]],
     ]);
     assertParse("templateLiteral", "`${`nested`}`", [
-      ops.templateTree,
+      ops.templateText,
       [ops.literal, ["", ""]],
-      [ops.templateTree, [ops.literal, ["nested"]]],
+      [ops.templateText, [ops.literal, ["nested"]]],
     ]);
     assertParse("templateLiteral", "`${ map(people, =`${name}`) }`", [
-      ops.templateTree,
+      ops.templateText,
       [ops.literal, ["", ""]],
       [
         [markers.traverse, [markers.reference, "map"]],
@@ -1477,7 +1475,7 @@ Body text`,
           ops.lambda,
           [[ops.literal, "_"]],
           [
-            ops.templateTree,
+            ops.templateText,
             [ops.literal, ["", ""]],
             [markers.traverse, [markers.reference, "name"]],
           ],
@@ -1562,7 +1560,7 @@ Body text`,
   // Second comment
      `,
       null,
-      "jse",
+      "program",
       false
     );
   });
@@ -1596,7 +1594,7 @@ function assertParse(
   assertCodeEqual(code, expected);
 }
 
-function assertThrows(startRule, source, message, position, mode = "shell") {
+function assertThrows(startRule, source, message, position, mode = "program") {
   // @ts-ignore We declare this so we can inspect it in debugger
   let code;
   try {

package/test/runtime/ops.test.js

@@ -246,7 +246,7 @@ describe("ops", () => {
   test("ops.merge", async () => {
     // {
     //   a: 1
-    //   …more
+    //   ...more
     //   c: a
     // }
     const scope = new ObjectTree({
@@ -340,6 +340,13 @@ describe("ops", () => {
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
   });
 
+  test("ops.property returns a property if defined, otherwise traverses", async () => {
+    assert.equal(await ops.property({ a: 1 }, "a"), 1);
+    assert.equal(await ops.property({ a: 1 }, "b"), undefined);
+    const uppercase = (text) => text.toUpperCase();
+    assert.equal(await ops.property(uppercase, "a"), "A");
+  });
+
   test("ops.remainder calculates the remainder of two numbers", async () => {
     assert.strictEqual(ops.remainder(13, 5), 3);
     assert.strictEqual(ops.remainder(-13, 5), -3);

package/src/runtime/templateIndent.js

@@ -1,120 +0,0 @@
-import { deepText, toString, Tree } from "@weborigami/async-tree";
-
-const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
-
-const mapStringsToModifications = new Map();
-
-/**
- * Normalize indentation in a tagged template string
- *
- * @param {TemplateStringsArray} strings
- * @param  {...any} values
- * @returns {Promise<string>}
- */
-export default async function indent(strings, ...values) {
-  let modified = mapStringsToModifications.get(strings);
-  if (!modified) {
-    modified = modifyStrings(strings);
-    mapStringsToModifications.set(strings, modified);
-  }
-  const { blockIndentations, strings: modifiedStrings } = modified;
-  const valueTexts = await Promise.all(
-    values.map((value) => (Tree.isTreelike(value) ? deepText(value) : value))
-  );
-  return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
-}
-
-// Join strings and values, applying the given block indentation to the lines of
-// values for block placholders.
-function joinBlocks(strings, values, blockIndentations) {
-  let result = strings[0];
-  for (let i = 0; i < values.length; i++) {
-    let text = toString(values[i]);
-    if (text) {
-      const blockIndentation = blockIndentations[i];
-      if (blockIndentation) {
-        const lines = text.split("\n");
-        text = "";
-        if (lines.at(-1) === "") {
-          // Drop empty last line
-          lines.pop();
-        }
-        for (let line of lines) {
-          text += blockIndentation + line + "\n";
-        }
-      }
-      result += text;
-    }
-    result += strings[i + 1];
-  }
-  return result;
-}
-
-// Given an array of template boilerplate strings, return an object { modified,
-// blockIndentations } where `strings` is the array of strings with indentation
-// removed, and `blockIndentations` is an array of indentation strings for each
-// block placeholder.
-function modifyStrings(strings) {
-  // Phase one: Identify the indentation based on the first real line of the
-  // first string (skipping the initial newline), and remove this indentation
-  // from all lines of all strings.
-  let indent;
-  if (strings.length > 0 && strings[0].startsWith("\n")) {
-    // Look for indenttation
-    const firstLineWhitespaceRegex = /^\n(?<indent>[ \t]*)/;
-    const match = strings[0].match(firstLineWhitespaceRegex);
-    indent = match?.groups.indent;
-  }
-
-  // Determine the modified strings. If this invoked as a JS tagged template
-  // literal, the `strings` argument will be an odd array-ish object that we'll
-  // want to convert to a real array.
-  let modified;
-  if (indent) {
-    // De-indent the strings.
-    const indentationRegex = new RegExp(`\n${indent}`, "g");
-    // The `replaceAll` also converts strings to a real array.
-    modified = strings.map((string) =>
-      string.replaceAll(indentationRegex, "\n")
-    );
-    // Remove indentation from last line of last string
-    modified[modified.length - 1] = modified
-      .at(-1)
-      .replace(lastLineWhitespaceRegex, "\n");
-  } else {
-    // No indentation; just copy the strings so we have a real array
-    modified = strings.slice();
-  }
-
-  // Phase two: Identify any block placholders, identify and remove their
-  // preceding indentation, and remove the following newline. Work backward from
-  // the end towards the start because we're modifying the strings in place and
-  // our pattern matching won't work going forward from start to end.
-  let blockIndentations = [];
-  for (let i = modified.length - 2; i >= 0; i--) {
-    // Get the modified before and after substitution with index `i`
-    const beforeString = modified[i];
-    const afterString = modified[i + 1];
-    const match = beforeString.match(lastLineWhitespaceRegex);
-    if (match && afterString.startsWith("\n")) {
-      // The substitution between these strings is a block substitution
-      let blockIndentation = match.groups.indent;
-      blockIndentations[i] = blockIndentation;
-      // Trim the before and after strings
-      if (blockIndentation) {
-        modified[i] = beforeString.slice(0, -blockIndentation.length);
-      }
-      modified[i + 1] = afterString.slice(1);
-    }
-  }
-
-  // Remove newline from start of first string *after* removing indentation.
-  if (modified[0].startsWith("\n")) {
-    modified[0] = modified[0].slice(1);
-  }
-
-  return {
-    blockIndentations,
-    strings: modified,
-  };
-}

package/test/runtime/taggedTemplateIndent.test.js

@@ -1,44 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import indent from "../../src/runtime/templateIndent.js";
-
-describe("taggedTemplateIndent", () => {
-  test("joins strings and values together if template isn't a block template", async () => {
-    const result = await indent`a ${"b"} c`;
-    assert.equal(result, "a b c");
-  });
-
-  test("removes first and last lines if template is a block template", async () => {
-    const actual = await indent`
-    <p>
-      Hello, ${"Alice"}!
-    </p>
-    `;
-    const expected = `
-<p>
-  Hello, Alice!
-</p>
-`.trimStart();
-    assert.equal(actual, expected);
-  });
-
-  test("indents all lines in a block substitution", async () => {
-    const lines = `
-Line 1
-Line 2
-Line 3`.trimStart();
-    const actual = await indent`
-    <main>
-      ${lines}
-    </main>
-    `;
-    const expected = `
-<main>
-  Line 1
-  Line 2
-  Line 3
-</main>
-`.trimStart();
-    assert.equal(actual, expected);
-  });
-});