@weborigami/language 0.0.59 → 0.0.61

package/test/runtime/ops.test.js

@@ -1,7 +1,6 @@
 import { ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import Scope from "../../src/runtime/Scope.js";
 
 import {
   OrigamiTree,
@@ -100,25 +99,27 @@ describe("ops", () => {
         ]),
       ],
     ];
-    const result = await evaluate.call({}, code);
+    const parent = new ObjectTree({});
+    const result = await evaluate.call(parent, code);
     assert(result instanceof OrigamiTree);
     assert.deepEqual(await Tree.plain(result), {
       name: "world",
       message: "Hello, world!",
     });
+    assert.equal(result.parent, parent);
   });
 
   test("can search inherited scope", async () => {
-    const a = new ObjectTree({
+    const parent = new ObjectTree({
       a: 1, // This is the inherited value we want
     });
     /** @type {any} */
-    const b = new ObjectTree({
+    const child = new ObjectTree({
       a: 2, // Should be ignored
     });
-    b.scope = new Scope(b, a);
+    child.parent = parent;
     const code = [ops.inherited, "a"];
-    const result = await evaluate.call(b.scope, code);
+    const result = await evaluate.call(child, code);
     assert.equal(result, 1);
   });
 

package/src/runtime/InheritScopeMixin.d.ts

@@ -1,9 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-import type { AsyncTree } from "@weborigami/types";
-
-declare const InheritScopeMixin: Mixin<{
-  scope: AsyncTree|null;
-}>;
-
-export default InheritScopeMixin;

package/src/runtime/InheritScopeMixin.js

@@ -1,34 +0,0 @@
-import Scope from "./Scope.js";
-
-const scopeKey = Symbol("scope");
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function InheritScopeMixin(Base) {
-  return class InheritScope extends Base {
-    constructor(...args) {
-      super(...args);
-      this[scopeKey] = null;
-    }
-
-    /** @type {import("@weborigami/types").AsyncTree} */
-    get scope() {
-      if (this[scopeKey] === null) {
-        if (this.parent) {
-          // Add parent to this tree's scope.
-          this[scopeKey] = new Scope(this, Scope.getScope(this.parent));
-        } else {
-          // Scope is just the tree itself.
-          this[scopeKey] = this;
-        }
-      }
-      return this[scopeKey];
-    }
-    set scope(scope) {
-      this[scopeKey] = scope;
-    }
-  };
-}

package/src/runtime/Scope.js

@@ -1,96 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @implements {AsyncTree}
- */
-export default class Scope {
-  constructor(...treelikes) {
-    const filtered = treelikes.filter((treelike) => treelike != undefined);
-    const trees = filtered.map((treelike) => Tree.from(treelike));
-
-    // If a tree argument has a `trees` property, use that instead.
-    const scopes = trees.flatMap(
-      (tree) => /** @type {any} */ (tree).trees ?? tree
-    );
-
-    this.trees = scopes;
-  }
-
-  async get(key) {
-    for (const tree of this.trees) {
-      const value = await tree.get(key);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return undefined;
-  }
-
-  /**
-   * If the given tree has a `scope` property, return that. If the tree has a
-   * `parent` property, construct a scope for the tree and its parent.
-   * Otherwise, return the tree itself.
-   *
-   * @param {AsyncTree|null|undefined} tree
-   * @returns {AsyncTree|null}
-   */
-  static getScope(tree) {
-    if (!tree) {
-      return null;
-    } else if (!Tree.isAsyncTree(tree)) {
-      throw new Error("Tried to get the scope of something that's not a tree.");
-    }
-
-    if ("scope" in tree) {
-      // Ask tree for its scope, use that if defined.
-      const scope = /** @type {any} */ (tree).scope;
-      if (scope) {
-        return scope;
-      }
-    }
-
-    // Default scope is tree plus its parent scope.
-    return new Scope(tree, this.getScope(tree.parent));
-  }
-
-  async keys() {
-    const keys = new Set();
-    for (const tree of this.trees) {
-      for (const key of await tree.keys()) {
-        keys.add(key);
-      }
-    }
-    return keys;
-  }
-
-  /**
-   * Return a new tree equivalent to the given tree, but with the given scope.
-   *
-   * The tree itself will be automatically included at the front of the scope.
-   *
-   * @typedef {import("@weborigami/async-tree").Treelike} Treelike
-   * @param {Treelike} treelike
-   * @param {Treelike|null} scope
-   * @returns {AsyncTree & { scope: AsyncTree }}
-   */
-  static treeWithScope(treelike, scope) {
-    // If the treelike was already a tree, create a copy of it.
-    const tree = Tree.isAsyncTree(treelike)
-      ? Object.create(treelike)
-      : Tree.from(treelike);
-    tree.scope = new Scope(tree, scope);
-    return tree;
-  }
-
-  async unwatch() {
-    for (const tree of this.trees) {
-      await /** @type {any} */ (tree).unwatch?.();
-    }
-  }
-  async watch() {
-    for (const tree of this.trees) {
-      await /** @type {any} */ (tree).watch?.();
-    }
-  }
-}

package/test/runtime/InheritScopeMixin.test.js

@@ -1,29 +0,0 @@
-import { DeepObjectTree, ObjectTree } from "@weborigami/async-tree";
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import InheritScopeMixin from "../../src/runtime/InheritScopeMixin.js";
-
-describe("InheritScopeMixin", () => {
-  test("creates a scope that includes a tree and its parent", async () => {
-    const fixture = new (InheritScopeMixin(ObjectTree))({
-      b: 2,
-    });
-    fixture.parent = new ObjectTree({
-      a: 1,
-    });
-    assert.deepEqual(await fixture.scope?.get("b"), 2);
-    assert.deepEqual(await fixture.scope?.get("a"), 1);
-  });
-
-  test("adds a subtree's parent to the subtrees's scope", async () => {
-    const fixture = new (InheritScopeMixin(DeepObjectTree))({
-      a: 1,
-      subtree: {
-        b: 2,
-      },
-    });
-    const subtree = await fixture.get("subtree");
-    assert.deepEqual(await subtree.scope.get("b"), 2);
-    assert.deepEqual(await subtree.scope.get("a"), 1);
-  });
-});

package/test/runtime/Scope.test.js

@@ -1,37 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import Scope from "../../src/runtime/Scope.js";
-
-describe("Scope", () => {
-  test("composes and flattens scopes and trees passed to it", async () => {
-    const treeA = {
-      a: 1,
-    };
-    const treeB = {
-      b: 2,
-    };
-    const treeC = {
-      c: 3,
-    };
-    const scope1 = new Scope(treeA, treeB);
-    const scope2 = new Scope(scope1, treeC);
-    const objects = scope2.trees.map(
-      (tree) => /** @type {any} */ (tree).object
-    );
-    assert.deepEqual(objects, [treeA, treeB, treeC]);
-  });
-
-  test("gets the first defined value from the scope trees", async () => {
-    const scope = new Scope(
-      {
-        a: 1,
-      },
-      {
-        a: 2,
-        b: 3,
-      }
-    );
-    assert.equal(await scope.get("a"), 1);
-    assert.equal(await scope.get("b"), 3);
-  });
-});

package/test/runtime/fixtures/programs/context.yaml

@@ -1,4 +0,0 @@
-title: Reference the special context key
-
-# This will pull in the value of "obj.yaml" from the result tree.
-obj = context 'obj.yaml':

package/test/runtime/fixtures/programs/files.yaml

@@ -1,2 +0,0 @@
-title: Files demonstration
-files = keys context():

package/test/runtime/fixtures/programs/obj.yaml

@@ -1,3 +0,0 @@
-a: Hello, a.
-b: Hello, b.
-c: Hello, c.

package/test/runtime/fixtures/programs/simple.yaml

@@ -1,2 +0,0 @@
-a = b: ""
-b: Hello, world.