@weborigami/language 0.0.50 → 0.0.52

package/src/compiler/parserHelpers.js

@@ -17,6 +17,38 @@ export function makeFunctionCall(target, chain) {
   return value;
 }
 
+export function makeObject(entries, op) {
+  let currentEntries = [];
+  const spreads = [];
+
+  for (const [key, value] of entries) {
+    if (key === ops.spread) {
+      if (currentEntries.length > 0) {
+        spreads.push([op, ...currentEntries]);
+        currentEntries = [];
+      }
+      spreads.push(value);
+    } else {
+      currentEntries.push([key, value]);
+    }
+  }
+
+  // Finish any current entries.
+  if (currentEntries.length > 0) {
+    spreads.push([op, ...currentEntries]);
+    currentEntries = [];
+  }
+
+  if (spreads.length > 1) {
+    return [ops.merge, ...spreads];
+  }
+  if (spreads.length === 1) {
+    return spreads[0];
+  } else {
+    return [op];
+  }
+}
+
 // Similar to a function call, but the order is reversed.
 export function makePipeline(steps) {
   const [first, ...rest] = steps;

package/src/runtime/mergeTrees.js

@@ -0,0 +1,73 @@
+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.
+ *
+ * @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) {
+  // Filter out null or undefined trees.
+  /** @type {Treelike[]}
+   * @ts-ignore */
+  const filtered = trees.filter((tree) => tree);
+
+  if (filtered.length === 1) {
+    // Only one tree, no need to merge.
+    return filtered[0];
+  }
+
+  // Unpack any packed objects.
+  const unpacked = await Promise.all(
+    filtered.map((obj) =>
+      isUnpackable(obj) ? /** @type {any} */ (obj).unpack() : obj
+    )
+  );
+
+  // If all trees are plain objects, return a plain object.
+  if (unpacked.every((tree) => isPlainObject(tree))) {
+    return mergeObjects(...unpacked);
+  }
+
+  // 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);
+
+  return result;
+}
+
+/**
+ * Merge the indicated plain objects. If a key is present in multiple objects,
+ * the value from the first object is used.
+ *
+ * This is similar to calling Object.assign() with the objects in reverse order,
+ * but we want to ensure the keys end up in the same order they're encountered
+ * in the objects.
+ *
+ * @param  {...any} objects
+ */
+function mergeObjects(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    for (const key of Object.keys(obj)) {
+      result[key] ??= obj[key];
+    }
+  }
+  return result;
+}

package/src/runtime/ops.js

@@ -10,6 +10,7 @@ import Scope from "./Scope.js";
 import concatTreeValues from "./concatTreeValues.js";
 import handleExtension from "./handleExtension.js";
 import { OrigamiTree, evaluate, expressionFunction } from "./internal.js";
+import mergeTrees from "./mergeTrees.js";
 
 // For memoizing lambda functions
 const lambdaFnMap = new Map();
@@ -209,6 +210,17 @@ export function lambda(parameters, code) {
 }
 lambda.toString = () => "«ops.lambda»";
 
+/**
+ * Merge the given trees. If they are all plain objects, return a plain object.
+ *
+ * @this {AsyncTree|null}
+ * @param {import("@weborigami/async-tree").Treelike[]} trees
+ */
+export async function merge(...trees) {
+  return mergeTrees.call(this, ...trees);
+}
+merge.toString = () => "«ops.merge»";
+
 /**
  * Construct an object. The keys will be the same as the given `obj`
  * parameter's, and the values will be the results of evaluating the
@@ -228,6 +240,17 @@ export async function object(...entries) {
 }
 object.toString = () => "«ops.object»";
 
+/**
+ * The spread operator is a placeholder during parsing. It should be replaced
+ * with an object merge.
+ */
+export function spread(...args) {
+  throw new Error(
+    "A compile-time spread operator wasn't converted to an object merge."
+  );
+}
+spread.toString = () => "«ops.spread»";
+
 /**
  * Traverse a path of keys through a tree.
  */

package/test/compiler/parse.test.js

@@ -19,23 +19,20 @@ describe("Origami parser", () => {
     assertParse("array", "[ 1 , 2 , 3 ]", [ops.array, 1, 2, 3]);
   });
 
-  test("assignment", () => {
-    assertParse("assignment", "data = obj.json", [
+  test("treeAssignment", () => {
+    assertParse("treeAssignment", "data = obj.json", [
       "data",
       [ops.scope, "obj.json"],
     ]);
-    assertParse("assignment", "foo = fn 'bar'", [
+    assertParse("treeAssignment", "foo = fn 'bar'", [
       "foo",
       [[ops.scope, "fn"], "bar"],
     ]);
   });
 
-  test("assignmentOrShorthand", () => {
-    assertParse("assignmentOrShorthand", "foo", [
-      "foo",
-      [ops.inherited, "foo"],
-    ]);
-    assertParse("assignmentOrShorthand", "foo = 1", ["foo", 1]);
+  test("treeEntry", () => {
+    assertParse("treeEntry", "foo", ["foo", [ops.inherited, "foo"]]);
+    assertParse("treeEntry", "foo = 1", ["foo", 1]);
   });
 
   test("expr", () => {
@@ -297,6 +294,11 @@ describe("Origami parser", () => {
       ["a", 1],
       ["b", [ops.scope, "b"]],
     ]);
+    assertParse("object", "{ a: 1, ...b }", [
+      ops.merge,
+      [ops.object, ["a", 1]],
+      [ops.scope, "b"],
+    ]);
   });
 
   test("objectProperty", () => {
@@ -308,12 +310,9 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("objectPropertyOrShorthand", () => {
-    assertParse("objectPropertyOrShorthand", "foo", [
-      "foo",
-      [ops.scope, "foo"],
-    ]);
-    assertParse("objectPropertyOrShorthand", "x: y", ["x", [ops.scope, "y"]]);
+  test("objectEntry", () => {
+    assertParse("objectEntry", "foo", ["foo", [ops.scope, "foo"]]);
+    assertParse("objectEntry", "x: y", ["x", [ops.scope, "y"]]);
   });
 
   test("parameterizedLambda", () => {
@@ -410,6 +409,11 @@ describe("Origami parser", () => {
     assertParse("scopeReference", "x", [ops.scope, "x"]);
   });
 
+  test("spread", () => {
+    assertParse("spread", "...a", [ops.spread, [ops.scope, "a"]]);
+    assertParse("spread", "…a", [ops.spread, [ops.scope, "a"]]);
+  });
+
   test("string", () => {
     assertParse("string", '"foo"', "foo");
     assertParse("string", "'bar'", "bar");
@@ -485,6 +489,11 @@ describe("Origami parser", () => {
       ops.tree,
       ["x", [[ops.scope, "fn"], "a"]],
     ]);
+    assertParse("tree", "{ a = 1, ...b }", [
+      ops.merge,
+      [ops.tree, ["a", 1]],
+      [ops.scope, "b"],
+    ]);
   });
 
   test("whitespace block", () => {

package/test/runtime/mergeTrees.test.js

@@ -0,0 +1,69 @@
+import { Tree } from "@weborigami/async-tree";
+import { ExpressionTree, expressionFunction, ops } from "@weborigami/language";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import mergeTrees from "../../src/runtime/mergeTrees.js";
+
+describe("mergeTrees", () => {
+  test("merges trees", async () => {
+    const tree = await mergeTrees.call(
+      null,
+      {
+        a: 1,
+        b: 2,
+      },
+      {
+        c: 3,
+        d: 4,
+      }
+    );
+    // @ts-ignore
+    assert.deepEqual(await Tree.plain(tree), {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+    });
+  });
+
+  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,
+      {
+        a: 1,
+        b: 2,
+      },
+      {
+        c: 3,
+        d: 4,
+      }
+    );
+    assert.deepEqual(result, {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+    });
+  });
+});