@weborigami/language 0.2.1 → 0.2.3

package/src/runtime/expressionObject.js

@@ -1,4 +1,10 @@
-import { extension, ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import {
+  extension,
+  ObjectTree,
+  symbols,
+  trailingSlash,
+  Tree,
+} from "@weborigami/async-tree";
 import { handleExtension } from "./handlers.js";
 import { evaluate, ops } from "./internal.js";
 
@@ -11,8 +17,8 @@ import { evaluate, ops } from "./internal.js";
  *
  * 1. A primitive value (string, etc.). This will be defined directly as an
  *    object property.
- * 1. An immediate code entry. This will be evaluated during this call and its
- *    result defined as an object property.
+ * 1. An eager (as opposed to lazy) code entry. This will be evaluated during
+ *    this call and its result defined as an object property.
  * 1. A code entry that starts with ops.getter. This will be defined as a
  *    property getter on the object.
  *
@@ -25,15 +31,9 @@ export default async function expressionObject(entries, parent) {
   if (parent !== null && !Tree.isAsyncTree(parent)) {
     throw new TypeError(`Parent must be an AsyncTree or null`);
   }
-  Object.defineProperty(object, symbols.parent, {
-    configurable: true,
-    enumerable: false,
-    value: parent,
-    writable: true,
-  });
 
   let tree;
-  const immediateProperties = [];
+  const eagerProperties = [];
   for (let [key, value] of entries) {
     // Determine if we need to define a getter or a regular property. If the key
     // has an extension, we need to define a getter. If the value is code (an
@@ -61,7 +61,6 @@ export default async function expressionObject(entries, parent) {
 
     if (defineProperty) {
       // Define simple property
-      // object[key] = value;
       Object.defineProperty(object, key, {
         configurable: true,
         enumerable,
@@ -74,7 +73,7 @@ export default async function expressionObject(entries, parent) {
       if (value[0] === ops.getter) {
         code = value[1];
       } else {
-        immediateProperties.push(key);
+        eagerProperties.push(key);
         code = value;
       }
 
@@ -102,9 +101,25 @@ export default async function expressionObject(entries, parent) {
     }
   }
 
+  // Attach a keys method
+  Object.defineProperty(object, symbols.keys, {
+    configurable: true,
+    enumerable: false,
+    value: () => keys(object, eagerProperties, entries),
+    writable: true,
+  });
+
+  // Attach the parent
+  Object.defineProperty(object, symbols.parent, {
+    configurable: true,
+    enumerable: false,
+    value: parent,
+    writable: true,
+  });
+
   // Evaluate any properties that were declared as immediate: get their value
   // and overwrite the property getter with the actual value.
-  for (const key of immediateProperties) {
+  for (const key of eagerProperties) {
     const value = await object[key];
     // @ts-ignore Unclear why TS thinks `object` might be undefined here
     const enumerable = Object.getOwnPropertyDescriptor(object, key).enumerable;
@@ -118,3 +133,31 @@ export default async function expressionObject(entries, parent) {
 
   return object;
 }
+
+function entryKey(object, eagerProperties, entry) {
+  const [key, value] = entry;
+
+  const hasExplicitSlash = trailingSlash.has(key);
+  if (hasExplicitSlash) {
+    // Return key as is
+    return key;
+  }
+
+  // If eager property value is treelike, add slash to the key
+  if (eagerProperties.includes(key) && Tree.isTreelike(object[key])) {
+    return trailingSlash.add(key);
+  }
+
+  // If entry will definitely create a subtree, add a trailing slash
+  const entryCreatesSubtree =
+    value instanceof Array &&
+    (value[0] === ops.object ||
+      (value[0] === ops.getter &&
+        value[1] instanceof Array &&
+        (value[1][0] === ops.object || value[1][0] === ops.merge)));
+  return trailingSlash.toggle(key, entryCreatesSubtree);
+}
+
+function keys(object, eagerProperties, entries) {
+  return entries.map((entry) => entryKey(object, eagerProperties, entry));
+}

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

@@ -667,7 +667,7 @@ describe("Origami parser", () => {
     assertParse("objectLiteral", "{ a: { b = fn() } }", [
       ops.object,
       [
-        "a/",
+        "a",
         [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
       ],
     ]);
@@ -687,7 +687,7 @@ describe("Origami parser", () => {
     assertParse("objectLiteral", "{ a: 1, ...b }", [
       ops.merge,
       [ops.object, ["a", [ops.literal, 1]]],
-      [undetermined, "b"],
+      [ops.scope, "b"],
     ]);
     assertParse("objectLiteral", "{ (a): 1 }", [
       ops.object,
@@ -946,9 +946,9 @@ describe("Origami parser", () => {
     assertParse("singleLineComment", "// Hello, world!", null, false);
   });
 
-  test("spread", () => {
-    assertParse("spread", "...a", [ops.spread, [undetermined, "a"]]);
-    assertParse("spread", "…a", [ops.spread, [undetermined, "a"]]);
+  test("spreadElement", () => {
+    assertParse("spreadElement", "...a", [ops.spread, [ops.scope, "a"]]);
+    assertParse("spreadElement", "…a", [ops.spread, [ops.scope, "a"]]);
   });
 
   test("stringLiteral", () => {
@@ -970,7 +970,7 @@ describe("Origami parser", () => {
       ops.lambda,
       ["_"],
       [
-        ops.template,
+        ops.templateIndent,
         [ops.literal, ["hello", "world"]],
         [ops.concat, [ops.scope, "foo"]],
       ],
@@ -978,7 +978,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/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);
+  });
+});