@weborigami/language 0.0.68 → 0.0.70

package/src/compiler/parserHelpers.js

@@ -13,8 +13,28 @@ export function annotate(parseResult, location) {
   return parseResult;
 }
 
+// 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
+// infinite recursion.
+function avoidRecursivePropertyCalls(code, key) {
+  if (!(code instanceof Array)) {
+    return code;
+  }
+  let modified;
+  if (code[0] === ops.scope && code[1] === key) {
+    // Rewrite to avoid recursion
+    modified = [ops.inherited, key];
+  } else {
+    // Process any nested code
+    modified = code.map((value) => avoidRecursivePropertyCalls(value, key));
+  }
+  // @ts-ignore
+  modified.location = code.location;
+  return modified;
+}
+
 // Return true if the code will generate an async object.
-function isAsyncObject(code) {
+function isCodeForAsyncObject(code) {
   if (!(code instanceof Array)) {
     return false;
   }
@@ -120,28 +140,29 @@ export function makeObject(entries, op) {
 
   for (let [key, value] of entries) {
     if (key === ops.spread) {
-      // Accumulate spread entry
+      // Spread entry; accumulate
       if (currentEntries.length > 0) {
         spreads.push([op, ...currentEntries]);
         currentEntries = [];
       }
       spreads.push(value);
-    } else {
-      if (
-        value instanceof Array &&
-        value[0] === ops.getter &&
-        value[1] instanceof Array &&
-        value[1][0] === ops.primitive
-      ) {
-        // Simplify a getter for a primitive value to a regular property
-        value = value[1];
-      } else if (isAsyncObject(value)) {
-        // Add a trailing slash to key if value is an async object
-        key = key + "/";
-      }
+      continue;
+    }
 
-      currentEntries.push([key, value]);
+    if (
+      value instanceof Array &&
+      value[0] === ops.getter &&
+      value[1] instanceof Array &&
+      value[1][0] === ops.literal
+    ) {
+      // Simplify a getter for a primitive value to a regular property
+      value = value[1];
+    } else if (isCodeForAsyncObject(value)) {
+      // Add a trailing slash to key to indicate value is a subtree
+      key = key + "/";
     }
+
+    currentEntries.push([key, value]);
   }
 
   // Finish any current entries.
@@ -170,16 +191,18 @@ export function makePipeline(steps) {
   return value;
 }
 
-export function makeTemplate(parts) {
-  // Drop empty/null strings.
-  const filtered = parts.filter((part) => part);
-  // Return a concatenation of the parts. If there are no parts, return the
-  // empty string. If there's just one string, return that directly.
-  return filtered.length === 0
-    ? ""
-    : filtered.length === 1 &&
-      filtered[0][0] === ops.primitive &&
-      typeof filtered[0][1] === "string"
-    ? filtered[0]
-    : [ops.concat, ...filtered];
+// Define a property on an object.
+export function makeProperty(key, value) {
+  const modified = avoidRecursivePropertyCalls(value, key);
+  return [key, modified];
+}
+
+export function makeTemplate(op, head, tail) {
+  const strings = [head];
+  const values = [];
+  for (const [value, string] of tail) {
+    values.push([ops.concat, value]);
+    strings.push(string);
+  }
+  return [op, [ops.literal, strings], ...values];
 }

package/src/runtime/WatchFilesMixin.js

@@ -43,6 +43,7 @@ export default function WatchFilesMixin(Base) {
       this.watcher = new Watcher(this.dirname, {
         ignoreInitial: true,
         persistent: false,
+        recursive: true,
       });
       this.watcher.on("all", (event, filePath) => {
         const key = path.basename(filePath);

package/src/runtime/evaluate.js

@@ -1,15 +1,7 @@
-import {
-  Tree,
-  isPlainObject,
-  isUnpackable,
-  scope,
-} from "@weborigami/async-tree";
+import { Tree, isUnpackable, scope } from "@weborigami/async-tree";
 import codeFragment from "./codeFragment.js";
 import { ops } from "./internal.js";
-
-const codeSymbol = Symbol("code");
-const scopeSymbol = Symbol("scope");
-const sourceSymbol = Symbol("source");
+import { codeSymbol, scopeSymbol, sourceSymbol } from "./symbols.js";
 
 /**
  * Evaluate the given code and return the result.
@@ -28,7 +20,7 @@ export default async function evaluate(code) {
   }
 
   let evaluated;
-  const unevaluatedFns = [ops.lambda, ops.object];
+  const unevaluatedFns = [ops.lambda, ops.object, ops.literal];
   if (unevaluatedFns.includes(code[0])) {
     // Don't evaluate instructions, use as is.
     evaluated = code;
@@ -93,11 +85,19 @@ export default async function evaluate(code) {
   }
 
   // To aid debugging, add the code to the result.
-  if (Object.isExtensible(result) && !isPlainObject(result)) {
+  if (Object.isExtensible(result) /* && !isPlainObject(result) */) {
     try {
-      result[codeSymbol] = code;
-      if (/** @type {any} */ (code).location) {
-        result[sourceSymbol] = codeFragment(code.location);
+      if (code.location && !result[sourceSymbol]) {
+        Object.defineProperty(result, sourceSymbol, {
+          value: codeFragment(code.location),
+          enumerable: false,
+        });
+      }
+      if (!result[codeSymbol]) {
+        Object.defineProperty(result, codeSymbol, {
+          value: code,
+          enumerable: false,
+        });
       }
       if (!result[scopeSymbol]) {
         Object.defineProperty(result, scopeSymbol, {

package/src/runtime/ops.js

@@ -9,6 +9,7 @@ import {
   SiteTree,
   Tree,
   isUnpackable,
+  pathFromKeys,
   scope as scopeFn,
   trailingSlash,
   concat as treeConcat,
@@ -19,10 +20,18 @@ import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
+import taggedTemplate from "./taggedTemplate.js";
 
 // For memoizing lambda functions
 const lambdaFnMap = new Map();
 
+function addOpLabel(op, label) {
+  Object.defineProperty(op, "toString", {
+    value: () => label,
+    enumerable: false,
+  });
+}
+
 /**
  * Construct an array.
  *
@@ -32,7 +41,7 @@ const lambdaFnMap = new Map();
 export async function array(...items) {
   return Array(...items);
 }
-array.toString = () => "«ops.array»";
+addOpLabel(array, "«ops.array»");
 
 // The assign op is a placeholder for an assignment declaration.
 // It is only used during parsing -- it shouldn't be executed.
@@ -47,7 +56,7 @@ export const assign = "«ops.assign»";
 export async function concat(...args) {
   return treeConcat.call(this, args);
 }
-concat.toString = () => "«ops.concat»";
+addOpLabel(concat, "«ops.concat»");
 
 /**
  * Find the indicated constructor in scope, then return a function which invokes
@@ -70,19 +79,18 @@ export async function constructor(...keys) {
       ? new constructor()
       : new constructor(...args);
 }
-constructor.toString = () => "«ops.constructor»";
+addOpLabel(constructor, "«ops.constructor»");
 
 /**
  * Given a protocol, a host, and a list of keys, construct an href.
  *
  * @param {string} protocol
  * @param {string} host
- * @param  {...string|Symbol} keys
+ * @param  {string[]} keys
  */
 function constructHref(protocol, host, ...keys) {
-  // Remove trailing slashes
-  const baseKeys = keys.map((key) => trailingSlash.remove(key));
-  let href = [host, ...baseKeys].join("/");
+  const path = pathFromKeys(keys);
+  let href = [host, path].join("/");
   if (!href.startsWith(protocol)) {
     if (!href.startsWith("//")) {
       href = `//${href}`;
@@ -99,7 +107,7 @@ function constructHref(protocol, host, ...keys) {
  * @param {import("../../index.ts").Constructor<AsyncTree>} treeClass
  * @param {AsyncTree|null} parent
  * @param {string} host
- * @param  {...string|Symbol} keys
+ * @param  {string[]} keys
  */
 async function constructSiteTree(protocol, treeClass, parent, host, ...keys) {
   // If the last key doesn't end in a slash, remove it for now.
@@ -144,6 +152,18 @@ async function fetchResponse(href) {
  */
 export const getter = new String("«ops.getter»");
 
+/**
+ * A site tree with JSON Keys via HTTPS.
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export function explorableSite(host, ...keys) {
+  return constructSiteTree("https:", ExplorableSiteTree, this, host, ...keys);
+}
+addOpLabel(explorableSite, "«ops.explorableSite»");
+
 /**
  * Construct a files tree for the filesystem root.
  *
@@ -165,26 +185,26 @@ export async function filesRoot() {
  *
  * @this {AsyncTree|null}
  * @param {string} host
- * @param  {...string|Symbol} keys
+ * @param  {...string} keys
  */
 export async function http(host, ...keys) {
   const href = constructHref("http:", host, ...keys);
   return fetchResponse.call(this, href);
 }
-http.toString = () => "«ops.http»";
+addOpLabel(http, "«ops.http»");
 
 /**
  * Retrieve a web resource via HTTPS.
  *
  * @this {AsyncTree|null}
  * @param {string} host
- * @param  {...string|Symbol} keys
+ * @param  {...string} keys
  */
 export function https(host, ...keys) {
   const href = constructHref("https:", host, ...keys);
   return fetchResponse.call(this, href);
 }
-https.toString = () => "«ops.https»";
+addOpLabel(https, "«ops.https»");
 
 /**
  * Search the parent's scope -- i.e., exclude the current tree -- for the given
@@ -200,7 +220,7 @@ export async function inherited(key) {
   const parentScope = scopeFn(this.parent);
   return parentScope.get(key);
 }
-inherited.toString = () => "«ops.inherited»";
+addOpLabel(inherited, "«ops.inherited»");
 
 /**
  * Return a function that will invoke the given code.
@@ -258,7 +278,15 @@ export function lambda(parameters, code) {
   lambdaFnMap.set(code, invoke);
   return invoke;
 }
-lambda.toString = () => "«ops.lambda";
+addOpLabel(lambda, "«ops.lambda");
+
+/**
+ * Return a primitive value
+ */
+export async function literal(value) {
+  return value;
+}
+addOpLabel(literal, "«ops.literal»");
 
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
@@ -269,7 +297,7 @@ lambda.toString = () => "«ops.lambda";
 export async function merge(...trees) {
   return mergeTrees.call(this, ...trees);
 }
-merge.toString = () => "«ops.merge»";
+addOpLabel(merge, "«ops.merge»");
 
 /**
  * Construct an object. The keys will be the same as the given `obj`
@@ -282,19 +310,7 @@ merge.toString = () => "«ops.merge»";
 export async function object(...entries) {
   return expressionObject(entries, this);
 }
-object.toString = () => "«ops.object»";
-
-/**
- * A site tree with JSON Keys via HTTPS.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string|Symbol} keys
- */
-export function explorableSite(host, ...keys) {
-  return constructSiteTree("https:", ExplorableSiteTree, this, host, ...keys);
-}
-explorableSite.toString = () => "«ops.explorableSite»";
+addOpLabel(object, "«ops.object»");
 
 /**
  * Look up the given key in the scope for the current tree.
@@ -308,7 +324,7 @@ export async function scope(key) {
   const scope = scopeFn(this);
   return scope.get(key);
 }
-scope.toString = () => "«ops.scope»";
+addOpLabel(scope, "«ops.scope»");
 
 /**
  * The spread operator is a placeholder during parsing. It should be replaced
@@ -319,15 +335,15 @@ export function spread(...args) {
     "A compile-time spread operator wasn't converted to an object merge."
   );
 }
-spread.toString = () => "«ops.spread»";
+addOpLabel(spread, "«ops.spread»");
 
 /**
- * Return a primitive value
+ * Apply the default tagged template function.
  */
-export async function primitive(value) {
-  return value;
+export function template(strings, ...values) {
+  return taggedTemplate(strings, values);
 }
-primitive.toString = () => "«ops.primitive»";
+addOpLabel(template, "«ops.template»");
 
 /**
  * Traverse a path of keys through a tree.
@@ -339,24 +355,24 @@ export const traverse = Tree.traverseOrThrow;
  *
  * @this {AsyncTree|null}
  * @param {string} host
- * @param  {...string|Symbol} keys
+ * @param  {...string} keys
  */
 export function treeHttp(host, ...keys) {
   return constructSiteTree("http:", SiteTree, this, host, ...keys);
 }
-treeHttp.toString = () => "«ops.treeHttp»";
+addOpLabel(treeHttp, "«ops.treeHttp»");
 
 /**
  * A website tree via HTTPS.
  *
  * @this {AsyncTree|null}
  * @param {string} host
- * @param  {...string|Symbol} keys
+ * @param  {...string} keys
  */
 export function treeHttps(host, ...keys) {
   return constructSiteTree("https:", SiteTree, this, host, ...keys);
 }
-treeHttps.toString = () => "«ops.treeHttps»";
+addOpLabel(treeHttps, "«ops.treeHttps»");
 
 /**
  * If the value is packed but has an unpack method, call it and return that as

package/src/runtime/symbols.js

@@ -0,0 +1,3 @@
+export const codeSymbol = Symbol("code");
+export const scopeSymbol = Symbol("scope");
+export const sourceSymbol = Symbol("source");

package/src/runtime/taggedTemplate.js

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

package/test/compiler/compile.test.js

@@ -61,6 +61,27 @@ describe("compile", () => {
       "escape characters with `backslash`"
     );
   });
+
+  test("tagged template string array is identical across calls", async () => {
+    let saved;
+    const scope = new ObjectTree({
+      tag: (strings, ...values) => {
+        assert.deepEqual(strings, ["Hello, ", "!"]);
+        if (saved) {
+          assert.equal(strings, saved);
+        } else {
+          saved = strings;
+        }
+        return strings[0] + values[0] + strings[1];
+      },
+    });
+    const fn = compile.expression("=tag`Hello, ${_}!`");
+    const templateFn = await fn.call(null);
+    const alice = await templateFn.call(scope, "Alice");
+    assert.equal(alice, "Hello, Alice!");
+    const bob = await templateFn.call(scope, "Bob");
+    assert.equal(bob, "Hello, Bob!");
+  });
 });
 
 async function assertCompile(text, expected) {