@weborigami/language 0.3.0 → 0.3.2

package/src/compiler/parserHelpers.js

@@ -364,6 +364,15 @@ export function makeProperty(key, value) {
   return [key, modified];
 }
 
+export function makeJsPropertyAccess(expression, property) {
+  const location = {
+    source: expression.location.source,
+    start: expression.location.start,
+    end: property.location.end,
+  };
+  return annotate([expression, property], location);
+}
+
 export function makeReference(identifier) {
   // We can't know for sure that an identifier is a builtin reference until we
   // see whether it's being called as a function.

package/src/runtime/expressionObject.js

@@ -1,6 +1,7 @@
 import {
   extension,
   ObjectTree,
+  setParent,
   symbols,
   trailingSlash,
   Tree,
@@ -116,12 +117,7 @@ export default async function expressionObject(entries, parent) {
   });
 
   // Attach the parent
-  Object.defineProperty(object, symbols.parent, {
-    configurable: true,
-    enumerable: false,
-    value: parent,
-    writable: true,
-  });
+  setParent(object, parent);
 
   // Evaluate any properties that were declared as immediate: get their value
   // and overwrite the property getter with the actual value.

package/src/runtime/handlers.js

@@ -5,7 +5,7 @@ import {
   isStringLike,
   isUnpackable,
   scope,
-  symbols,
+  setParent,
   trailingSlash,
 } from "@weborigami/async-tree";
 
@@ -92,7 +92,7 @@ export async function handleExtension(parent, value, key) {
         if (handler.mediaType) {
           value.mediaType = handler.mediaType;
         }
-        value[symbols.parent] = parent;
+        setParent(value, parent);
 
         const unpack = handler.unpack;
         if (unpack) {

package/src/runtime/ops.js

@@ -8,10 +8,10 @@
 import {
   ObjectTree,
   Tree,
-  concatTrees,
+  deepText,
   isUnpackable,
   scope as scopeFn,
-  symbols,
+  setParent,
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
@@ -131,7 +131,7 @@ export async function document(frontData, bodyCode) {
     ...frontData,
     "@text": body,
   };
-  object[symbols.parent] = this;
+  setParent(object, this);
   return object;
 }
 addOpLabel(document, "«ops.document");
@@ -224,7 +224,8 @@ export async function inherited(key) {
     return undefined;
   }
   const parentScope = scopeFn(this.parent);
-  return parentScope.get(key);
+  const value = await parentScope.get(key);
+  return value;
 }
 addOpLabel(inherited, "«ops.inherited»");
 
@@ -388,17 +389,33 @@ export async function merge(...codes) {
     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;
-  }
-
+  // If we have direct property entries, create a context for them. The
+  // `expressionObject` function will set the object's parent symbol to `this`.
+  // Tree.from will call the ObjectTree constructor, which will use that symbol
+  // to set the parent for the new tree to `this`.
+  const context = directObject ? Tree.from(directObject) : this;
+
+  // Second pass: evaluate the trees. For the trees which are direct property
+  // entries, we'll copy over the values we've already calculated. We can't
+  // reuse the `directObject` as is because in a merge we need to respect the
+  // order in which the properties are defined. Trees that aren't direct
+  // property entries are evaluated with the direct property entries in scope.
   const trees = await Promise.all(
-    codes.map(async (code) => evaluate.call(context, code))
+    codes.map(async (code) => {
+      if (code[0] === object) {
+        // Using the code as reference, create a new object with the direct
+        // property values we've already calculated.
+        const object = {};
+        for (const [key] of code.slice(1)) {
+          // @ts-ignore directObject will always be defined
+          object[key] = directObject[key];
+        }
+        setParent(object, this);
+        return object;
+      } else {
+        return evaluate.call(context, code);
+      }
+    })
   );
 
   return mergeTrees.call(this, ...trees);
@@ -533,7 +550,7 @@ addOpLabel(subtraction, "«ops.subtraction»");
  * Apply the default tagged template function.
  */
 export async function template(strings, ...values) {
-  return concatTrees(strings, ...values);
+  return deepText(strings, ...values);
 }
 addOpLabel(template, "«ops.template»");
 

package/test/compiler/parse.test.js

@@ -236,6 +236,24 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("callExpression using property acccess", () => {
+    assertParse("callExpression", "(foo).bar", [
+      ops.traverse,
+      [ops.scope, "foo"],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("callExpression", "(foo).bar.baz", [
+      ops.traverse,
+      [ops.traverse, [ops.scope, "foo"], [ops.literal, "bar"]],
+      [ops.literal, "baz"],
+    ]);
+    assertParse("callExpression", "foo[bar]", [
+      ops.traverse,
+      [ops.scope, "foo/"],
+      [ops.scope, "bar"],
+    ]);
+  });
+
   test("commaExpression", () => {
     assertParse("commaExpression", "1", [ops.literal, 1]);
     assertParse("commaExpression", "a, b, c", [
@@ -567,6 +585,26 @@ Body`,
     ]);
   });
 
+  test("jsIdentifier", () => {
+    assertParse("jsIdentifier", "foo", "foo", false);
+    assertParse("jsIdentifier", "$Δelta", "$Δelta", false);
+    assertThrows(
+      "jsIdentifier",
+      "1stCharacterIsNumber",
+      "Expected JavaScript identifier start"
+    );
+    assertThrows(
+      "jsIdentifier",
+      "has space",
+      "Expected JavaScript identifier continuation"
+    );
+    assertThrows(
+      "jsIdentifier",
+      "foo.bar",
+      "Expected JavaScript identifier continuation"
+    );
+  });
+
   test("list", () => {
     assertParse("list", "1", [[ops.literal, 1]]);
     assertParse("list", "1,2,3", [