@weborigami/language 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "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.3",
-    "@weborigami/types": "0.2.3",
+    "@weborigami/async-tree": "0.2.4",
+    "@weborigami/types": "0.2.4",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/origami.pegjs

@@ -31,12 +31,12 @@ import {
 
 // A block of optional whitespace
 __
-  = (inlineSpace / newLine / comment)*  {
+  = whitespace*  {
     return null;
   }
 
 additiveExpression
-  = head:multiplicativeExpression tail:(__ @additiveOperator __ @multiplicativeExpression)* {
+  = head:multiplicativeExpression tail:(whitespace @additiveOperator whitespace @multiplicativeExpression)* {
       return annotate(tail.reduce(makeBinaryOperation, head), location());
     }
 
@@ -148,8 +148,8 @@ comment "comment"
 
 conditionalExpression
   = condition:logicalOrExpression tail:(__
-    "?" __ @pipelineExpression __
-    ":" __ @pipelineExpression)?
+    "?" __ @shorthandFunction __
+    ":" __ @shorthandFunction)?
     {
       if (!tail) {
         return condition;
@@ -310,7 +310,7 @@ multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
 multiplicativeExpression
-  = head:exponentiationExpression tail:(__ @multiplicativeOperator __ @exponentiationExpression)* {
+  = head:exponentiationExpression tail:(whitespace @multiplicativeOperator whitespace @exponentiationExpression)* {
       return annotate(tail.reduce(makeBinaryOperation, head), location());
     }
 
@@ -625,5 +625,10 @@ unaryOperator
   / "-"
   / "~"
 
+whitespace
+  = inlineSpace
+  / newLine
+  / comment
+
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __

package/src/compiler/parse.js

@@ -202,7 +202,7 @@ function peg$parse(input, options) {
   var peg$FAILED = {};
   var peg$source = options.grammarSource;
 
-  var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, arguments: peg$parsearguments, arrayLiteral: peg$parsearrayLiteral, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, arrowFunction: peg$parsearrowFunction, bitwiseAndExpression: peg$parsebitwiseAndExpression, bitwiseAndOperator: peg$parsebitwiseAndOperator, bitwiseOrExpression: peg$parsebitwiseOrExpression, bitwiseOrOperator: peg$parsebitwiseOrOperator, bitwiseXorExpression: peg$parsebitwiseXorExpression, bitwiseXorOperator: peg$parsebitwiseXorOperator, callExpression: peg$parsecallExpression, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParenthesis: peg$parseclosingParenthesis, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, conditionalExpression: peg$parseconditionalExpression, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, equalityExpression: peg$parseequalityExpression, equalityOperator: peg$parseequalityOperator, escapedChar: peg$parseescapedChar, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, list: peg$parselist, literal: peg$parseliteral, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, namespace: peg$parsenamespace, newLine: peg$parsenewLine, numericLiteral: peg$parsenumericLiteral, nullishCoalescingExpression: peg$parsenullishCoalescingExpression, objectLiteral: peg$parseobjectLiteral, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectGetter: peg$parseobjectGetter, objectHiddenKey: peg$parseobjectHiddenKey, objectKey: peg$parseobjectKey, objectProperty: peg$parseobjectProperty, objectShorthandProperty: peg$parseobjectShorthandProperty, objectPublicKey: peg$parseobjectPublicKey, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, reference: peg$parsereference, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, slashFollows: peg$parseslashFollows, shebang: peg$parseshebang, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
+  var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, arguments: peg$parsearguments, arrayLiteral: peg$parsearrayLiteral, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, arrowFunction: peg$parsearrowFunction, bitwiseAndExpression: peg$parsebitwiseAndExpression, bitwiseAndOperator: peg$parsebitwiseAndOperator, bitwiseOrExpression: peg$parsebitwiseOrExpression, bitwiseOrOperator: peg$parsebitwiseOrOperator, bitwiseXorExpression: peg$parsebitwiseXorExpression, bitwiseXorOperator: peg$parsebitwiseXorOperator, callExpression: peg$parsecallExpression, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParenthesis: peg$parseclosingParenthesis, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, conditionalExpression: peg$parseconditionalExpression, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, equalityExpression: peg$parseequalityExpression, equalityOperator: peg$parseequalityOperator, escapedChar: peg$parseescapedChar, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, list: peg$parselist, literal: peg$parseliteral, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, namespace: peg$parsenamespace, newLine: peg$parsenewLine, numericLiteral: peg$parsenumericLiteral, nullishCoalescingExpression: peg$parsenullishCoalescingExpression, objectLiteral: peg$parseobjectLiteral, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectGetter: peg$parseobjectGetter, objectHiddenKey: peg$parseobjectHiddenKey, objectKey: peg$parseobjectKey, objectProperty: peg$parseobjectProperty, objectShorthandProperty: peg$parseobjectShorthandProperty, objectPublicKey: peg$parseobjectPublicKey, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, reference: peg$parsereference, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, slashFollows: peg$parseslashFollows, shebang: peg$parseshebang, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespace: peg$parsewhitespace, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
   var peg$startRuleFunction = peg$parse__;
 
   var peg$c0 = "[";
@@ -791,22 +791,10 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = [];
-    s2 = peg$parseinlineSpace();
-    if (s2 === peg$FAILED) {
-      s2 = peg$parsenewLine();
-      if (s2 === peg$FAILED) {
-        s2 = peg$parsecomment();
-      }
-    }
+    s2 = peg$parsewhitespace();
     while (s2 !== peg$FAILED) {
       s1.push(s2);
-      s2 = peg$parseinlineSpace();
-      if (s2 === peg$FAILED) {
-        s2 = peg$parsenewLine();
-        if (s2 === peg$FAILED) {
-          s2 = peg$parsecomment();
-        }
-      }
+      s2 = peg$parsewhitespace();
     }
     peg$savedPos = s0;
     s1 = peg$f0();
@@ -823,13 +811,23 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = peg$currPos;
-      s4 = peg$parse__();
-      s5 = peg$parseadditiveOperator();
-      if (s5 !== peg$FAILED) {
-        s6 = peg$parse__();
-        s7 = peg$parsemultiplicativeExpression();
-        if (s7 !== peg$FAILED) {
-          s3 = [ s5, s7 ];
+      s4 = peg$parsewhitespace();
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parseadditiveOperator();
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parsewhitespace();
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parsemultiplicativeExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = [ s5, s7 ];
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
         } else {
           peg$currPos = s3;
           s3 = peg$FAILED;
@@ -841,13 +839,23 @@ function peg$parse(input, options) {
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = peg$currPos;
-        s4 = peg$parse__();
-        s5 = peg$parseadditiveOperator();
-        if (s5 !== peg$FAILED) {
-          s6 = peg$parse__();
-          s7 = peg$parsemultiplicativeExpression();
-          if (s7 !== peg$FAILED) {
-            s3 = [ s5, s7 ];
+        s4 = peg$parsewhitespace();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parseadditiveOperator();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parsewhitespace();
+            if (s6 !== peg$FAILED) {
+              s7 = peg$parsemultiplicativeExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = [ s5, s7 ];
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -1565,7 +1573,7 @@ function peg$parse(input, options) {
       }
       if (s4 !== peg$FAILED) {
         s5 = peg$parse__();
-        s6 = peg$parsepipelineExpression();
+        s6 = peg$parseshorthandFunction();
         if (s6 !== peg$FAILED) {
           s7 = peg$parse__();
           if (input.charCodeAt(peg$currPos) === 58) {
@@ -1577,7 +1585,7 @@ function peg$parse(input, options) {
           }
           if (s8 !== peg$FAILED) {
             s9 = peg$parse__();
-            s10 = peg$parsepipelineExpression();
+            s10 = peg$parseshorthandFunction();
             if (s10 !== peg$FAILED) {
               s2 = [ s6, s10 ];
             } else {
@@ -2863,13 +2871,23 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = peg$currPos;
-      s4 = peg$parse__();
-      s5 = peg$parsemultiplicativeOperator();
-      if (s5 !== peg$FAILED) {
-        s6 = peg$parse__();
-        s7 = peg$parseexponentiationExpression();
-        if (s7 !== peg$FAILED) {
-          s3 = [ s5, s7 ];
+      s4 = peg$parsewhitespace();
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parsemultiplicativeOperator();
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parsewhitespace();
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parseexponentiationExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = [ s5, s7 ];
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
         } else {
           peg$currPos = s3;
           s3 = peg$FAILED;
@@ -2881,13 +2899,23 @@ function peg$parse(input, options) {
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = peg$currPos;
-        s4 = peg$parse__();
-        s5 = peg$parsemultiplicativeOperator();
-        if (s5 !== peg$FAILED) {
-          s6 = peg$parse__();
-          s7 = peg$parseexponentiationExpression();
-          if (s7 !== peg$FAILED) {
-            s3 = [ s5, s7 ];
+        s4 = peg$parsewhitespace();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parsemultiplicativeOperator();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parsewhitespace();
+            if (s6 !== peg$FAILED) {
+              s7 = peg$parseexponentiationExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = [ s5, s7 ];
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -4683,6 +4711,20 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parsewhitespace() {
+    var s0;
+
+    s0 = peg$parseinlineSpace();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsenewLine();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsecomment();
+      }
+    }
+
+    return s0;
+  }
+
   function peg$parsewhitespaceWithNewLine() {
     var s0, s1, s2, s3, s4;
 
@@ -4841,6 +4883,7 @@ const peg$allowedStartRules = [
   "textChar",
   "unaryExpression",
   "unaryOperator",
+  "whitespace",
   "whitespaceWithNewLine"
 ];
 

package/src/runtime/mergeTrees.js

@@ -1,4 +1,9 @@
-import { isPlainObject, isUnpackable, merge } from "@weborigami/async-tree";
+import {
+  isPlainObject,
+  isUnpackable,
+  merge,
+  Tree,
+} from "@weborigami/async-tree";
 
 /**
  * Create a tree that's the result of merging the given trees.
@@ -28,8 +33,23 @@ export default async function mergeTrees(...trees) {
   );
 
   // If all trees are plain objects, return a plain object.
-  if (unpacked.every((tree) => isPlainObject(tree))) {
-    return Object.assign({}, ...unpacked);
+  if (
+    unpacked.every((tree) => isPlainObject(tree) && !Tree.isAsyncTree(tree))
+  ) {
+    // If we do an Object.assign, we'd evaluate getters.
+    // To avoid that, we'll merge property descriptors.
+    const result = {};
+    for (const obj of unpacked) {
+      const descriptors = Object.getOwnPropertyDescriptors(obj);
+      for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (descriptor.value !== undefined) {
+          result[key] = descriptor.value;
+        } else {
+          Object.defineProperty(result, key, descriptor);
+        }
+      }
+    }
+    return result;
   }
 
   // If all trees are arrays, return an array.

package/test/compiler/parse.test.js

@@ -433,6 +433,18 @@ describe("Origami parser", () => {
         [ops.scope, "slug"],
       ],
     ]);
+    assertParse("expression", "keys ~", [
+      [ops.builtin, "keys"],
+      [ops.homeDirectory],
+    ]);
+    assertParse("expression", "keys /Users/alice", [
+      [ops.builtin, "keys"],
+      [
+        ops.traverse,
+        [ops.rootDirectory, [ops.literal, "Users/"]],
+        [ops.literal, "alice"],
+      ],
+    ]);
 
     // Verify parser treatment of identifiers containing operators
     assertParse("expression", "a + b", [

package/test/runtime/mergeTrees.test.js

@@ -1,50 +1,68 @@
-import { Tree } from "@weborigami/async-tree";
+import { ObjectTree, Tree } from "@weborigami/async-tree";
 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(
+  test("if all arguments are plain objects, result is a plain object", async () => {
+    let calledFoo = false;
+    let calledBar = false;
+    const result = await mergeTrees.call(
       null,
       {
         a: 1,
         b: 2,
+        get foo() {
+          calledFoo = true;
+          return true;
+        },
       },
       {
         b: 3,
         c: 4,
+        get bar() {
+          calledBar = true;
+          return true;
+        },
       }
     );
-    // @ts-ignore
-    assert.deepEqual(await Tree.plain(tree), {
+
+    // Shouldn't call functions when just getting keys
+    assert.deepEqual(Object.keys(result), ["a", "b", "foo", "c", "bar"]);
+    assert(!calledFoo);
+    assert(!calledBar);
+
+    assert.deepEqual(result, {
       a: 1,
       b: 3,
+      foo: true,
       c: 4,
+      bar: true,
     });
   });
 
-  test("if all arguments are plain objects, result is a plain object", async () => {
-    const result = await mergeTrees.call(
+  test("if all arguments are arrays, result is an array", async () => {
+    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
+    assert.deepEqual(result, [1, 2, 3, 4]);
+  });
+
+  test("merges heterogenous arguments as trees", async () => {
+    const tree = await mergeTrees.call(
       null,
-      {
+      new ObjectTree({
         a: 1,
         b: 2,
-      },
+      }),
       {
         b: 3,
         c: 4,
       }
     );
-    assert.deepEqual(result, {
+    // @ts-ignore
+    assert.deepEqual(await Tree.plain(tree), {
       a: 1,
       b: 3,
       c: 4,
     });
   });
-
-  test("if all arguments are arrays, result is an array", async () => {
-    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
-    assert.deepEqual(result, [1, 2, 3, 4]);
-  });
 });