@weborigami/language 0.6.2 → 0.6.4

package/test/compiler/parse.test.js

@@ -187,7 +187,112 @@ describe("Origami parser", () => {
   });
 
   describe("callExpression", () => {
-    test("with parentheses arguments", () => {
+    test("call chains", () => {
+      assertParse("callExpression", "(foo.js())('arg')", [
+        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
+        [ops.literal, "arg"],
+      ]);
+      assertParse("callExpression", "fn('a')('b')", [
+        [
+          [markers.traverse, [markers.reference, "fn"]],
+          [ops.literal, "a"],
+        ],
+        [ops.literal, "b"],
+      ]);
+      assertParse("callExpression", "(foo.js())(a, b)", [
+        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
+      ]);
+      assertParse("callExpression", "fn (x) (y) (z)", [
+        [
+          [
+            [markers.traverse, [markers.reference, "fn"]],
+            [markers.traverse, [markers.reference, "x"]],
+          ],
+          [markers.traverse, [markers.reference, "y"]],
+        ],
+        [markers.traverse, [markers.reference, "z"]],
+      ]);
+    });
+
+    test("optional property access", () => {
+      assertParse("callExpression", "a?.b.c", [
+        ops.optional,
+        [markers.traverse, [markers.reference, "a"]],
+        [
+          ops.lambda,
+          [[ops.literal, "__optional__"]],
+          [
+            ops.property,
+            [
+              ops.property,
+              [markers.traverse, [markers.reference, "__optional__"]],
+              [ops.literal, "b"],
+            ],
+            [ops.literal, "c"],
+          ],
+        ],
+      ]);
+      assertParse("callExpression", "a?.b?.c", [
+        ops.optional,
+        [markers.traverse, [markers.reference, "a"]],
+        [
+          ops.lambda,
+          [[ops.literal, "__optional__"]],
+          [
+            ops.optional,
+            [
+              ops.property,
+              [markers.traverse, [markers.reference, "__optional__"]],
+              [ops.literal, "b"],
+            ],
+            [
+              ops.lambda,
+              [[ops.literal, "__optional__"]],
+              [
+                ops.property,
+                [markers.traverse, [markers.reference, "__optional__"]],
+                [ops.literal, "c"],
+              ],
+            ],
+          ],
+        ],
+      ]);
+    });
+
+    test("optional computed property access", () => {
+      assertParse("callExpression", "a?.[key]", [
+        ops.optional,
+        [markers.traverse, [markers.reference, "a"]],
+        [
+          ops.lambda,
+          [[ops.literal, "__optional__"]],
+          [
+            ops.property,
+            [markers.traverse, [markers.reference, "__optional__"]],
+            [markers.traverse, [markers.reference, "key"]],
+          ],
+        ],
+      ]);
+    });
+
+    test("optional parentheses call", () => {
+      assertParse("callExpression", "fn?.(0)", [
+        ops.optional,
+        [markers.traverse, [markers.reference, "fn"]],
+        [
+          ops.lambda,
+          [[ops.literal, "__optional__"]],
+          [
+            [markers.traverse, [markers.reference, "__optional__"]],
+            [ops.literal, 0],
+          ],
+        ],
+      ]);
+    });
+
+    test("parentheses arguments", () => {
       assertParse("callExpression", "fn()", [
         [markers.traverse, [markers.reference, "fn"]],
         undefined,
@@ -212,26 +317,20 @@ describe("Origami parser", () => {
       ]);
     });
 
-    test("call chains", () => {
-      assertParse("callExpression", "(foo.js())('arg')", [
-        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
-        [ops.literal, "arg"],
-      ]);
-      assertParse("callExpression", "fn('a')('b')", [
+    test("parentheses arguments with spreads", () => {
+      assertParse("callExpression", "fn(a, ...b, ...c)", [
+        [ops.property, [markers.traverse, [markers.reference, "fn"]], "apply"],
+        null,
         [
-          [markers.traverse, [markers.reference, "fn"]],
-          [ops.literal, "a"],
+          ops.flat,
+          [ops.array, [markers.traverse, [markers.reference, "a"]]],
+          [markers.traverse, [markers.reference, "b"]],
+          [markers.traverse, [markers.reference, "c"]],
         ],
-        [ops.literal, "b"],
-      ]);
-      assertParse("callExpression", "(foo.js())(a, b)", [
-        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
-        [markers.traverse, [markers.reference, "a"]],
-        [markers.traverse, [markers.reference, "b"]],
       ]);
     });
 
-    test("with paths", () => {
+    test("paths", () => {
       assertParse("callExpression", "tree/", [
         markers.traverse,
         [markers.reference, "tree/"],
@@ -292,17 +391,6 @@ describe("Origami parser", () => {
       ]);
     });
 
-    test("tagged templates", () => {
-      assertParse("callExpression", "indent`hello`", [
-        [markers.traverse, [markers.reference, "indent"]],
-        [ops.literal, ["hello"]],
-      ]);
-      assertParse("callExpression", "fn.js`Hello, world.`", [
-        [markers.traverse, [markers.reference, "fn.js"]],
-        [ops.literal, ["Hello, world."]],
-      ]);
-    });
-
     test("protocols", () => {
       assertParse("callExpression", "files:src/assets", [
         [markers.global, "files:"],
@@ -318,6 +406,17 @@ describe("Origami parser", () => {
         [ops.literal, "env"],
       ]);
     });
+
+    test("tagged templates", () => {
+      assertParse("callExpression", "indent`hello`", [
+        [markers.traverse, [markers.reference, "indent"]],
+        [ops.literal, ["hello"]],
+      ]);
+      assertParse("callExpression", "fn.js`Hello, world.`", [
+        [markers.traverse, [markers.reference, "fn.js"]],
+        [ops.literal, ["Hello, world."]],
+      ]);
+    });
   });
 
   test("commaExpression", () => {
@@ -768,6 +867,24 @@ Body`,
         [ops.literal, "arg"],
       ],
     ]);
+    assertParse(
+      "implicitParenthesesCallExpression",
+      "concat a.json, ...b.json, c.json",
+      [
+        [
+          ops.property,
+          [markers.traverse, [markers.reference, "concat"]],
+          "apply",
+        ],
+        null,
+        [
+          ops.flat,
+          [ops.array, [markers.traverse, [markers.reference, "a.json"]]],
+          [markers.traverse, [markers.reference, "b.json"]],
+          [ops.array, [markers.traverse, [markers.reference, "c.json"]]],
+        ],
+      ]
+    );
   });
 
   test("key", () => {
@@ -782,35 +899,6 @@ Body`,
     assertParse("key", "package-lock.json", "package-lock.json");
   });
 
-  test("list", () => {
-    assertParse("list", "1", [[ops.literal, 1]]);
-    assertParse("list", "1,2,3", [
-      [ops.literal, 1],
-      [ops.literal, 2],
-      [ops.literal, 3],
-    ]);
-    assertParse("list", "1, 2, 3,", [
-      [ops.literal, 1],
-      [ops.literal, 2],
-      [ops.literal, 3],
-    ]);
-    assertParse("list", "1 , 2 , 3", [
-      [ops.literal, 1],
-      [ops.literal, 2],
-      [ops.literal, 3],
-    ]);
-    assertParse("list", "1\n2\n3", [
-      [ops.literal, 1],
-      [ops.literal, 2],
-      [ops.literal, 3],
-    ]);
-    assertParse("list", "'a' , 'b' , 'c'", [
-      [ops.literal, "a"],
-      [ops.literal, "b"],
-      [ops.literal, "c"],
-    ]);
-  });
-
   test("logicalAndExpression", () => {
     assertParse("logicalAndExpression", "true && false", [
       ops.logicalAnd,
@@ -898,7 +986,7 @@ Body`,
   });
 
   describe("objectLiteral", () => {
-    describe("basic objects", () => {
+    test("basic objects", () => {
       assertParse("objectLiteral", "{}", [ops.object]);
       assertParse("objectLiteral", "{ a: 1, b }", [
         ops.object,
@@ -991,7 +1079,7 @@ Body`,
       ]);
     });
 
-    describe("spreads", () => {
+    test("spreads", () => {
       assertParse("objectLiteral", "{ ...x }", [
         ops.unpack,
         [markers.traverse, [markers.reference, "x"]],
@@ -1019,6 +1107,16 @@ Body`,
         ["b", [ops.literal, 2]],
       ]);
     });
+
+    test("computed property keys", () => {
+      assertParse("objectLiteral", "{ [key]: value }", [
+        ops.object,
+        [
+          [markers.traverse, [markers.reference, "key"]],
+          [markers.traverse, [markers.reference, "value"]],
+        ],
+      ]);
+    });
   });
 
   describe("objectEntry", () => {
@@ -1122,12 +1220,17 @@ Body`,
     assertParse("objectPublicKey", `"foo bar"`, "foo bar", "shell", false);
   });
 
-  // test.skip("optionalChaining", () => {
-  //   assertParse("optionalChaining", "?.key", [
-  //     ops.optionalTraverse,
-  //     [ops.literal, "key"],
-  //   ]);
-  // });
+  test("optional", () => {
+    assertParse("optional", "?.key", [
+      ops.optional,
+      [markers.property, [ops.literal, "key"]],
+    ]);
+    assertParse("optional", "?.[index]", [
+      ops.optional,
+      [markers.property, [markers.traverse, [markers.reference, "index"]]],
+    ]);
+    assertParse("optional", "?.(0)", [ops.optional, [[ops.literal, 0]]]);
+  });
 
   test("parenthesesArguments", () => {
     assertParse("parenthesesArguments", "()", [undefined]);
@@ -1138,6 +1241,40 @@ Body`,
     ]);
   });
 
+  test("parenthesesArgumentList", () => {
+    assertParse("parenthesesArgumentList", "1", [[ops.literal, 1]]);
+    assertParse("parenthesesArgumentList", "1,2,3", [
+      [ops.literal, 1],
+      [ops.literal, 2],
+      [ops.literal, 3],
+    ]);
+    assertParse("parenthesesArgumentList", "1, 2, 3,", [
+      [ops.literal, 1],
+      [ops.literal, 2],
+      [ops.literal, 3],
+    ]);
+    assertParse("parenthesesArgumentList", "1 , 2 , 3", [
+      [ops.literal, 1],
+      [ops.literal, 2],
+      [ops.literal, 3],
+    ]);
+    assertParse("parenthesesArgumentList", "1\n2\n3", [
+      [ops.literal, 1],
+      [ops.literal, 2],
+      [ops.literal, 3],
+    ]);
+    assertParse("parenthesesArgumentList", "'a' , 'b' , 'c'", [
+      [ops.literal, "a"],
+      [ops.literal, "b"],
+      [ops.literal, "c"],
+    ]);
+    assertParse("parenthesesArgumentList", "a, ...b, c", [
+      [markers.traverse, [markers.reference, "a"]],
+      [markers.spread, [markers.traverse, [markers.reference, "b"]]],
+      [markers.traverse, [markers.reference, "c"]],
+    ]);
+  });
+
   test("pathKeys", () => {
     assertParse(
       "pathKeys",
@@ -1360,7 +1497,7 @@ Body`,
 
   test("spreadElement", () => {
     assertParse("spreadElement", "...a", [
-      ops.spread,
+      markers.spread,
       [markers.traverse, [markers.reference, "a"]],
     ]);
   });

package/test/runtime/expressionObject.test.js

@@ -52,6 +52,14 @@ describe("expressionObject", () => {
     assert.equal(object[symbols.parent], context);
   });
 
+  test("can compute a property key", async () => {
+    const entries = [[[ops.concat, "data", ".json"], 1]];
+    const context = new SyncMap();
+    const object = await expressionObject(entries, { object: context });
+    assert.equal(await object["data.json"], 1);
+    assert.deepEqual(object[symbols.keys](), ["data.json"]);
+  });
+
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
     const context = new SyncMap();
@@ -79,6 +87,8 @@ describe("expressionObject", () => {
       ["message", "Hello"],
       // Immediate maplike value, should have a slash
       ["object", [ops.object, ["b", [ops.literal, 2]]]],
+      // Computed key
+      [[ops.concat, [ops.array, "data", ".json"]], 1],
     ];
     const object = await expressionObject(entries);
     assert.deepEqual(object[symbols.keys](), [
@@ -86,6 +96,7 @@ describe("expressionObject", () => {
       "hasSlash/",
       "message",
       "object/",
+      "data.json",
     ]);
   });
 

package/test/runtime/ops.test.js

@@ -304,10 +304,20 @@ describe("ops", () => {
     assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  // test("ops.optionalTraverse", async () => {
-  //   assert.equal(await ops.optionalTraverse(null, "a"), undefined);
-  //   assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
-  // });
+  test("ops.optional", async () => {
+    assert.equal(
+      ops.optional(null, (x) => x.a),
+      undefined
+    );
+    assert.equal(
+      ops.optional(undefined, (x) => x.a),
+      undefined
+    );
+    assert.equal(
+      ops.optional({ a: 1 }, (x) => x.a),
+      1
+    );
+  });
 
   test("ops.notEqual", () => {
     assert(!ops.notEqual(1, 1));