@weborigami/language 0.2.2 → 0.2.4

package/src/runtime/ops.js

@@ -12,6 +12,7 @@ import {
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
+import taggedTemplateIndent from "../../src/runtime/taggedTemplateIndent.js";
 import { builtinReferenceError, scopeReferenceError } from "./errors.js";
 import expressionObject from "./expressionObject.js";
 import { evaluate } from "./internal.js";
@@ -447,10 +448,18 @@ addOpLabel(subtraction, "«ops.subtraction»");
  * Apply the default tagged template function.
  */
 export function template(strings, ...values) {
-  return taggedTemplate(strings, values);
+  return taggedTemplate(strings, ...values);
 }
 addOpLabel(template, "«ops.template»");
 
+/**
+ * Apply the tagged template indent function.
+ */
+export function templateIndent(strings, ...values) {
+  return taggedTemplateIndent(strings, ...values);
+}
+addOpLabel(templateIndent, "«ops.templateIndent");
+
 /**
  * Traverse a path of keys through a tree.
  */

package/src/runtime/taggedTemplate.js

@@ -1,6 +1,6 @@
 // Default JavaScript tagged template function splices strings and values
 // together.
-export default function defaultTemplateJoin(strings, values) {
+export default function taggedTemplate(strings, ...values) {
   let result = strings[0];
   for (let i = 0; i < values.length; i++) {
     result += values[i] + strings[i + 1];

package/src/runtime/taggedTemplateIndent.js

@@ -0,0 +1,115 @@
+const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
+
+const mapStringsToModifications = new Map();
+
+/**
+ * Normalize indentation in a tagged template string.
+ *
+ * @param {TemplateStringsArray} strings
+ * @param  {...any} values
+ * @returns {string}
+ */
+export default function indent(strings, ...values) {
+  let modified = mapStringsToModifications.get(strings);
+  if (!modified) {
+    modified = modifyStrings(strings);
+    mapStringsToModifications.set(strings, modified);
+  }
+  const { blockIndentations, strings: modifiedStrings } = modified;
+  return joinBlocks(modifiedStrings, values, 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 = 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/compiler/compile.test.js

@@ -10,7 +10,7 @@ const shared = new ObjectTree({
   name: "Alice",
 });
 
-describe.only("compile", () => {
+describe("compile", () => {
   test("array", async () => {
     await assertCompile("[]", []);
     await assertCompile("[ 1, 2, 3, ]", [1, 2, 3]);
@@ -46,12 +46,14 @@ describe.only("compile", () => {
   test("async object", async () => {
     const fn = compile.expression("{ a: { b = name }}");
     const object = await fn.call(shared);
-    assert.deepEqual(await object["a/"].b, "Alice");
+    assert.deepEqual(await object.a.b, "Alice");
   });
 
   test("templateDocument", async () => {
-    const fn = compile.templateDocument("Documents can contain ` backticks");
-    const templateFn = await fn.call(shared);
+    const defineTemplateFn = compile.templateDocument(
+      "Documents can contain ` backticks"
+    );
+    const templateFn = await defineTemplateFn.call(null);
     const value = await templateFn.call(null);
     assert.deepEqual(value, "Documents can contain ` backticks");
   });
@@ -85,7 +87,7 @@ describe.only("compile", () => {
     assert.equal(bob, "Hello, Bob!");
   });
 
-  test.only("converts non-local ops.scope calls to ops.external", async () => {
+  test("converts non-local ops.scope calls to ops.external", async () => {
     const expression = `
       (name) => {
         a: 1
@@ -108,6 +110,18 @@ describe.only("compile", () => {
       ],
     ]);
   });
+
+  test("can apply a macro", async () => {
+    const literal = [ops.literal, 1];
+    const expression = `{ a: literal }`;
+    const fn = compile.expression(expression, {
+      macros: {
+        literal,
+      },
+    });
+    const code = fn.code;
+    assert.deepEqual(stripCodeLocations(code), [ops.object, ["a", literal]]);
+  });
 });
 
 async function assertCompile(text, expected) {

package/test/compiler/parse.test.js

@@ -433,6 +433,18 @@ describe("Origami parser", () => {
         [ops.scope, "slug"],
       ],
     ]);
+    assertParse("expression", "keys ~", [
+      [ops.builtin, "keys"],
+      [ops.homeDirectory],
+    ]);
+    assertParse("expression", "keys /Users/alice", [
+      [ops.builtin, "keys"],
+      [
+        ops.traverse,
+        [ops.rootDirectory, [ops.literal, "Users/"]],
+        [ops.literal, "alice"],
+      ],
+    ]);
 
     // Verify parser treatment of identifiers containing operators
     assertParse("expression", "a + b", [
@@ -667,7 +679,7 @@ describe("Origami parser", () => {
     assertParse("objectLiteral", "{ a: { b = fn() } }", [
       ops.object,
       [
-        "a/",
+        "a",
         [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
       ],
     ]);
@@ -970,7 +982,7 @@ describe("Origami parser", () => {
       ops.lambda,
       ["_"],
       [
-        ops.template,
+        ops.templateIndent,
         [ops.literal, ["hello", "world"]],
         [ops.concat, [ops.scope, "foo"]],
       ],
@@ -978,7 +990,10 @@ describe("Origami parser", () => {
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
       ["_"],
-      [ops.template, [ops.literal, ["Documents can contain ` backticks"]]],
+      [
+        ops.templateIndent,
+        [ops.literal, ["Documents can contain ` backticks"]],
+      ],
     ]);
   });
 

package/test/runtime/expressionObject.test.js

@@ -5,7 +5,7 @@ import { describe, test } from "node:test";
 import expressionObject from "../../src/runtime/expressionObject.js";
 import { ops } from "../../src/runtime/internal.js";
 
-describe("expressionObject", () => {
+describe.only("expressionObject", () => {
   test("can instantiate an object", async () => {
     const scope = new ObjectTree({
       upper: (s) => s.toUpperCase(),
@@ -73,4 +73,22 @@ describe("expressionObject", () => {
     assert.deepEqual(Object.keys(object), ["visible"]);
     assert.equal(object["hidden"], "shh");
   });
+
+  test.only("provides a symbols.keys method", async () => {
+    const entries = [
+      // Will return a tree, should have a slash
+      ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
+      ["hasSlash/", "This isn't really a tree but says it is"],
+      ["message", "Hello"],
+      // Immediate treelike value, should have a slash
+      ["object", [ops.object, ["b", [ops.literal, 2]]]],
+    ];
+    const object = await expressionObject(entries, null);
+    assert.deepEqual(object[symbols.keys](), [
+      "getter/",
+      "hasSlash/",
+      "message",
+      "object/",
+    ]);
+  });
 });

package/test/runtime/mergeTrees.test.js

@@ -1,50 +1,68 @@
-import { Tree } from "@weborigami/async-tree";
+import { ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import mergeTrees from "../../src/runtime/mergeTrees.js";
 
 describe("mergeTrees", () => {
-  test("merges trees", async () => {
-    const tree = await mergeTrees.call(
+  test("if all arguments are plain objects, result is a plain object", async () => {
+    let calledFoo = false;
+    let calledBar = false;
+    const result = await mergeTrees.call(
       null,
       {
         a: 1,
         b: 2,
+        get foo() {
+          calledFoo = true;
+          return true;
+        },
       },
       {
         b: 3,
         c: 4,
+        get bar() {
+          calledBar = true;
+          return true;
+        },
       }
     );
-    // @ts-ignore
-    assert.deepEqual(await Tree.plain(tree), {
+
+    // Shouldn't call functions when just getting keys
+    assert.deepEqual(Object.keys(result), ["a", "b", "foo", "c", "bar"]);
+    assert(!calledFoo);
+    assert(!calledBar);
+
+    assert.deepEqual(result, {
       a: 1,
       b: 3,
+      foo: true,
       c: 4,
+      bar: true,
     });
   });
 
-  test("if all arguments are plain objects, result is a plain object", async () => {
-    const result = await mergeTrees.call(
+  test("if all arguments are arrays, result is an array", async () => {
+    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
+    assert.deepEqual(result, [1, 2, 3, 4]);
+  });
+
+  test("merges heterogenous arguments as trees", async () => {
+    const tree = await mergeTrees.call(
       null,
-      {
+      new ObjectTree({
         a: 1,
         b: 2,
-      },
+      }),
       {
         b: 3,
         c: 4,
       }
     );
-    assert.deepEqual(result, {
+    // @ts-ignore
+    assert.deepEqual(await Tree.plain(tree), {
       a: 1,
       b: 3,
       c: 4,
     });
   });
-
-  test("if all arguments are arrays, result is an array", async () => {
-    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
-    assert.deepEqual(result, [1, 2, 3, 4]);
-  });
 });

package/test/runtime/taggedTemplateIndent.test.js

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