@weborigami/language 0.0.66-beta.1 → 0.0.66-beta.2

package/test/compiler/parse.test.js

@@ -8,7 +8,7 @@ describe("Origami parser", () => {
   test("absoluteFilePath", () => {
     assertParse("absoluteFilePath", "/foo/bar", [
       [ops.filesRoot],
-      [ops.primitive, "foo"],
+      [ops.primitive, "foo/"],
       [ops.primitive, "bar"],
     ]);
   });
@@ -134,11 +134,10 @@ describe("Origami parser", () => {
       ]
     );
 
-    // Consecutive slahes inside a path = empty string key
+    // Consecutive slahes in a path are removed
     assertParse("expression", "path//key", [
       ops.traverse,
-      [ops.scope, "path"],
-      [ops.primitive, ""],
+      [ops.scope, "path/"],
       [ops.primitive, "key"],
     ]);
     // Single slash at start of something = absolute file path
@@ -177,24 +176,27 @@ describe("Origami parser", () => {
     ]);
     assertParse("functionComposition", "tree/", [
       ops.traverse,
-      [ops.scope, "tree"],
-      [ops.primitive, ""],
+      [ops.scope, "tree/"],
     ]);
     assertParse("functionComposition", "tree/key", [
       ops.traverse,
-      [ops.scope, "tree"],
+      [ops.scope, "tree/"],
       [ops.primitive, "key"],
     ]);
     assertParse("functionComposition", "tree/foo/bar", [
       ops.traverse,
-      [ops.scope, "tree"],
-      [ops.primitive, "foo"],
+      [ops.scope, "tree/"],
+      [ops.primitive, "foo/"],
       [ops.primitive, "bar"],
     ]);
     assertParse("functionComposition", "tree/key()", [
-      [ops.traverse, [ops.scope, "tree"], [ops.primitive, "key"]],
+      [ops.traverse, [ops.scope, "tree/"], [ops.primitive, "key"]],
       undefined,
     ]);
+    assertParse("functionComposition", "(tree)/", [
+      ops.unpack,
+      [ops.scope, "tree"],
+    ]);
     assertParse("functionComposition", "fn()/key()", [
       [ops.traverse, [[ops.scope, "fn"], undefined], [ops.primitive, "key"]],
       undefined,
@@ -249,7 +251,7 @@ describe("Origami parser", () => {
       [ops.primitive, "arg"],
     ]);
     assertParse("functionComposition", "tree/key arg", [
-      [ops.traverse, [ops.scope, "tree"], [ops.primitive, "key"]],
+      [ops.traverse, [ops.scope, "tree/"], [ops.primitive, "key"]],
       [ops.scope, "arg"],
     ]);
     assertParse("functionComposition", "https://example.com/tree.yaml 'key'", [
@@ -267,6 +269,7 @@ describe("Origami parser", () => {
   test("host", () => {
     assertParse("host", "abc", [ops.primitive, "abc"]);
     assertParse("host", "abc:123", [ops.primitive, "abc:123"]);
+    assertParse("host", "foo\\ bar", [ops.primitive, "foo bar"]);
   });
 
   test("identifier", () => {
@@ -295,10 +298,9 @@ describe("Origami parser", () => {
   });
 
   test("leadingSlashPath", () => {
-    assertParse("leadingSlashPath", "/tree/", [
-      [ops.primitive, "tree"],
-      [ops.primitive, ""],
-    ]);
+    assertParse("leadingSlashPath", "/", []);
+    assertParse("leadingSlashPath", "/tree", [[ops.primitive, "tree"]]);
+    assertParse("leadingSlashPath", "/tree/", [[ops.primitive, "tree/"]]);
   });
 
   test("list", () => {
@@ -358,16 +360,36 @@ describe("Origami parser", () => {
       ["a", [ops.primitive, 1]],
       ["b", [ops.inherited, "b"]],
     ]);
+    assertParse("object", "{ sub: { a: 1 } }", [
+      ops.object,
+      ["sub", [ops.object, ["a", [ops.primitive, 1]]]],
+    ]);
+    assertParse("object", "{ sub: { a/: 1 } }", [
+      ops.object,
+      ["sub", [ops.object, ["a/", [ops.primitive, 1]]]],
+    ]);
     assertParse("object", `{ "a": 1, "b": 2 }`, [
       ops.object,
       ["a", [ops.primitive, 1]],
       ["b", [ops.primitive, 2]],
     ]);
-    assertParse("object", "{ a = b, b: 2 }", [
+    assertParse("object", "{ a = b, b = 2 }", [
       ops.object,
       ["a", [ops.getter, [ops.scope, "b"]]],
       ["b", [ops.primitive, 2]],
     ]);
+    assertParse("object", "{ a: { b: 1 } }", [
+      ops.object,
+      ["a", [ops.object, ["b", [ops.primitive, 1]]]],
+    ]);
+    assertParse("object", "{ a: { b = 1 } }", [
+      ops.object,
+      ["a", [ops.object, ["b", [ops.primitive, 1]]]],
+    ]);
+    assertParse("object", "{ a: { b = fn() } }", [
+      ops.object,
+      ["a/", [ops.object, ["b", [ops.getter, [[ops.scope, "fn"], undefined]]]]],
+    ]);
     assertParse("object", "{ x = fn('a') }", [
       ops.object,
       [
@@ -429,6 +451,12 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("objectPublicKey", () => {
+    assertParse("objectPublicKey", "a", "a", false);
+    assertParse("objectPublicKey", "markdown/", "markdown/", false);
+    assertParse("objectPublicKey", "foo\\ bar", "foo bar", false);
+  });
+
   test("parameterizedLambda", () => {
     assertParse("parameterizedLambda", "() => foo", [
       ops.lambda,
@@ -470,19 +498,20 @@ describe("Origami parser", () => {
   });
 
   test("path", () => {
-    assertParse("path", "tree/", [
-      [ops.primitive, "tree"],
-      [ops.primitive, ""],
-    ]);
+    assertParse("path", "tree/", [[ops.primitive, "tree/"]]);
     assertParse("path", "month/12", [
-      [ops.primitive, "month"],
+      [ops.primitive, "month/"],
       [ops.primitive, "12"],
     ]);
     assertParse("path", "tree/foo/bar", [
-      [ops.primitive, "tree"],
-      [ops.primitive, "foo"],
+      [ops.primitive, "tree/"],
+      [ops.primitive, "foo/"],
       [ops.primitive, "bar"],
     ]);
+    assertParse("path", "a///b", [
+      [ops.primitive, "a/"],
+      [ops.primitive, "b"],
+    ]);
   });
 
   test("pipeline", () => {
@@ -514,8 +543,7 @@ describe("Origami parser", () => {
     assertParse("protocolCall", "https://example.com/foo/", [
       ops.https,
       [ops.primitive, "example.com"],
-      [ops.primitive, "foo"],
-      [ops.primitive, ""],
+      [ops.primitive, "foo/"],
     ]);
     assertParse("protocolCall", "http:example.com", [
       ops.http,
@@ -528,6 +556,25 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("scopeReference", () => {
+    assertParse("scopeReference", "x", [ops.scope, "x"]);
+  });
+
+  test("scopeTraverse", () => {
+    assertParse("scopeTraverse", "tree/foo/bar", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.primitive, "foo/"],
+      [ops.primitive, "bar"],
+    ]);
+    assertParse("scopeTraverse", "tree/foo/bar/", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.primitive, "foo/"],
+      [ops.primitive, "bar/"],
+    ]);
+  });
+
   test("shebang", () => {
     assertParse(
       "expression",
@@ -543,10 +590,6 @@ describe("Origami parser", () => {
     assertParse("singleLineComment", "// Hello, world!", null, false);
   });
 
-  test("scopeReference", () => {
-    assertParse("scopeReference", "x", [ops.scope, "x"]);
-  });
-
   test("spread", () => {
     assertParse("spread", "...a", [ops.spread, [ops.scope, "a"]]);
     assertParse("spread", "…a", [ops.spread, [ops.scope, "a"]]);

package/test/runtime/extensions.test.js

@@ -1,7 +1,7 @@
 import { ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { attachHandlerIfApplicable } from "../../src/runtime/extensions.js";
+import { handleExtension } from "../../src/runtime/extensions.js";
 
 describe("extensions", () => {
   test("attaches an unpack method to a value with an extension", async () => {
@@ -10,15 +10,18 @@ describe("extensions", () => {
     assert(typeof numberValue === "number");
     assert.equal(numberValue, 1);
     const jsonFile = await fixture.get("bar.json");
-    const withHandler = await attachHandlerIfApplicable(
-      fixture,
-      jsonFile,
-      "bar.json"
-    );
+    const withHandler = await handleExtension(fixture, jsonFile, "bar.json");
     assert.equal(String(withHandler), `{ "bar": 2 }`);
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });
   });
+
+  test("immediately unpacks if key ends in slash", async () => {
+    const fixture = createFixture();
+    const jsonFile = await fixture.get("bar.json");
+    const data = await handleExtension(fixture, jsonFile, "bar.json/");
+    assert.deepEqual(data, { bar: 2 });
+  });
 });
 
 function createFixture() {

package/test/runtime/ops.test.js

@@ -5,7 +5,7 @@ import { describe, test } from "node:test";
 import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
-  test("can resolve substitutions in a template literal", async () => {
+  test("ops.concat concatenates tree value text", async () => {
     const scope = new ObjectTree({
       name: "world",
     });
@@ -16,7 +16,33 @@ describe("ops", () => {
     assert.equal(result, "Hello, world.");
   });
 
-  test("can invoke a lambda", async () => {
+  test("ops.constructor returns a constructor", async () => {
+    const scope = new ObjectTree({
+      "@js": {
+        Number: Number,
+      },
+    });
+    const fn = await ops.constructor.call(scope, "@js", "Number");
+    const number = fn("1");
+    assert(number instanceof Number);
+    assert.equal(number, 1);
+  });
+
+  test("ops.inherited searches inherited scope", async () => {
+    const parent = new ObjectTree({
+      a: 1, // This is the inherited value we want
+    });
+    /** @type {any} */
+    const child = new ObjectTree({
+      a: 2, // Should be ignored
+    });
+    child.parent = parent;
+    const code = createCode([ops.inherited, "a"]);
+    const result = await evaluate.call(child, code);
+    assert.equal(result, 1);
+  });
+
+  test("ops.lambda defines a function", async () => {
     const scope = new ObjectTree({
       message: "Hello",
     });
@@ -28,14 +54,14 @@ describe("ops", () => {
     assert.equal(result, "Hello");
   });
 
-  test("lambda adds input to scope as `_`", async () => {
+  test("ops.lambda adds input to scope as `_`", async () => {
     const code = createCode([ops.lambda, null, [ops.scope, "_"]]);
     const fn = await evaluate.call(null, code);
     const result = await fn("Hello");
     assert.equal(result, "Hello");
   });
 
-  test("parameterized lambda adds input args to scope", async () => {
+  test("ops.lambda adds input parameters to scope", async () => {
     const code = createCode([
       ops.lambda,
       ["a", "b"],
@@ -46,7 +72,7 @@ describe("ops", () => {
     assert.equal(result, "yx");
   });
 
-  test("a lambda can reference itself with @recurse", async () => {
+  test("ops.lambda function can reference itself with @recurse", async () => {
     const code = createCode([ops.lambda, null, [ops.scope, "@recurse"]]);
     const fn = await evaluate.call(null, code);
     const result = await fn();
@@ -55,7 +81,7 @@ describe("ops", () => {
     assert.equal(result.code, fn.code);
   });
 
-  test("can instantiate an object", async () => {
+  test("ops.object instantiates an object", async () => {
     const scope = new ObjectTree({
       upper: (s) => s.toUpperCase(),
     });
@@ -71,7 +97,7 @@ describe("ops", () => {
     assert.equal(result.world, "WORLD");
   });
 
-  test("can instantiate an array", async () => {
+  test("ops.object instantiates an array", async () => {
     const scope = new ObjectTree({
       upper: (s) => s.toUpperCase(),
     });
@@ -85,30 +111,11 @@ describe("ops", () => {
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
   });
 
-  test("can search inherited scope", async () => {
-    const parent = new ObjectTree({
-      a: 1, // This is the inherited value we want
-    });
-    /** @type {any} */
-    const child = new ObjectTree({
-      a: 2, // Should be ignored
-    });
-    child.parent = parent;
-    const code = createCode([ops.inherited, "a"]);
-    const result = await evaluate.call(child, code);
-    assert.equal(result, 1);
-  });
-
-  test("returns a constructor", async () => {
-    const scope = new ObjectTree({
-      "@js": {
-        Number: Number,
-      },
-    });
-    const fn = await ops.constructor.call(scope, "@js", "Number");
-    const number = fn("1");
-    assert(number instanceof Number);
-    assert.equal(number, 1);
+  test("ops.unpack unpacks a value", async () => {
+    const fixture = new String("packed");
+    /** @type {any} */ (fixture).unpack = async () => "unpacked";
+    const result = await ops.unpack.call(null, fixture);
+    assert.equal(result, "unpacked");
   });
 });