@weborigami/language 0.0.71-beta.1 → 0.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.71-beta.1",
+  "version": "0.0.72",
   "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.71-beta.1",
-    "@weborigami/types": "0.0.71-beta.1",
+    "@weborigami/async-tree": "0.0.72",
+    "@weborigami/types": "0.0.72",
     "watcher": "2.3.1"
   },
   "scripts": {

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

@@ -53,7 +53,7 @@ export async function getExtensionHandler(parent, extension) {
     handlersForContainer.set(parent, handlers);
   }
 
-  const handlerName = `${extension.slice(1)}_handler`;
+  const handlerName = `${extension.slice(1)}.handler`;
   const parentScope = scope(parent);
 
   /** @type {Promise<ExtensionHandler>} */
@@ -95,7 +95,7 @@ export async function handleExtension(parent, value, key) {
     }
 
     // Special case: `.ori.<ext>` extensions are Origami documents.
-    const extension = key.match(/\.ori\.\S+$/) ? ".ori_document" : extname(key);
+    const extension = key.match(/\.ori\.\S+$/) ? ".oridocument" : extname(key);
     if (extension) {
       const handler = await getExtensionHandler(parent, extension);
       if (handler) {

package/src/runtime/ops.js

@@ -62,10 +62,6 @@ export async function cache(key, cache) {
   return value;
 }
 
-// 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»";
-
 /**
  * Concatenate the given arguments.
  *
@@ -142,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.
  *
@@ -171,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.
  *
@@ -257,12 +253,11 @@ export function lambda(parameters, code) {
 
   /** @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/parse.test.js

@@ -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", () => {

package/test/runtime/expressionObject.test.js

@@ -54,7 +54,7 @@ describe("expressionObject", () => {
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
     const parent = new ObjectTree({
-      json_handler: {
+      "json.handler": {
         unpack: JSON.parse,
       },
     });

package/test/runtime/extensions.test.js

@@ -26,7 +26,7 @@ describe("extensions", () => {
 
 function createFixture() {
   const parent = new ObjectTree({
-    json_handler: {
+    "json.handler": {
       unpack: (buffer) => JSON.parse(String(buffer)),
     },
   });

package/test/runtime/ops.test.js

@@ -79,15 +79,6 @@ describe("ops", () => {
     assert.equal(result, "yx");
   });
 
-  test("ops.lambda function can reference itself with @recurse", async () => {
-    const code = createCode([ops.lambda, ["_"], [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(),