@weborigami/language 0.5.5 → 0.5.6

package/src/runtime/{handlers.js → handleExtension.js}

@@ -7,23 +7,22 @@ import {
   setParent,
   trailingSlash,
 } from "@weborigami/async-tree";
+import globals from "../project/projectGlobals.js";
+
+let projectGlobals;
 
 /**
  * If the given value is packed (e.g., buffer) and the key is a string-like path
  * that ends in an extension, search for a handler for that extension and, if
  * found, attach it to the value.
  *
- * @param {import("@weborigami/types").AsyncTree} parent
  * @param {any} value
  * @param {any} key
+ * @param {import("@weborigami/types").AsyncTree} [parent]
  */
-export async function handleExtension(parent, value, key, handlers) {
-  if (
-    handlers &&
-    isPacked(value) &&
-    isStringlike(key) &&
-    value.unpack === undefined
-  ) {
+export default async function handleExtension(value, key, parent) {
+  projectGlobals ??= await globals();
+  if (isPacked(value) && isStringlike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
       key = trailingSlash.remove(key);
@@ -38,8 +37,8 @@ export async function handleExtension(parent, value, key, handlers) {
       ? ".jsedocument"
       : extension.extname(key);
     if (extname) {
-      const handlerName = `${extname.slice(1)}.handler`;
-      let handler = await handlers[handlerName];
+      const handlerName = `${extname.slice(1)}_handler`;
+      let handler = await projectGlobals[handlerName];
       if (handler) {
         if (isUnpackable(handler)) {
           // The extension handler itself needs to be unpacked
@@ -57,7 +56,10 @@ export async function handleExtension(parent, value, key, handlers) {
         if (handler.mediaType) {
           value.mediaType = handler.mediaType;
         }
-        setParent(value, parent);
+
+        if (parent) {
+          setParent(value, parent);
+        }
 
         const unpack = handler.unpack;
         if (unpack) {

package/src/runtime/mergeTrees.js

@@ -1,9 +1,4 @@
-import {
-  isPlainObject,
-  isUnpackable,
-  setParent,
-  Tree,
-} from "@weborigami/async-tree";
+import { isPlainObject, isUnpackable, Tree } from "@weborigami/async-tree";
 
 /**
  * Create a tree that's the result of merging the given trees.
@@ -11,7 +6,6 @@ import {
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  *
- * @this {AsyncTree|null}
  * @param {(Treelike|null)[]} trees
  */
 export default async function mergeTrees(...trees) {
@@ -54,6 +48,5 @@ export default async function mergeTrees(...trees) {
 
   // Merge the trees.
   const result = Tree.merge(...unpacked);
-  setParent(result, this);
   return result;
 }

package/src/runtime/ops.js

@@ -3,12 +3,12 @@
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.ts").RuntimeState} RuntimeState
  */
 
-import { isUnpackable, ObjectTree, Tree } from "@weborigami/async-tree";
+import { isUnpackable, symbols, Tree } from "@weborigami/async-tree";
 import os from "node:os";
 import expressionObject from "./expressionObject.js";
-import getHandlers from "./getHandlers.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
@@ -29,7 +29,6 @@ addOpLabel(addition, "«ops.addition»");
 /**
  * Construct an array.
  *
- * @this {AsyncTree|null}
  * @param {any[]} items
  */
 export async function array(...items) {
@@ -60,7 +59,6 @@ addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 /**
  * Cache the value of the code for an external reference
  *
- * @this {AsyncTree|null}
  * @param {any} cache
  * @param {string} path
  * @param {AnnotatedCode} code
@@ -72,7 +70,7 @@ export async function cache(cache, path, code) {
   }
 
   // Don't await: might get another request for this before promise resolves
-  const promise = await evaluate.call(this, code);
+  const promise = await evaluate(code);
 
   // Save promise so another request will get the same promise
   cache[path] = promise;
@@ -91,13 +89,12 @@ cache.unevaluatedArgs = true;
 /**
  * JavaScript comma operator, returns the last argument.
  *
- * @this {AsyncTree|null}
  * @param  {...AnnotatedCode} args
  */
 export async function comma(...args) {
   let result;
   for (const arg of args) {
-    result = await evaluate.call(this, arg);
+    result = await evaluate(arg);
   }
   return result;
 }
@@ -107,11 +104,10 @@ comma.unevaluatedArgs = true;
 /**
  * Concatenate the given arguments.
  *
- * @this {AsyncTree|null}
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return Tree.deepText.call(this, args);
+  return Tree.deepText(args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -127,23 +123,6 @@ export async function construct(constructor, ...args) {
   return Reflect.construct(constructor, args);
 }
 
-/**
- * Return the nth parent of the current tree
- *
- * @this {AsyncTree|null|undefined}
- */
-export function context(n = 0) {
-  let tree = this;
-  for (let i = 0; i < n; i++) {
-    if (!tree) {
-      throw new Error("Internal error: couldn't find tree ancestor.");
-    }
-    tree = tree.parent;
-  }
-  return tree;
-}
-addOpLabel(context, "«ops.context»");
-
 export function division(a, b) {
   return a / b;
 }
@@ -195,65 +174,74 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
 
 /**
  * Files tree for the user's home directory.
- *
- * @this {AsyncTree|null}
  */
 export async function homeDirectory(...keys) {
   const tree = new OrigamiFiles(os.homedir());
-  // Use the same handlers as the current tree
-  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
+/**
+ * Given the tree currently be using as the context for the runtime, walk up the
+ * parent chain `depth` levels and return that tree.
+ *
+ * @param {number} depth
+ * @param {RuntimeState} state
+ */
+export async function inherited(depth, state) {
+  let current = state.object;
+  for (let i = 0; i < depth; i++) {
+    if (!current) {
+      throw new ReferenceError(
+        `Origami internal error: Can't find context object`
+      );
+    }
+    current = current.parent ?? current[symbols.parent];
+  }
+  return current;
+}
+addOpLabel(inherited, "«ops.inherited»");
+inherited.needsState = true;
+
 /**
  * Return a function that will invoke the given code.
  *
- * @this {AsyncTree|null}
  * @param {string[]} parameters
  * @param {AnnotatedCode} code
  */
-export function lambda(parameters, code) {
-  const context = this;
+export function lambda(parameters, code, state = {}) {
+  const stack = state.stack ?? [];
 
-  /** @this {Treelike|null} */
   async function invoke(...args) {
-    let target;
+    let newState;
     if (parameters.length === 0) {
       // No parameters
-      target = context;
+      newState = state;
     } else {
-      // Add arguments to scope.
-      const ambients = {};
+      // Create a stack frame for the parameters
+      const frame = {};
       for (const parameter of parameters) {
         const parameterName = parameter[1];
-        ambients[parameterName] = args.shift();
+        frame[parameterName] = args.shift();
       }
-      Object.defineProperty(ambients, codeSymbol, {
+      // Record which code this stack frame is associated with
+      Object.defineProperty(frame, codeSymbol, {
         value: code,
         enumerable: false,
       });
-      const ambientTree = new ObjectTree(ambients);
-      ambientTree.parent = context;
-      target = ambientTree;
-    }
-
-    let result = await evaluate.call(target, code);
-
-    // Bind a function result to the ambients so that it has access to the
-    // parameter values -- i.e., like a closure.
-    if (result instanceof Function) {
-      const resultCode = result.code;
-      result = result.bind(target);
-      if (code) {
-        // Copy over Origami code
-        result.code = resultCode;
-      }
+      const newStack = stack.slice();
+      newStack.push(frame);
+      newState = Object.assign({}, state, { stack: newStack });
     }
 
+    const result = await evaluate(code, newState);
     return result;
   }
 
+  // Retain a reference to the original code for debugging, and so that functions
+  // can be compared by their code (e.g., for caching purposes).
+  invoke.code = code;
+
   // We set the `length` property on the function so that Tree.traverseOrThrow()
   // will correctly identify how many parameters it wants. This is unorthodox
   // but doesn't appear to affect other behavior.
@@ -262,11 +250,11 @@ export function lambda(parameters, code) {
     value: fnLength,
   });
 
-  invoke.code = code;
   return invoke;
 }
 addOpLabel(lambda, "«ops.lambda»");
 lambda.unevaluatedArgs = true;
+lambda.needsState = true;
 
 export function lessThan(a, b) {
   return a < b;
@@ -348,11 +336,10 @@ addOpLabel(logicalOr, "«ops.logicalOr»");
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
- * @this {AsyncTree|null}
  * @param {any[]} trees
  */
 export async function merge(...trees) {
-  return mergeTrees.call(this, ...trees);
+  return mergeTrees(...trees);
 }
 addOpLabel(merge, "«ops.merge»");
 
@@ -396,14 +383,28 @@ addOpLabel(nullishCoalescing, "«ops.nullishCoalescing»");
  * parameter's, and the values will be the results of evaluating the
  * corresponding code values in `obj`.
  *
- * @this {AsyncTree|null}
  * @param {any[]} entries
  */
 export async function object(...entries) {
-  return expressionObject(entries, this);
+  const state = entries.pop();
+  return expressionObject(entries, state);
 }
 addOpLabel(object, "«ops.object»");
 object.unevaluatedArgs = true;
+object.needsState = true;
+
+/**
+ * Return the stack frame that's `depth` levels up the stack.
+ *
+ * @param {number} depth
+ * @param {RuntimeState} state
+ */
+export async function params(depth, state = {}) {
+  const stack = state.stack ?? [];
+  return stack[stack.length - 1 - depth];
+}
+addOpLabel(params, "«ops.params»");
+params.needsState = true;
 
 // export function optionalTraverse(treelike, key) {
 //   if (!treelike) {
@@ -416,39 +417,37 @@ object.unevaluatedArgs = true;
 /**
  * Return the indicated property
  *
- * @param {any} obj
+ * @param {any} object
  * @param {string} key
  */
-export async function property(obj, key) {
-  if (obj == null) {
+export async function property(object, key) {
+  if (object == null) {
     throw new ReferenceError();
   }
 
-  if (isUnpackable(obj)) {
-    obj = await obj.unpack();
-  } else if (typeof obj === "string") {
-    obj = new String(obj);
-  } else if (typeof obj === "number") {
-    obj = new Number(obj);
+  if (isUnpackable(object)) {
+    object = await object.unpack();
+  } else if (typeof object === "string") {
+    object = new String(object);
+  } else if (typeof object === "number") {
+    object = new Number(object);
   }
 
-  if (key in obj) {
+  if (key in object) {
     // Object defines the property, get it
-    let value = obj[key];
+    let value = object[key];
     // Is value an instance method? Copied from ObjectTree.
     const isInstanceMethod =
-      !(obj instanceof Function) &&
-      value instanceof Function &&
-      !Object.hasOwn(obj, key);
+      value instanceof Function && !Object.hasOwn(object, key);
     if (isInstanceMethod) {
       // Bind it to the object
-      value = value.bind(obj);
+      value = value.bind(object);
     }
     return value;
   }
 
   // Handle as tree traversal
-  return Tree.traverseOrThrow(obj, key);
+  return Tree.traverseOrThrow(object, key);
 }
 addOpLabel(property, "«ops.property»");
 
@@ -459,13 +458,9 @@ addOpLabel(remainder, "«ops.remainder»");
 
 /**
  * Files tree for the filesystem root.
- *
- * @this {AsyncTree|null}
  */
 export async function rootDirectory(...keys) {
   const tree = new OrigamiFiles("/");
-  // Use the same handlers as the current tree
-  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
@@ -473,17 +468,15 @@ addOpLabel(rootDirectory, "«ops.rootDirectory»");
 /**
  * Return the scope of the current tree
  *
- * @this {AsyncTree|null}
- * @param {AsyncTree|null} [context]
+ * @param {AsyncTree} parent
  */
-export async function scope(context) {
-  if (context === undefined) {
-    context = this;
-  }
-  if (!context) {
-    return null;
+export async function scope(parent) {
+  if (!parent) {
+    throw new ReferenceError(
+      "Tried to find a value in scope, but no container was provided as the parent."
+    );
   }
-  return Tree.scope(context);
+  return Tree.scope(parent);
 }
 addOpLabel(scope, "«ops.scope»");
 

package/test/compiler/compile.test.js

@@ -1,10 +1,10 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { 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 { assertCodeEqual } from "./codeHelpers.js";
 
-const sharedGlobals = {
+const globals = {
   greet: (name) => `Hello, ${name}!`,
   name: "Alice",
 };
@@ -43,21 +43,24 @@ describe("compile", () => {
     );
   });
 
-  test.skip("merge", async () => {
+  test("merge", async () => {
     {
-      const scope = new ObjectTree({
+      const globals = {
         more: {
           b: 2,
         },
-      });
-      const fn = compile.expression(`
+      };
+      const fn = compile.expression(
+        `
         {
           a: 1
           ...more
           c: a
         }
-      `);
-      const result = await fn.call(scope);
+      `,
+        { globals }
+      );
+      const result = await fn();
       assert.deepEqual(await Tree.plain(result), {
         a: 1,
         b: 2,
@@ -78,10 +81,8 @@ describe("compile", () => {
   });
 
   test("async object", async () => {
-    const fn = compile.expression("{ a: { b = name }}", {
-      globals: sharedGlobals,
-    });
-    const object = await fn.call(null);
+    const fn = compile.expression("{ a: { b = name }}", { globals });
+    const object = await fn();
     assert.deepEqual(await object.a.b, "Alice");
   });
 
@@ -89,8 +90,8 @@ describe("compile", () => {
     const defineTemplateFn = compile.templateDocument(
       "Documents can contain ` backticks"
     );
-    const templateFn = await defineTemplateFn.call(null);
-    const value = await templateFn.call(null);
+    const templateFn = await defineTemplateFn();
+    const value = await templateFn();
     assert.deepEqual(value, "Documents can contain ` backticks");
   });
 
@@ -115,8 +116,8 @@ describe("compile", () => {
         return strings[0] + values[0] + strings[1];
       },
     };
-    const program = compile.expression("=tag`Hello, ${_}!`", { globals });
-    const lambda = await program.call(null);
+    const program = compile.expression("(_) => tag`Hello, ${_}!`", { globals });
+    const lambda = await program();
     const alice = await lambda("Alice");
     assert.equal(alice, "Hello, Alice!");
     const bob = await lambda("Bob");
@@ -126,9 +127,9 @@ describe("compile", () => {
 
 async function assertCompile(text, expected, options = {}) {
   const mode = options.mode ?? "program";
-  const fn = compile.expression(text, { globals: sharedGlobals, mode });
-  const target = options.target ?? null;
-  let result = await fn.call(target);
+  const parent = options.target ?? null;
+  const fn = compile.expression(text, { globals, mode, parent });
+  let result = await fn();
   if (Tree.isTreelike(result)) {
     result = await Tree.plain(result);
   }