@weborigami/language 0.0.70 → 0.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.70",
+  "version": "0.0.71",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.70",
-    "@weborigami/types": "0.0.70",
+    "@weborigami/async-tree": "0.0.71",
+    "@weborigami/types": "0.0.71",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -1,15 +1,20 @@
+import { trailingSlash } from "@weborigami/async-tree";
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
+import { ops } from "../runtime/internal.js";
 import { parse } from "./parse.js";
 
 function compile(source, startRule) {
   if (typeof source === "string") {
     source = { text: source };
   }
-  const parseResult = parse(source.text, {
+  const code = parse(source.text, {
     grammarSource: source,
     startRule,
   });
-  const fn = createExpressionFunction(parseResult);
+  const cache = {};
+  const modified = cacheNonLocalScopeReferences(code, cache);
+  // const modified = code;
+  const fn = createExpressionFunction(modified);
   return fn;
 }
 
@@ -17,6 +22,63 @@ export function expression(source) {
   return compile(source, "expression");
 }
 
+// Given code containing ops.scope calls, upgrade them to ops.cache calls unless
+// they refer to local variables: variables defined by object literals or lambda
+// parameters.
+export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
+  const [fn, ...args] = code;
+
+  let additionalLocalNames;
+  switch (fn) {
+    case ops.scope:
+      const key = args[0];
+      const normalizedKey = trailingSlash.remove(key);
+      if (locals[normalizedKey]) {
+        return code;
+      } else {
+        // Upgrade to cached scope lookup
+        const modified = [ops.cache, key, cache];
+        /** @type {any} */ (modified).location = code.location;
+        return modified;
+      }
+
+    case ops.lambda:
+      const parameters = args[0];
+      additionalLocalNames = parameters;
+      break;
+
+    case ops.object:
+      const entries = args;
+      additionalLocalNames = entries.map(([key]) => trailingSlash.remove(key));
+      break;
+  }
+
+  let updatedLocals = { ...locals };
+  if (additionalLocalNames) {
+    for (const key of additionalLocalNames) {
+      updatedLocals[key] = true;
+    }
+  }
+
+  const modified = code.map((child) => {
+    if (Array.isArray(child)) {
+      // Review: This currently descends into arrays that are not instructions,
+      // such as the parameters of a lambda. This should be harmless, but it'd
+      // be preferable to only descend into instructions. This would require
+      // surrounding ops.lambda parameters with ops.literal, and ops.object
+      // entries with ops.array.
+      return cacheNonLocalScopeReferences(child, cache, updatedLocals);
+    } else {
+      return child;
+    }
+  });
+
+  if (code.location) {
+    modified.location = code.location;
+  }
+  return modified;
+}
+
 export function templateDocument(source) {
   return compile(source, "templateDocument");
 }

package/src/compiler/origami.pegjs

@@ -209,7 +209,7 @@ integer "integer"
 // A lambda expression: `=foo()`
 lambda "lambda function"
   = "=" __ expr:expr {
-      return annotate([ops.lambda, null, expr], location());
+      return annotate([ops.lambda, ["_"], expr], location());
     }
 
 // A path that begins with a slash: `/foo/bar`
@@ -435,7 +435,7 @@ taggedTemplate
 // literal, but can contain backticks at the top level.
 templateDocument "template"
   = contents:templateDocumentContents {
-      return annotate([ops.lambda, null, contents], location());
+      return annotate([ops.lambda, ["_"], contents], location());
     }
 
 // Template documents can contain backticks at the top level.

package/src/compiler/parse.js

@@ -416,7 +416,7 @@ function peg$parse(input, options) {
       return annotate([ops.literal, parseInt(text())], location());
     };
   var peg$f26 = function(expr) {
-      return annotate([ops.lambda, null, expr], location());
+      return annotate([ops.lambda, ["_"], expr], location());
     };
   var peg$f27 = function(path) {
       return annotate(path ?? [], location());
@@ -500,7 +500,7 @@ function peg$parse(input, options) {
       return annotate(makeTemplate(tag, contents[0], contents[1]), location());
     };
   var peg$f60 = function(contents) {
-      return annotate([ops.lambda, null, contents], location());
+      return annotate([ops.lambda, ["_"], contents], location());
     };
   var peg$f61 = function(head, tail) {
       return annotate(makeTemplate(ops.template, head, tail), location());

package/src/compiler/parserHelpers.js

@@ -1,3 +1,4 @@
+import { trailingSlash } from "@weborigami/async-tree";
 import * as ops from "../runtime/ops.js";
 
 // Parser helpers
@@ -21,9 +22,15 @@ function avoidRecursivePropertyCalls(code, key) {
     return code;
   }
   let modified;
-  if (code[0] === ops.scope && code[1] === key) {
+  if (
+    code[0] === ops.scope &&
+    trailingSlash.remove(code[1]) === trailingSlash.remove(key)
+  ) {
     // Rewrite to avoid recursion
-    modified = [ops.inherited, key];
+    modified = [ops.inherited, code[1]];
+  } else if (code[0] === ops.lambda && code[1].includes(key)) {
+    // Lambda that defines the key; don't rewrite
+    return code;
   } else {
     // Process any nested code
     modified = code.map((value) => avoidRecursivePropertyCalls(value, key));

package/src/runtime/extensions.js

@@ -8,6 +8,11 @@ import {
   trailingSlash,
 } from "@weborigami/async-tree";
 
+/** @typedef {import("../../index.ts").ExtensionHandler} ExtensionHandler */
+
+// Track extensions handlers for a given containing tree.
+const handlersForContainer = new Map();
+
 /**
  * If the given path ends in an extension, return it. Otherwise, return the
  * empty string.
@@ -38,18 +43,39 @@ export function extname(path) {
  * @param {string} extension
  */
 export async function getExtensionHandler(parent, extension) {
+  let handlers = handlersForContainer.get(parent);
+  if (handlers) {
+    if (handlers[extension]) {
+      return handlers[extension];
+    }
+  } else {
+    handlers = {};
+    handlersForContainer.set(parent, handlers);
+  }
+
   const handlerName = `${extension.slice(1)}_handler`;
   const parentScope = scope(parent);
-  /** @type {import("../../index.ts").ExtensionHandler} */
-  let extensionHandler = await parentScope?.get(handlerName);
-  if (isUnpackable(extensionHandler)) {
-    // The extension handler itself needs to be unpacked. E.g., if it's a
-    // buffer containing JavaScript file, we need to unpack it to get its
-    // default export.
-    // @ts-ignore
-    extensionHandler = await extensionHandler.unpack();
-  }
-  return extensionHandler;
+
+  /** @type {Promise<ExtensionHandler>} */
+  let handlerPromise = parentScope
+    ?.get(handlerName)
+    .then(async (extensionHandler) => {
+      if (isUnpackable(extensionHandler)) {
+        // The extension handler itself needs to be unpacked. E.g., if it's a
+        // buffer containing JavaScript file, we need to unpack it to get its
+        // default export.
+        // @ts-ignore
+        extensionHandler = await extensionHandler.unpack();
+      }
+      // Update cache with actual handler
+      handlers[extension] = extensionHandler;
+      return extensionHandler;
+    });
+
+  // Cache handler even if it's undefined so we don't look it up again
+  handlers[extension] = handlerPromise;
+
+  return handlerPromise;
 }
 
 /**
@@ -62,7 +88,7 @@ export async function getExtensionHandler(parent, extension) {
  * @param {any} key
  */
 export async function handleExtension(parent, value, key) {
-  if (isPacked(value) && isStringLike(key)) {
+  if (isPacked(value) && isStringLike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
       key = trailingSlash.remove(key);
@@ -89,10 +115,10 @@ export async function handleExtension(parent, value, key) {
         const unpack = handler.unpack;
         if (unpack) {
           // Wrap the unpack function so its only called once per value.
-          let loaded;
+          let loadPromise;
           value.unpack = async () => {
-            loaded ??= await unpack(value, { key, parent });
-            return loaded;
+            loadPromise ??= unpack(value, { key, parent });
+            return loadPromise;
           };
         }
       }

package/src/runtime/ops.js

@@ -43,9 +43,24 @@ export async function array(...items) {
 }
 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.
-export const assign = "«ops.assign»";
+/**
+ * Look up the given key in the scope for the current tree the first time
+ * the key is requested, holding on to the value for future requests.
+ *
+ * @this {AsyncTree|null}
+ */
+export async function cache(key, cache) {
+  if (key in cache) {
+    return cache[key];
+  }
+  // First save a promise for the value
+  const promise = scope.call(this, key);
+  cache[key] = promise;
+  const value = await promise;
+  // Now update with the actual value
+  cache[key] = value;
+  return value;
+}
 
 /**
  * Concatenate the given arguments.
@@ -123,6 +138,18 @@ async function constructSiteTree(protocol, treeClass, parent, host, ...keys) {
   return lastKey ? result.get(lastKey) : result;
 }
 
+/**
+ * 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»");
+
 /**
  * Fetch the resource at the given href.
  *
@@ -152,18 +179,6 @@ 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.
  *
@@ -236,17 +251,13 @@ export function lambda(parameters, code) {
     return lambdaFnMap.get(code);
   }
 
-  // By default, the first input argument is named `_`.
-  parameters ??= ["_"];
-
   /** @this {AsyncTree|null} */
   async function invoke(...args) {
-    // Add arguments and @recurse to scope.
+    // Add arguments to scope.
     const ambients = {};
     for (const parameter of parameters) {
       ambients[parameter] = args.shift();
     }
-    ambients["@recurse"] = invoke;
     const ambientTree = new ObjectTree(ambients);
     ambientTree.parent = this;
 

package/test/compiler/compile.test.js

@@ -2,6 +2,8 @@ import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
+import { ops } from "../../src/runtime/internal.js";
+import { stripCodeLocations } from "./stripCodeLocations.js";
 
 const shared = new ObjectTree({
   greet: (name) => `Hello, ${name}!`,
@@ -82,6 +84,30 @@ describe("compile", () => {
     const bob = await templateFn.call(scope, "Bob");
     assert.equal(bob, "Hello, Bob!");
   });
+
+  test("converts non-local ops.scope calls to ops.cache", async () => {
+    const expression = `
+      (name) => {
+        a: 1
+        b: a            // local, should be left as ops.scope
+        c: nonLocal     // non-local, should be converted to ops.cache
+        d: name         // local, should be left as ops.scope
+      }
+    `;
+    const fn = compile.expression(expression);
+    const code = fn.code;
+    assert.deepEqual(stripCodeLocations(code), [
+      ops.lambda,
+      ["name"],
+      [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [ops.scope, "a"]],
+        ["c", [ops.cache, "nonLocal", {}]],
+        ["d", [ops.scope, "name"]],
+      ],
+    ]);
+  });
 });
 
 async function assertCompile(text, expected) {

package/test/compiler/parse.test.js

@@ -1,8 +1,8 @@
-import { isPlainObject } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
 import * as ops from "../../src/runtime/ops.js";
+import { stripCodeLocations } from "./stripCodeLocations.js";
 
 describe("Origami parser", () => {
   test("absoluteFilePath", () => {
@@ -63,7 +63,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expr", "fn =`x`", [
       [ops.scope, "fn"],
-      [ops.lambda, null, [ops.template, [ops.literal, ["x"]]]],
+      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
     ]);
     assertParse("expr", "copy app(formulas), files 'snapshot'", [
       [ops.scope, "copy"],
@@ -80,7 +80,7 @@ describe("Origami parser", () => {
       [ops.scope, "@map"],
       [
         ops.lambda,
-        null,
+        ["_"],
         [
           ops.template,
           [ops.literal, ["<li>", "</li>"]],
@@ -271,12 +271,12 @@ describe("Origami parser", () => {
   test("lambda", () => {
     assertParse("lambda", "=message", [
       ops.lambda,
-      null,
+      ["_"],
       [ops.scope, "message"],
     ]);
     assertParse("lambda", "=`Hello, ${name}.`", [
       ops.lambda,
-      null,
+      ["_"],
       [
         ops.template,
         [ops.literal, ["Hello, ", "."]],
@@ -406,6 +406,18 @@ describe("Origami parser", () => {
     assertParse("objectEntry", "foo", ["foo", [ops.inherited, "foo"]]);
     assertParse("objectEntry", "x: y", ["x", [ops.scope, "y"]]);
     assertParse("objectEntry", "a: a", ["a", [ops.inherited, "a"]]);
+    assertParse("objectEntry", "a: (a) => a", [
+      "a",
+      [ops.lambda, ["a"], [ops.scope, "a"]],
+    ]);
+    assertParse("objectEntry", "posts/: @map(posts, post.ori)", [
+      "posts/",
+      [
+        [ops.scope, "@map"],
+        [ops.inherited, "posts"],
+        [ops.scope, "post.ori"],
+      ],
+    ]);
   });
 
   test("objectGetter", () => {
@@ -609,7 +621,7 @@ describe("Origami parser", () => {
   test("templateDocument", () => {
     assertParse("templateDocument", "hello${foo}world", [
       ops.lambda,
-      null,
+      ["_"],
       [
         ops.template,
         [ops.literal, ["hello", "world"]],
@@ -618,7 +630,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
-      null,
+      ["_"],
       [ops.template, [ops.literal, ["Documents can contain ` backticks"]]],
     ]);
   });
@@ -648,7 +660,7 @@ describe("Origami parser", () => {
           [ops.scope, "people"],
           [
             ops.lambda,
-            null,
+            ["_"],
             [
               ops.template,
               [ops.literal, ["", ""]],
@@ -695,23 +707,6 @@ function assertParse(startRule, source, expected, checkLocation = true) {
     assert.equal(resultSource, source.trim());
   }
 
-  const actual = stripLocations(code);
+  const actual = stripCodeLocations(code);
   assert.deepEqual(actual, expected);
 }
-
-// For comparison purposes, strip the `location` property added by the parser.
-function stripLocations(parseResult) {
-  if (Array.isArray(parseResult)) {
-    return parseResult.map(stripLocations);
-  } else if (isPlainObject(parseResult)) {
-    const result = {};
-    for (const key in parseResult) {
-      if (key !== "location") {
-        result[key] = stripLocations(parseResult[key]);
-      }
-    }
-    return result;
-  } else {
-    return parseResult;
-  }
-}

package/test/compiler/stripCodeLocations.js

@@ -0,0 +1,18 @@
+import { isPlainObject } from "@weborigami/async-tree";
+
+// For comparison purposes, strip the `location` property added by the parser.
+export function stripCodeLocations(parseResult) {
+  if (Array.isArray(parseResult)) {
+    return parseResult.map(stripCodeLocations);
+  } else if (isPlainObject(parseResult)) {
+    const result = {};
+    for (const key in parseResult) {
+      if (key !== "location") {
+        result[key] = stripCodeLocations(parseResult[key]);
+      }
+    }
+    return result;
+  } else {
+    return parseResult;
+  }
+}

package/test/runtime/ops.test.js

@@ -5,6 +5,20 @@ import { describe, test } from "node:test";
 import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
+  test("ops.cache looks up a value in scope and memoizes it", async () => {
+    let count = 0;
+    const tree = new ObjectTree({
+      get count() {
+        return ++count;
+      },
+    });
+    const code = createCode([ops.cache, "count", {}]);
+    const result = await evaluate.call(tree, code);
+    assert.equal(result, 1);
+    const result2 = await evaluate.call(tree, code);
+    assert.equal(result2, 1);
+  });
+
   test("ops.concat concatenates tree value text", async () => {
     const scope = new ObjectTree({
       name: "world",
@@ -47,20 +61,13 @@ describe("ops", () => {
       message: "Hello",
     });
 
-    const code = createCode([ops.lambda, null, [ops.scope, "message"]]);
+    const code = createCode([ops.lambda, ["_"], [ops.scope, "message"]]);
 
     const fn = await evaluate.call(scope, code);
     const result = await fn.call(scope);
     assert.equal(result, "Hello");
   });
 
-  test("ops.lambda adds input to scope as `_`", async () => {
-    const code = createCode([ops.lambda, null, [ops.scope, "_"]]);
-    const fn = await evaluate.call(null, code);
-    const result = await fn("Hello");
-    assert.equal(result, "Hello");
-  });
-
   test("ops.lambda adds input parameters to scope", async () => {
     const code = createCode([
       ops.lambda,
@@ -72,15 +79,6 @@ describe("ops", () => {
     assert.equal(result, "yx");
   });
 
-  test("ops.lambda function can reference itself with @recurse", async () => {
-    const code = createCode([ops.lambda, null, [ops.scope, "@recurse"]]);
-    const fn = await evaluate.call(null, code);
-    const result = await fn();
-    // We're expecting the function to return itself, but testing recursion is
-    // messy. We just confirm that the result has the same code as the original.
-    assert.equal(result.code, fn.code);
-  });
-
   test("ops.object instantiates an object", async () => {
     const scope = new ObjectTree({
       upper: (s) => s.toUpperCase(),