@weborigami/language 0.2.6 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -12,8 +12,8 @@
     "yaml": "2.6.1"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.6",
-    "@weborigami/types": "0.2.6",
+    "@weborigami/async-tree": "0.2.7",
+    "@weborigami/types": "0.2.7",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/parserHelpers.js

@@ -235,12 +235,17 @@ export function makeObject(entries, op) {
 
   for (let [key, value] of entries) {
     if (key === ops.spread) {
-      // Spread entry; accumulate
-      if (currentEntries.length > 0) {
-        spreads.push([op, ...currentEntries]);
-        currentEntries = [];
+      if (value[0] === ops.object) {
+        // Spread of an object; fold into current object
+        currentEntries.push(...value.slice(1));
+      } else {
+        // Spread of a tree; accumulate
+        if (currentEntries.length > 0) {
+          spreads.push([op, ...currentEntries]);
+          currentEntries = [];
+        }
+        spreads.push(value);
       }
-      spreads.push(value);
       continue;
     }
 
@@ -253,15 +258,6 @@ export function makeObject(entries, op) {
         // Optimize a getter for a primitive value to a regular property
         value = value[1];
       }
-      // else if (
-      //   value[0] === ops.object ||
-      //   (value[0] === ops.getter &&
-      //     value[1] instanceof Array &&
-      //     (value[1][0] === ops.object || value[1][0] === ops.merge))
-      // ) {
-      //   // Add a trailing slash to key to indicate value is a subtree
-      //   key = trailingSlash.add(key);
-      // }
     }
 
     currentEntries.push([key, value]);

package/src/runtime/evaluate.js

@@ -20,7 +20,13 @@ export default async function evaluate(code) {
   }
 
   let evaluated;
-  const unevaluatedFns = [ops.external, ops.lambda, ops.object, ops.literal];
+  const unevaluatedFns = [
+    ops.external,
+    ops.lambda,
+    ops.merge,
+    ops.object,
+    ops.literal,
+  ];
   if (unevaluatedFns.includes(code[0])) {
     // Don't evaluate instructions, use as is.
     evaluated = code;

package/src/runtime/expressionObject.js

@@ -34,11 +34,13 @@ export default async function expressionObject(entries, parent) {
 
   let tree;
   const eagerProperties = [];
+  const propertyIsEnumerable = {};
   for (let [key, value] of entries) {
     // Determine if we need to define a getter or a regular property. If the key
     // has an extension, we need to define a getter. If the value is code (an
     // array), we need to define a getter -- but if that code takes the form
-    // [ops.getter, <primitive>], we can define a regular property.
+    // [ops.getter, <primitive>] or [ops.literal, <value>], we can define a
+    // regular property.
     let defineProperty;
     const extname = extension.extname(key);
     if (extname) {
@@ -48,6 +50,9 @@ export default async function expressionObject(entries, parent) {
     } else if (value[0] === ops.getter && !(value[1] instanceof Array)) {
       defineProperty = true;
       value = value[1];
+    } else if (value[0] === ops.literal) {
+      defineProperty = true;
+      value = value[1];
     } else {
       defineProperty = false;
     }
@@ -58,6 +63,7 @@ export default async function expressionObject(entries, parent) {
       key = key.slice(1, -1);
       enumerable = false;
     }
+    propertyIsEnumerable[key] = enumerable;
 
     if (defineProperty) {
       // Define simple property
@@ -105,7 +111,7 @@ export default async function expressionObject(entries, parent) {
   Object.defineProperty(object, symbols.keys, {
     configurable: true,
     enumerable: false,
-    value: () => keys(object, eagerProperties, entries),
+    value: () => keys(object, eagerProperties, propertyIsEnumerable, entries),
     writable: true,
   });
 
@@ -158,6 +164,8 @@ function entryKey(object, eagerProperties, entry) {
   return trailingSlash.toggle(key, entryCreatesSubtree);
 }
 
-function keys(object, eagerProperties, entries) {
-  return entries.map((entry) => entryKey(object, eagerProperties, entry));
+function keys(object, eagerProperties, propertyIsEnumerable, entries) {
+  return entries
+    .filter(([key]) => propertyIsEnumerable[key])
+    .map((entry) => entryKey(object, eagerProperties, entry));
 }

package/src/runtime/mergeTrees.js

@@ -2,6 +2,7 @@ import {
   isPlainObject,
   isUnpackable,
   merge,
+  setParent,
   Tree,
 } from "@weborigami/async-tree";
 
@@ -59,5 +60,6 @@ export default async function mergeTrees(...trees) {
 
   // Merge the trees.
   const result = merge(...unpacked);
+  setParent(result, this);
   return result;
 }

package/src/runtime/ops.js

@@ -33,6 +33,17 @@ export function addition(a, b) {
 }
 addOpLabel(addition, "«ops.addition»");
 
+/**
+ * Construct an array.
+ *
+ * @this {AsyncTree|null}
+ * @param {any[]} items
+ */
+export async function array(...items) {
+  return items;
+}
+addOpLabel(array, "«ops.array»");
+
 export function bitwiseAnd(a, b) {
   return a & b;
 }
@@ -53,17 +64,6 @@ export function bitwiseXor(a, b) {
 }
 addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 
-/**
- * Construct an array.
- *
- * @this {AsyncTree|null}
- * @param {any[]} items
- */
-export async function array(...items) {
-  return items;
-}
-addOpLabel(array, "«ops.array»");
-
 /**
  * Like ops.scope, but only searches for a builtin at the top of the scope
  * chain.
@@ -328,9 +328,41 @@ export async function logicalOr(head, ...tail) {
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
  * @this {AsyncTree|null}
- * @param {import("@weborigami/async-tree").Treelike[]} trees
+ * @param {Code[]} codes
  */
-export async function merge(...trees) {
+export async function merge(...codes) {
+  // First pass: evaluate the direct property entries in a single object
+  let treeSpreads = false;
+  const directEntries = [];
+  for (const code of codes) {
+    if (code[0] === object) {
+      directEntries.push(...code.slice(1));
+    } else {
+      treeSpreads = true;
+    }
+  }
+
+  const directObject = directEntries
+    ? await expressionObject(directEntries, this)
+    : null;
+  if (!treeSpreads) {
+    // No tree spreads, we're done
+    return directObject;
+  }
+
+  // Second pass: evaluate the trees with the direct properties object in scope
+  let context;
+  if (directObject) {
+    context = Tree.from(directObject);
+    context.parent = this;
+  } else {
+    context = this;
+  }
+
+  const trees = await Promise.all(
+    codes.map(async (code) => evaluate.call(context, code))
+  );
+
   return mergeTrees.call(this, ...trees);
 }
 addOpLabel(merge, "«ops.merge»");
@@ -438,7 +470,7 @@ addOpLabel(shiftRightUnsigned, "«ops.shiftRightUnsigned»");
  * The spread operator is a placeholder during parsing. It should be replaced
  * with an object merge.
  */
-export function spread(...args) {
+export function spread(arg) {
   throw new Error(
     "Internal error: a spread operation wasn't compiled correctly."
   );

package/src/runtime/typos.js

@@ -15,6 +15,12 @@ export function isTypo(s1, s2) {
     return false;
   }
 
+  // If strings are both a single character, we don't want to consider them
+  // typos.
+  if (length1 === 1 && length2 === 1) {
+    return false;
+  }
+
   // If length difference is more than 1, distance can't be 1
   if (Math.abs(length1 - length2) > 1) {
     return false;

package/test/compiler/parse.test.js

@@ -701,6 +701,11 @@ describe("Origami parser", () => {
       [ops.object, ["a", [ops.literal, 1]]],
       [ops.scope, "b"],
     ]);
+    assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
+      ops.object,
+      ["a", [ops.literal, 1]],
+      ["b", [ops.literal, 2]],
+    ]);
     assertParse("objectLiteral", "{ (a): 1 }", [
       ops.object,
       ["(a)", [ops.literal, 1]],

package/test/runtime/ops.test.js

@@ -220,6 +220,45 @@ describe("ops", () => {
     assert.strictEqual(await ops.logicalOr(true, errorFn), true);
   });
 
+  test("ops.merge", async () => {
+    // {
+    //   a: 1
+    //   …fn(a)
+    // }
+    const scope = new ObjectTree({
+      fn: (a) => ({ b: 2 * a }),
+    });
+    const code = createCode([
+      ops.merge,
+      [ops.object, ["a", [ops.literal, 1]]],
+      [
+        [ops.builtin, "fn"],
+        [ops.scope, "a"],
+      ],
+    ]);
+    const result = await evaluate.call(scope, code);
+    assert.deepEqual(result, { a: 1, b: 2 });
+  });
+
+  test("ops.merge lets all direct properties see each other", async () => {
+    // {
+    //   a: 1
+    //   ...more
+    //   c: a
+    // }
+    const scope = new ObjectTree({
+      more: { b: 2 },
+    });
+    const code = createCode([
+      ops.merge,
+      [ops.object, ["a", [ops.literal, 1]]],
+      [ops.scope, "more"],
+      [ops.object, ["c", [ops.scope, "a"]]],
+    ]);
+    const result = await evaluate.call(scope, code);
+    assert.deepEqual(result, { a: 1, b: 2, c: 1 });
+  });
+
   test("ops.multiplication multiplies two numbers", async () => {
     assert.strictEqual(ops.multiplication(3, 4), 12);
     assert.strictEqual(ops.multiplication(-3, 4), -12);

package/test/runtime/typos.test.js

@@ -12,6 +12,7 @@ describe("typos", () => {
     assert(isTypo("cat", "cta")); // transposition
     assert(isTypo("cat", "act")); // transposition
     assert(!isTypo("cat", "dog")); // more than 1 edit
+    assert(!isTypo("a", "b")); // single character
   });
 
   test("typos", () => {