@weborigami/language 0.7.0-beta.2 → 0.7.0-beta.3

package/test/compiler/parse.test.js

@@ -604,7 +604,7 @@ describe("Origami parser", () => {
         [ops.literal, "key"],
       ]);
       assertParse("callExpression", "{ a: 1, b: 2}/b", [
-        [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
+        [ops.object, null, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
         [ops.literal, "b"],
       ]);
       assertParse("callExpression", "files:foo/bar", [
@@ -897,12 +897,13 @@ Body`,
       assertParse("expression", "1", [ops.literal, 1]);
       assertParse("expression", "{ a: 1, b: 2 }", [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [ops.literal, 2]],
       ]);
       assertParse("expression", "serve { index.html: 'hello' }", [
         [markers.traverse, [markers.reference, "serve"]],
-        [ops.object, ["index.html", [ops.literal, "hello"]]],
+        [ops.object, null, ["index.html", [ops.literal, "hello"]]],
       ]);
       assertParse("expression", "fn =`x`", [
         [markers.traverse, [markers.reference, "fn"]],
@@ -991,6 +992,7 @@ Body`,
       }`,
         [
           ops.object,
+          null,
           [
             "index.html",
             [
@@ -1010,6 +1012,7 @@ Body`,
                 [markers.traverse, [markers.reference, "images"]],
                 [
                   ops.object,
+                  null,
                   [
                     "value",
                     [markers.traverse, [markers.reference, "thumbnail.js"]],
@@ -1253,27 +1256,32 @@ Body`,
 
   describe("objectLiteral", () => {
     test("basic objects", () => {
-      assertParse("objectLiteral", "{}", [ops.object]);
+      assertParse("objectLiteral", "{}", [ops.object, null]);
       assertParse("objectLiteral", "{ a: 1, b }", [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [markers.traverse, [markers.reference, "b"]]],
       ]);
       assertParse("objectLiteral", "{ sub: { a: 1 } }", [
         ops.object,
-        ["sub", [ops.object, ["a", [ops.literal, 1]]]],
+        null,
+        ["sub", [ops.object, null, ["a", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", "{ sub: { a/: 1 } }", [
         ops.object,
-        ["sub", [ops.object, ["a/", [ops.literal, 1]]]],
+        null,
+        ["sub", [ops.object, null, ["a/", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", `{ "a": 1, "b": 2 }`, [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [ops.literal, 2]],
       ]);
       assertParse("objectLiteral", "{ a = b, b = 2 }", [
         ops.object,
+        null,
         ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
         ["b", [ops.literal, 2]],
       ]);
@@ -1285,24 +1293,29 @@ Body`,
       }`,
         [
           ops.object,
+          null,
           ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
           ["b", [ops.literal, 2]],
         ],
       );
       assertParse("objectLiteral", "{ a: { b: 1 } }", [
         ops.object,
-        ["a", [ops.object, ["b", [ops.literal, 1]]]],
+        null,
+        ["a", [ops.object, null, ["b", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", "{ a: { b = 1 } }", [
         ops.object,
-        ["a", [ops.object, ["b", [ops.literal, 1]]]],
+        null,
+        ["a", [ops.object, null, ["b", [ops.literal, 1]]]],
       ]);
       assertParse("objectLiteral", "{ a: { b = fn() } }", [
         ops.object,
+        null,
         [
           "a",
           [
             ops.object,
+            null,
             [
               "b",
               [ops.getter, [[markers.traverse, [markers.reference, "fn"]]]],
@@ -1312,6 +1325,7 @@ Body`,
       ]);
       assertParse("objectLiteral", "{ x = fn.js('a') }", [
         ops.object,
+        null,
         [
           "x",
           [
@@ -1326,10 +1340,12 @@ Body`,
 
       assertParse("objectLiteral", "{ (a): 1 }", [
         ops.object,
+        null,
         ["(a)", [ops.literal, 1]],
       ]);
       assertParse("objectLiteral", "{ <path/to/file.txt> }", [
         ops.object,
+        null,
         [
           "file.txt",
           [
@@ -1350,15 +1366,24 @@ Body`,
       assertParse("objectLiteral", "{ a: 1, ...more, c: a }", [
         [
           ops.object,
+          null,
           ["a", [ops.literal, 1]],
           ["c", [markers.traverse, [markers.reference, "a"]]],
           [
             "_result",
             [
               ops.merge,
-              [ops.object, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
+              [
+                ops.object,
+                null,
+                ["a", [ops.getter, [[ops.inherited, 1], "a"]]],
+              ],
               [markers.traverse, [markers.reference, "more"]],
-              [ops.object, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
+              [
+                ops.object,
+                null,
+                ["c", [ops.getter, [[ops.inherited, 1], "c"]]],
+              ],
             ],
           ],
         ],
@@ -1366,6 +1391,7 @@ Body`,
       ]);
       assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["b", [ops.literal, 2]],
       ]);
@@ -1374,6 +1400,7 @@ Body`,
     test("computed property keys", () => {
       assertParse("objectLiteral", "{ [key]: value }", [
         ops.object,
+        null,
         [
           [markers.traverse, [markers.reference, "key"]],
           [markers.traverse, [markers.reference, "value"]],
@@ -1816,6 +1843,7 @@ title: Title goes here
 Body text`,
       [
         ops.object,
+        null,
         ["title", [ops.literal, "Title goes here"]],
         ["_body", [ops.templateIndent, [ops.literal, ["Body text"]]]],
       ],
@@ -1835,6 +1863,7 @@ Body text`,
 `,
       [
         ops.object,
+        null,
         ["title", [ops.literal, "Title"]],
         [
           "_body",

package/test/runtime/AsyncCacheTransform.test.js

@@ -41,7 +41,8 @@ describe("AsyncCacheTransform", () => {
       ],
     ]);
 
-    assert.deepEqual(await Tree.entries(calcs), [
+    const entries = await Tree.entries(calcs);
+    assert.deepEqual(entries, [
       ["a", 8],
       ["b", 4],
       ["c", 3],
@@ -55,11 +56,13 @@ describe("AsyncCacheTransform", () => {
 
     // Replace formula for a
     // { a = 3 * b, b = c + 1, c = 3 }
-    data.set("a", async () => {
+    await data.set("a", async () => {
       log.push("a");
       const b = await calcs.get("b");
       return 3 * b;
     });
+    // Manually trigger cache invalidation
+    data.onValueChange("a");
     log = [];
     const a2 = await calcs.get("a");
     assert.strictEqual(a2, 12);
@@ -67,11 +70,12 @@ describe("AsyncCacheTransform", () => {
 
     // Replace formula for b
     // { a = 3 * b, b = c + 10, c = 3 }
-    data.set("b", async () => {
+    await data.set("b", async () => {
       log.push("b");
       const c = await calcs.get("c");
       return c + 10;
     });
+    data.onValueChange("b");
     log = [];
     const a3 = await calcs.get("a");
     assert.strictEqual(a3, 39);
@@ -79,10 +83,11 @@ describe("AsyncCacheTransform", () => {
 
     // Replace value of c
     // { a = 3 * b, b = c + 10, c = 100 }
-    data.set("c", async () => {
+    await data.set("c", async () => {
       log.push("c");
       return 100;
     });
+    data.onValueChange("c");
     log = [];
     const a4 = await calcs.get("a");
     assert.strictEqual(a4, 330);

package/test/runtime/SyncCacheTransform.test.js

@@ -62,6 +62,8 @@ describe("SyncCacheTransform", () => {
       const b = calcs.get("b");
       return 3 * b;
     });
+    // Manually trigger cache invalidation
+    data.onValueChange("a");
     log = [];
     const a2 = calcs.get("a");
     assert.strictEqual(a2, 12);
@@ -74,6 +76,7 @@ describe("SyncCacheTransform", () => {
       const c = calcs.get("c");
       return c + 10;
     });
+    data.onValueChange("b");
     log = [];
     const a3 = calcs.get("a");
     assert.strictEqual(a3, 39);
@@ -85,6 +88,7 @@ describe("SyncCacheTransform", () => {
       log.push("c");
       return 100;
     });
+    data.onValueChange("c");
     log = [];
     const a4 = calcs.get("a");
     assert.strictEqual(a4, 330);

package/test/runtime/asyncCalcs.js

@@ -1,13 +1,35 @@
-import { AsyncMap, SyncMap } from "@weborigami/async-tree";
+import { AsyncMap } from "@weborigami/async-tree";
 import AsyncCacheTransform from "../../src/runtime/AsyncCacheTransform.js";
-import SyncCacheTransform from "../../src/runtime/SyncCacheTransform.js";
 
 export default function asyncCalcs(iterable) {
-  const data = new (SyncCacheTransform(SyncMap))(iterable);
+  const data = new (AsyncCacheTransform(AsyncDataMap))(new Map(iterable));
   const calcs = new (AsyncCacheTransform(AsyncResultsMap))(data);
   return { calcs, data };
 }
 
+class AsyncDataMap extends AsyncMap {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+
+  async delete(key) {
+    return this.source.delete(key);
+  }
+
+  async get(key) {
+    return this.source.get(key);
+  }
+
+  async *keys() {
+    yield* this.source.keys();
+  }
+
+  async set(key, value) {
+    return this.source.set(key, value);
+  }
+}
+
 class AsyncResultsMap extends AsyncMap {
   constructor(source) {
     super();
@@ -15,7 +37,7 @@ class AsyncResultsMap extends AsyncMap {
   }
 
   async get(key) {
-    let value = this.source.get(key);
+    let value = await this.source.get(key);
     if (typeof value === "function") {
       value = await value();
     }

package/test/runtime/errors.test.js

@@ -188,7 +188,7 @@ evaluating: \x1B[31mposts.md\x1B[0m
         `(post1/totle).toUpperCase()`,
         `ReferenceError: Tried to get a property of something that doesn't exist.
 This path returned undefined: post1/totle
-evaluating: \x1B[31mpost1/totle\x1B[0m`,
+evaluating: \x1B[31m(post1/totle)\x1B[0m`,
         { parent },
       );
     });
@@ -238,7 +238,7 @@ evaluating: \x1B[31msup/\x1B[0m`,
 Tried to traverse path:  map/1/a
 Stopped unexpectedly at: 1/
 Slash-separated keys are searched as strings. Here there's no string "1" key, but there is a number 1 key.
-To get the value for that number key, use parentheses: map/(1)
+To get the value for that number key, use parentheses: map/(1)/a
 evaluating: \x1B[31m1/\x1B[0m`,
         { parent },
       );
@@ -250,8 +250,8 @@ evaluating: \x1B[31m1/\x1B[0m`,
       });
       await assertError(
         `file.foo/bar`,
-        `TraverseError: A path hit binary data that can't be unpacked.
-Tried to traverse path:  file.foo/bar
+        `TraverseError: A path tried to unpack data but there's no unpack function.
+Tried to traverse path:  file.foo/
 Stopped unexpectedly at: file.foo/
 The value couldn't be unpacked because no file extension handler is registered for ".foo".
 evaluating: \x1B[31mfile.foo/\x1B[0m`,

package/test/runtime/expressionObject.test.js

@@ -23,7 +23,7 @@ describe("expressionObject", () => {
     ];
     const context = new SyncMap();
 
-    const object = await expressionObject(entries, {
+    const object = await expressionObject("test.ori/", entries, {
       object: context,
       parent,
     });
@@ -36,7 +36,7 @@ describe("expressionObject", () => {
     let count = 0;
     const increment = () => count++;
     const entries = [["count", [increment]]];
-    const object = await expressionObject(entries);
+    const object = await expressionObject("test.ori/", entries);
     const propertyDescriptor = Object.getOwnPropertyDescriptor(object, "count");
     assert.equal(propertyDescriptor?.value, 0);
     assert.equal(object.count, 0);
@@ -47,7 +47,7 @@ describe("expressionObject", () => {
     let count = 0;
     const increment = () => count++;
     const entries = [["count", [ops.getter, [increment]]]];
-    const object = await expressionObject(entries);
+    const object = await expressionObject("test.ori/", entries);
     object[cachePathSymbol] = "foo.ori/"; // enable caching on this object tree
     assert.equal(await object.count, 0);
     const propertyDescriptor = Object.getOwnPropertyDescriptor(object, "count");
@@ -58,7 +58,7 @@ describe("expressionObject", () => {
 
   test("treats a getter for a primitive value as a regular property", async () => {
     const entries = [["name", [ops.getter, "world"]]];
-    const object = await expressionObject(entries);
+    const object = await expressionObject("test.ori/", entries);
     assert.equal(object.name, "world");
   });
 
@@ -68,7 +68,9 @@ describe("expressionObject", () => {
       ["message", [ops.deepText, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
     ];
     const context = new SyncMap();
-    const object = await expressionObject(entries, { object: context });
+    const object = await expressionObject("test.ori/", entries, {
+      object: context,
+    });
     assert.deepEqual(await Tree.plain(object), {
       name: "world",
       message: "Hello, world!",
@@ -92,7 +94,9 @@ describe("expressionObject", () => {
       ["name", "data"],
     ];
     const context = new SyncMap();
-    const object = await expressionObject(entries, { object: context });
+    const object = await expressionObject("test.ori/", entries, {
+      object: context,
+    });
     assert.deepEqual(await Tree.plain(object), {
       "data.json": 1,
       name: "data",
@@ -105,7 +109,7 @@ describe("expressionObject", () => {
     const globals = {
       json_handler: { unpack: (data) => JSON.parse(data) },
     };
-    const result = await expressionObject(entries, {
+    const result = await expressionObject("test.ori/", entries, {
       object: context,
       globals,
     });
@@ -119,7 +123,7 @@ describe("expressionObject", () => {
       ["(hidden)", "shh"],
       ["visible", "hey"],
     ];
-    const object = await expressionObject(entries);
+    const object = await expressionObject("test.ori/", entries);
     assert.deepEqual(Object.keys(object), ["visible"]);
     assert.equal(object["hidden"], "shh");
   });
@@ -127,15 +131,15 @@ describe("expressionObject", () => {
   test("provides a symbols.keys method returning normalized keys", async () => {
     const entries = [
       // Will return a tree, should have a slash
-      ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
+      ["getter", [ops.getter, [ops.object, null, ["b", [ops.literal, 2]]]]],
       ["hasSlash/", "This isn't really a tree but says it is"],
       ["message", "Hello"],
       // Immediate maplike value, should have a slash
-      ["object", [ops.object, ["b", [ops.literal, 2]]]],
+      ["object", [ops.object, null, ["b", [ops.literal, 2]]]],
       // Computed key
       [[ops.deepText, [ops.array, "data", ".json"]], 1],
     ];
-    const object = await expressionObject(entries);
+    const object = await expressionObject("test.ori/", entries);
     assert.deepEqual(object[symbols.keys](), [
       "getter/",
       "hasSlash/",
@@ -152,7 +156,7 @@ describe("expressionObject", () => {
     const getNumber = () =>
       systemCache.getOrInsertComputed("dependency", () => 1);
     const entries = [["number", [ops.getter, [getNumber]]]];
-    const object = await expressionObject(entries);
+    const object = await expressionObject("test.ori/", entries);
     object[cachePathSymbol] = "src/test.ori/"; // enable caching on this object tree
     const number = await object.number;
     assert.equal(number, 1);
@@ -162,4 +166,11 @@ describe("expressionObject", () => {
     assert(dependencyEntry.downstreams.has("src/test.ori/number"));
     assert(objectEntry.upstreams.has("dependency"));
   });
+
+  test("generates a unique cache path for an unattached object", async () => {
+    const object0 = await expressionObject("test.ori/_objects/", [["a", 1]]);
+    assert.equal(object0[cachePathSymbol], "test.ori/_objects/0/");
+    const object1 = await expressionObject("test.ori/_objects/", [["a", 1]]);
+    assert.equal(object1[cachePathSymbol], "test.ori/_objects/1/");
+  });
 });

package/test/runtime/handleExtension.test.js

@@ -4,11 +4,9 @@ import { describe, test } from "node:test";
 import * as handlers from "../../src/handlers/handlers.js";
 import handleExtension from "../../src/runtime/handleExtension.js";
 import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
-import { cachePathSymbol } from "../../src/runtime/symbols.js";
 
 const fixturesUrl = new URL("fixtures/unpack", import.meta.url);
 const fixtureFiles = new OrigamiFileMap(fixturesUrl);
-fixtureFiles[cachePathSymbol] = "fixtures";
 fixtureFiles.globals = handlers;
 
 describe("handleExtension", () => {

package/test/runtime/ops.test.js

@@ -56,7 +56,7 @@ describe("ops", () => {
 
   test("ops.cache", async () => {
     const fn = () => 1;
-    const code = createCode([ops.object, ["a", [ops.getter, [fn]]]]);
+    const code = createCode([ops.object, null, ["a", [ops.getter, [fn]]]]);
     const result = await ops.cache("a.ori/_refs/b.ori/", code, {});
     assert.deepEqual(await Tree.plain(result), { a: 1 });
     const cachedResult = await systemCache.get("a.ori/_refs/b.ori/");
@@ -333,15 +333,16 @@ describe("ops", () => {
     const code = createCode([
       [
         ops.object,
+        null,
         ["a", [ops.literal, 1]],
         ["c", [[ops.inherited, 0], "a"]],
         [
           "_result",
           [
             ops.merge,
-            [ops.object, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
+            [ops.object, null, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
             [[ops.scope], "more"],
-            [ops.object, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
+            [ops.object, null, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
           ],
         ],
       ],
@@ -390,6 +391,7 @@ describe("ops", () => {
 
     const code = createCode([
       ops.object,
+      null,
       ["hello", [[[ops.scope], "upper"], "hello"]],
       ["world", [[[ops.scope], "upper"], "world"]],
     ]);

package/test/runtime/syncCalcs.js

@@ -2,12 +2,35 @@ import { SyncMap } from "@weborigami/async-tree";
 import SyncCacheTransform from "../../src/runtime/SyncCacheTransform.js";
 
 export default function syncCalcs(iterable) {
-  const data = new (SyncCacheTransform(SyncMap))(iterable);
-  const calcs = new (SyncCacheTransform(SyncResultsMap))(data);
+  const data = new (SyncCacheTransform(SyncDataMap))(new Map(iterable));
+  const calcs = new (SyncCacheTransform(SyncCalcsMap))(data);
   return { calcs, data };
 }
 
-class SyncResultsMap extends SyncMap {
+class SyncDataMap extends SyncMap {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+
+  delete(key) {
+    return this.source.delete(key);
+  }
+
+  get(key) {
+    return this.source.get(key);
+  }
+
+  keys() {
+    return this.source.keys();
+  }
+
+  set(key, value) {
+    return this.source.set(key, value);
+  }
+}
+
+class SyncCalcsMap extends SyncMap {
   constructor(source) {
     super();
     this.source = source;

package/test/runtime/systemCache.test.js

@@ -48,12 +48,16 @@ describe("systemCache", () => {
 
     // Add new data.json to src folder, overriding the one in project root
     src.set("data.json", "2");
+    // Manually trigger cache invalidation
+    src.onValueChange("data.json");
 
     const value2 = await site.value;
     assert.equal(value2, 2);
 
     // Delete data.json from src folder, reverting to the one in project root
     src.delete("data.json");
+    // Manually trigger cache invalidation
+    src.onValueChange("data.json");
 
     const value3 = await site.value;
     assert.equal(value3, 1);