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

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);