@weborigami/language 0.0.59 → 0.0.61

package/src/runtime/ExpressionTree.js

@@ -1,20 +1,6 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { DeepObjectTree } from "@weborigami/async-tree";
 import InvokeFunctionsTransform from "./InvokeFunctionsTransform.js";
-import { expressionFunction } from "./internal.js";
 
 export default class ExpressionTree extends InvokeFunctionsTransform(
-  ObjectTree
-) {
-  // Return the unevaluated expressions in the original object.
-  expressions() {
-    const obj = /** @type {any} */ (this).object;
-    const result = {};
-    for (const key in obj) {
-      const value = obj[key];
-      if (expressionFunction.isExpressionFunction(value)) {
-        result[key] = value.code;
-      }
-    }
-    return result;
-  }
-}
+  DeepObjectTree
+) {}

package/src/runtime/HandleExtensionsTransform.js

@@ -1,5 +1,4 @@
 import { isStringLike } from "@weborigami/async-tree";
-import Scope from "./Scope.js";
 import handleExtension from "./handleExtension.js";
 
 /**
@@ -17,8 +16,7 @@ export default function HandleExtensionsTransform(Base) {
       // If the key is string-like and has an extension, attach a loader (if one
       // exists) that handles that extension.
       if (value && isStringLike(key)) {
-        const scope = Scope.getScope(this);
-        value = await handleExtension(scope, String(key), value, this);
+        value = await handleExtension(this, String(key), value);
       }
 
       return value;

package/src/runtime/InvokeFunctionsTransform.js

@@ -1,5 +1,4 @@
 import { Tree } from "@weborigami/async-tree";
-import Scope from "./Scope.js";
 
 /**
  * When using `get` to retrieve a value from a tree, if the value is a
@@ -14,10 +13,9 @@ export default function InvokeFunctionsTransform(Base) {
     async get(key) {
       let value = await super.get(key);
       if (typeof value === "function") {
-        const scope = Scope.getScope(this);
-        value = await value.call(scope);
+        value = await value.call(this);
 
-        if (Tree.isAsyncTree(value)) {
+        if (Tree.isAsyncTree(value) && !value.parent) {
           value.parent = this;
         }
       }

package/src/runtime/OrigamiTransform.d.ts

@@ -1,11 +1,5 @@
 import { Mixin } from "../../index.ts";
 
-import type { AsyncTree } from "@weborigami/types";
-
-// TODO: Figure out how to import declarations from InheritScopeMixin and
-// HandleExtensionsTransform and apply them here.
-declare const OrigamiTransform: Mixin<{
-  scope: AsyncTree|null;
-}>;
+declare const OrigamiTransform: Mixin<{}>;
 
 export default OrigamiTransform;

package/src/runtime/OrigamiTransform.js

@@ -1,13 +1,3 @@
+// Right now this just applies HandleExtensionsTransform.
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
-import InheritScopeMixin from "./InheritScopeMixin.js";
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function OrigamiTransform(Base) {
-  return class Origami extends InheritScopeMixin(
-    HandleExtensionsTransform(Base)
-  ) {};
-}
+export default HandleExtensionsTransform;

package/src/runtime/evaluate.js

@@ -1,26 +1,27 @@
-import { Tree, isPlainObject, isUnpackable } from "@weborigami/async-tree";
+import {
+  Tree,
+  isPlainObject,
+  isUnpackable,
+  scope,
+} from "@weborigami/async-tree";
 import { ops } from "./internal.js";
 
 const codeSymbol = Symbol("code");
+const scopeSymbol = Symbol("scope");
 const sourceSymbol = Symbol("source");
 
 /**
  * Evaluate the given code and return the result.
  *
- * `this` should be the scope used to look up references found in the code.
+ * `this` should be the tree used as the context for the evaluation.
  *
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {Treelike|null}
+ * @this {import("@weborigami/types").AsyncTree|null}
  * @param {any} code
  */
 export default async function evaluate(code) {
-  const scope = this;
+  const tree = this;
 
-  if (code === ops.scope) {
-    // ops.scope is a placeholder for the context's scope.
-    return scope;
-  } else if (!(code instanceof Array)) {
+  if (!(code instanceof Array)) {
     // Simple scalar; return as is.
     return code;
   }
@@ -33,7 +34,7 @@ export default async function evaluate(code) {
   } else {
     // Evaluate each instruction in the code.
     evaluated = await Promise.all(
-      code.map((instruction) => evaluate.call(scope, instruction))
+      code.map((instruction) => evaluate.call(tree, instruction))
     );
   }
 
@@ -61,7 +62,7 @@ export default async function evaluate(code) {
   try {
     result =
       fn instanceof Function
-        ? await fn.call(scope, ...args) // Invoke the function
+        ? await fn.call(tree, ...args) // Invoke the function
         : await Tree.traverseOrThrow(fn, ...args); // Traverse the tree.
   } catch (/** @type {any} */ error) {
     if (!error.location) {
@@ -71,6 +72,12 @@ export default async function evaluate(code) {
     throw error;
   }
 
+  // If the result is a tree, then the default parent of the tree is the current
+  // tree.
+  if (Tree.isAsyncTree(result) && !result.parent) {
+    result.parent = tree;
+  }
+
   // To aid debugging, add the code to the result.
   if (
     result &&
@@ -83,6 +90,14 @@ export default async function evaluate(code) {
       if (/** @type {any} */ (code).location) {
         result[sourceSymbol] = codeFragment(code);
       }
+      if (!result[scopeSymbol]) {
+        Object.defineProperty(result, scopeSymbol, {
+          get() {
+            return scope(result).trees;
+          },
+          enumerable: false,
+        });
+      }
     } catch (/** @type {any} */ error) {
       // Ignore errors.
     }

package/src/runtime/functionResultsMap.js

@@ -1,5 +1,4 @@
 import { map, Tree } from "@weborigami/async-tree";
-import Scope from "./Scope.js";
 
 /**
  * When using `get` to retrieve a value from a tree, if the value is a
@@ -12,9 +11,8 @@ export default function functionResultsMap(treelike) {
     value: async (sourceValue, sourceKey, tree) => {
       let resultValue;
       if (typeof sourceValue === "function") {
-        const scope = Scope.getScope(tree);
-        resultValue = await sourceValue.call(scope);
-        if (Tree.isAsyncTree(resultValue)) {
+        resultValue = await sourceValue.call(tree);
+        if (Tree.isAsyncTree(resultValue) && !resultValue.parent) {
           resultValue.parent = tree;
         }
       } else {

package/src/runtime/handleExtension.js

@@ -1,4 +1,4 @@
-import { isUnpackable, symbols } from "@weborigami/async-tree";
+import { isUnpackable, scope, symbols } from "@weborigami/async-tree";
 import extname from "./extname.js";
 
 /**
@@ -8,18 +8,18 @@ import extname from "./extname.js";
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
- * @param {AsyncTree|null} scope
+ * @param {AsyncTree} parent
  * @param {any} key
  * @param {any} value
- * @param {AsyncTree|null} parent
  */
-export default async function handleExtension(scope, key, value, parent) {
+export default async function handleExtension(parent, key, value) {
   const extension = extname(key);
   let result = value;
   if (extension) {
     const handlerName = `${extension.slice(1)}_handler`;
+    const parentScope = scope(parent);
     /** @type {import("../../index.ts").ExtensionHandler} */
-    let extensionHandler = await scope?.get(handlerName);
+    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

package/src/runtime/mergeTrees.js

@@ -1,5 +1,4 @@
 import { isPlainObject, isUnpackable, merge } from "@weborigami/async-tree";
-import Scope from "./Scope.js";
 
 /**
  * Create a tree that's the result of merging the given trees.
@@ -38,21 +37,7 @@ export default async function mergeTrees(...trees) {
     return unpacked.flat();
   }
 
-  // If a tree can take a scope, give it one that includes the other trees and
-  // the current scope.
-  const scopedTrees = unpacked.map((tree) => {
-    const otherTrees = unpacked.filter((g) => g !== tree);
-    const scope = new Scope(...otherTrees, this);
-    // Each tree will be included first in its own scope.
-    return Scope.treeWithScope(tree, scope);
-  });
-
   // Merge the trees.
-  const result = merge(...scopedTrees);
-
-  // Give the overall mixed tree a scope that includes the component trees and
-  // the current scope.
-  /** @type {any} */ (result).scope = new Scope(result, this);
-
+  const result = merge(...unpacked);
   return result;
 }

package/src/runtime/ops.js

@@ -8,11 +8,11 @@ import {
   SiteTree,
   Tree,
   isUnpackable,
+  scope as scopeFn,
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import OrigamiFiles from "./OrigamiFiles.js";
-import Scope from "./Scope.js";
 import handleExtension from "./handleExtension.js";
 import { OrigamiTree, evaluate, expressionFunction } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
@@ -72,12 +72,18 @@ function constructHref(protocol, host, ...keys) {
  * @param  {...any} keys
  */
 export async function constructor(...keys) {
-  const scope = this;
+  const tree = this;
+  const scope = scopeFn(tree);
   let constructor = await Tree.traverseOrThrow(scope, ...keys);
   if (isUnpackable(constructor)) {
     constructor = await constructor.unpack();
   }
-  return (...args) => new constructor(...args);
+  // Origami may pass `undefined` as the first argument to the constructor. We
+  // don't pass that along, because constructors like `Date` don't like it.
+  return (...args) =>
+    args.length === 1 && args[0] === undefined
+      ? new constructor()
+      : new constructor(...args);
 }
 constructor.toString = () => "«ops.constructor»";
 
@@ -97,8 +103,8 @@ async function fetchResponse(href) {
   // Attach any loader defined for the file type.
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();
-  if (filename) {
-    buffer = await handleExtension(this, filename, buffer, null);
+  if (this && filename) {
+    buffer = await handleExtension(this, filename, buffer);
   }
 
   return buffer;
@@ -110,13 +116,12 @@ async function fetchResponse(href) {
  * @this {AsyncTree|null}
  */
 export async function filesRoot() {
-  /** @type {AsyncTree} */
   let root = new OrigamiFiles("/");
 
-  // The root itself needs a scope so that expressions evaluated within it
+  // The root itself needs a parent so that expressions evaluated within it
   // (e.g., Origami expressions loaded from .ori files) will have access to
   // things like the built-in functions.
-  root = Scope.treeWithScope(root, this);
+  root.parent = this;
 
   return root;
 }
@@ -148,17 +153,18 @@ export function https(host, ...keys) {
 https.toString = () => "«ops.https»";
 
 /**
- * Search the inherited scope -- i.e., exclude the current tree -- for the
- * given key.
+ * Search the parent's scope -- i.e., exclude the current tree -- for the given
+ * key.
  *
  * @this {AsyncTree|null}
  * @param {*} key
  */
 export async function inherited(key) {
-  const scope = this;
-  const scopeTrees = /** @type {any} */ (scope).trees ?? scope;
-  const inheritedScope = new Scope(...scopeTrees.slice(1));
-  return inheritedScope.get(key);
+  if (!this?.parent) {
+    return undefined;
+  }
+  const parentScope = scopeFn(this.parent);
+  return parentScope.get(key);
 }
 inherited.toString = () => "«ops.inherited»";
 
@@ -170,6 +176,7 @@ inherited.toString = () => "«ops.inherited»";
  * @param {string[]} parameters
  * @param {Code} code
  */
+
 export function lambda(parameters, code) {
   if (lambdaFnMap.has(code)) {
     return lambdaFnMap.get(code);
@@ -186,15 +193,16 @@ export function lambda(parameters, code) {
       ambients[parameter] = args.shift();
     }
     ambients["@recurse"] = invoke;
-    const scope = new Scope(new ObjectTree(ambients), this);
+    const ambientTree = new ObjectTree(ambients);
+    ambientTree.parent = this;
 
-    let result = await evaluate.call(scope, code);
+    let result = await evaluate.call(ambientTree, code);
 
-    // Bind a function result to the scope so that it has access to the
+    // 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(scope);
+      result = result.bind(ambientTree);
       if (code) {
         // Copy over Origami code
         result.code = resultCode;
@@ -216,7 +224,7 @@ export function lambda(parameters, code) {
   lambdaFnMap.set(code, invoke);
   return invoke;
 }
-lambda.toString = () => "«ops.lambda»";
+lambda.toString = () => "«ops.lambda";
 
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
@@ -238,16 +246,30 @@ merge.toString = () => "«ops.merge»";
  * @param {any[]} entries
  */
 export async function object(...entries) {
-  const scope = this;
+  const tree = this;
   const promises = entries.map(async ([key, value]) => [
     key,
-    await evaluate.call(scope, value),
+    await evaluate.call(tree, value),
   ]);
   const evaluated = await Promise.all(promises);
   return Object.fromEntries(evaluated);
 }
 object.toString = () => "«ops.object»";
 
+/**
+ * Look up the given key in the scope for the current tree.
+ *
+ * @this {AsyncTree|null}
+ */
+export async function scope(key) {
+  if (!this) {
+    throw new Error("Tried to get the scope of a null or undefined tree.");
+  }
+  const scope = scopeFn(this);
+  return scope.get(key);
+}
+scope.toString = () => "«ops.scope»";
+
 /**
  * The spread operator is a placeholder during parsing. It should be replaced
  * with an object merge.
@@ -282,7 +304,7 @@ export async function tree(...entries) {
   });
   const object = Object.fromEntries(fns);
   const result = new OrigamiTree(object);
-  result.scope = new Scope(result, this);
+  result.parent = this;
   return result;
 }
 tree.toString = () => "«ops.tree»";
@@ -296,9 +318,8 @@ tree.toString = () => "«ops.tree»";
  */
 export function treeHttp(host, ...keys) {
   const href = constructHref("http:", host, ...keys);
-  /** @type {AsyncTree} */
   let result = new (HandleExtensionsTransform(SiteTree))(href);
-  result = Scope.treeWithScope(result, this);
+  result.parent = this;
   return result;
 }
 treeHttp.toString = () => "«ops.treeHttp»";
@@ -312,12 +333,8 @@ treeHttp.toString = () => "«ops.treeHttp»";
  */
 export function treeHttps(host, ...keys) {
   const href = constructHref("https:", host, ...keys);
-  /** @type {AsyncTree} */
   let result = new (HandleExtensionsTransform(SiteTree))(href);
-  result = Scope.treeWithScope(result, this);
+  result.parent = this;
   return result;
 }
 treeHttps.toString = () => "«ops.treeHttps»";
-
-// The scope op is a placeholder for the tree's scope.
-export const scope = "«ops.scope»";

package/test/compiler/compile.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 
-const scope = new ObjectTree({
+const shared = new ObjectTree({
   greet: (name) => `Hello, ${name}!`,
   name: "Alice",
 });
@@ -24,7 +24,7 @@ describe("compile", () => {
   test("tree", async () => {
     const fn = compile.expression("{ message = greet(name) }");
     const tree = await fn.call(null);
-    tree.scope = scope;
+    tree.parent = shared;
     assert.deepEqual(await Tree.plain(tree), {
       message: "Hello, Alice!",
     });
@@ -43,7 +43,7 @@ describe("compile", () => {
 
   test("templateDocument", async () => {
     const fn = compile.templateDocument("Documents can contain ` backticks");
-    const templateFn = await fn.call(scope);
+    const templateFn = await fn.call(shared);
     const value = await templateFn.call(null);
     assert.deepEqual(value, "Documents can contain ` backticks");
   });
@@ -59,6 +59,6 @@ describe("compile", () => {
 
 async function assertCompile(text, expected) {
   const fn = compile.expression(text);
-  const result = await fn.call(scope);
+  const result = await fn.call(shared);
   assert.deepEqual(result, expected);
 }

package/test/compiler/parse.test.js

@@ -438,6 +438,7 @@ describe("Origami parser", () => {
     assertParse("string", "'bar baz'", "bar baz");
     assertParse("string", `"foo\\"s bar"`, `foo"s bar`);
     assertParse("string", `'bar\\'s baz'`, `bar's baz`);
+    assertParse("string", `«string»`, "string");
   });
 
   test("templateDocument", () => {

package/test/runtime/HandleExtensionsTransform.test.js

@@ -2,7 +2,6 @@ import { ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import HandleExtensionsTransform from "../../src/runtime/HandleExtensionsTransform.js";
-import Scope from "../../src/runtime/Scope.js";
 
 describe("HandleExtensionsTransform", () => {
   test("invokes an appropriate loader for a .json file extension", async () => {
@@ -25,17 +24,17 @@ describe("HandleExtensionsTransform", () => {
 });
 
 function createFixture() {
-  /** @type {import("@weborigami/types").AsyncTree} */
-  let tree = new (HandleExtensionsTransform(ObjectTree))({
-    foo: 1, // No extension, should be left alone
-    "bar.json": `{ "bar": 2 }`,
-  });
   /** @type {any} */
-  const scope = new ObjectTree({
+  const parent = new ObjectTree({
     json_handler: {
       unpack: (buffer) => JSON.parse(String(buffer)),
     },
   });
-  tree = Scope.treeWithScope(tree, scope);
+  /** @type {import("@weborigami/types").AsyncTree} */
+  let tree = new (HandleExtensionsTransform(ObjectTree))({
+    foo: 1, // No extension, should be left alone
+    "bar.json": `{ "bar": 2 }`,
+  });
+  tree.parent = parent;
   return tree;
 }

package/test/runtime/evaluate.test.js

@@ -8,10 +8,12 @@ import evaluate from "../../src/runtime/evaluate.js";
 describe("evaluate", () => {
   test("can retrieve values from scope", async () => {
     const code = [ops.scope, "message"];
-    const scope = {
+    const parent = new ObjectTree({
       message: "Hello",
-    };
-    const result = await evaluate.call(scope, code);
+    });
+    const tree = new ObjectTree({});
+    tree.parent = parent;
+    const result = await evaluate.call(tree, code);
     assert.equal(result, "Hello");
   });
 
@@ -22,25 +24,25 @@ describe("evaluate", () => {
       [ops.scope, "name"],
     ];
 
-    const scope = new ObjectTree({
+    const tree = new ObjectTree({
       async greet(name) {
         return `Hello ${name}`;
       },
       name: "world",
     });
 
-    const result = await evaluate.call(scope, code);
+    const result = await evaluate.call(tree, code);
     assert.equal(result, "Hello world");
   });
 
   test("passes context to invoked functions", async () => {
     const code = [ops.scope, "fn"];
-    const scope = {
+    const tree = new ObjectTree({
       async fn() {
-        assert.equal(this, scope);
+        assert.equal(this, tree);
       },
-    };
-    await evaluate.call(scope, code);
+    });
+    await evaluate.call(tree, code);
   });
 
   test("evaluates a function with fixed number of arguments", async () => {
@@ -59,4 +61,12 @@ describe("evaluate", () => {
     const result = await evaluate.call(null, code);
     assert.equal(result, "a,b,c");
   });
+
+  test("by defalut sets the parent of a returned tree to the current tree", async () => {
+    const fn = () => new ObjectTree({});
+    const code = [fn];
+    const tree = new ObjectTree({});
+    const result = await evaluate.call(tree, code);
+    assert.equal(result.parent, tree);
+  });
 });

package/test/runtime/functionResultsMap.test.js

@@ -1,23 +1,20 @@
-import { Tree } from "@weborigami/async-tree";
+import { ObjectTree, Tree, scope } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import Scope from "../../src/runtime/Scope.js";
 import functionResultsMap from "../../src/runtime/functionResultsMap.js";
 
 describe("functionResultsMap", () => {
   test("get() invokes functions using scope, returns other values as is", async () => {
-    const scope = {
+    const parent = new ObjectTree({
       message: "Hello",
-    };
-    const tree = Scope.treeWithScope(
-      {
-        fn: /** @this {import("@weborigami/types").AsyncTree} */ function () {
-          return this.get("message");
-        },
-        string: "string",
+    });
+    const tree = new ObjectTree({
+      fn: /** @this {import("@weborigami/types").AsyncTree} */ function () {
+        return scope(this).get("message");
       },
-      scope
-    );
+      string: "string",
+    });
+    tree.parent = parent;
     const fixture = functionResultsMap(tree);
     assert.deepEqual(await Tree.plain(fixture), {
       fn: "Hello",

package/test/runtime/mergeTrees.test.js

@@ -1,11 +1,6 @@
 import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import {
-  ExpressionTree,
-  expressionFunction,
-  ops,
-} from "../../src/runtime/internal.js";
 import mergeTrees from "../../src/runtime/mergeTrees.js";
 
 describe("mergeTrees", () => {
@@ -29,27 +24,6 @@ describe("mergeTrees", () => {
     });
   });
 
-  test("puts all trees in scope", async () => {
-    const tree = await mergeTrees.call(
-      null,
-      new ExpressionTree({
-        a: 1,
-        b: expressionFunction.createExpressionFunction([ops.scope, "c"]),
-      }),
-      new ExpressionTree({
-        c: 2,
-        d: expressionFunction.createExpressionFunction([ops.scope, "a"]),
-      })
-    );
-    // @ts-ignore
-    assert.deepEqual(await Tree.plain(tree), {
-      a: 1,
-      b: 2,
-      c: 2,
-      d: 1,
-    });
-  });
-
   test("if all arguments are plain objects, result is a plain object", async () => {
     const result = await mergeTrees.call(
       null,