@weborigami/async-tree 0.0.66-beta.1 → 0.0.66

package/test/calendarTree.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { toPlainValue } from "../main.js";
 import calendarTree from "../src/calendarTree.js";
+import { toPlainValue } from "../src/utilities.js";
 
 describe("calendarTree", () => {
   test("without a start or end, returns a tree for today", async () => {

package/test/fixtures/markdown/subfolder/README.md

@@ -0,0 +1 @@
+This file exists to force the creation of the parent folder.

package/test/jsonKeys.test.js

@@ -4,15 +4,6 @@ import { describe, test } from "node:test";
 import * as jsonKeys from "../src/jsonKeys.js";
 
 describe("jsonKeys", () => {
-  test("parses JSON Keys", async () => {
-    const json = '["index.html","about/"]';
-    const parsed = jsonKeys.parse(json);
-    assert.deepStrictEqual(parsed, {
-      "index.html": false,
-      about: true,
-    });
-  });
-
   test("stringifies JSON Keys", async () => {
     const tree = new DeepObjectTree({
       about: {},

package/test/operations/cache.test.js

@@ -19,7 +19,7 @@ describe("cache", () => {
     );
 
     const keys = [...(await fixture.keys())];
-    assert.deepEqual(keys, ["a", "b", "c", "more"]);
+    assert.deepEqual(keys, ["a", "b", "c", "more/"]);
 
     assert.equal(await objectCache.get("a"), undefined);
     assert.equal(await fixture.get("a"), 1);

package/test/operations/merge.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { Tree } from "../../src/internal.js";
+import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import merge from "../../src/operations/merge.js";
 import * as symbols from "../../src/symbols.js";
 
@@ -42,4 +42,23 @@ describe("merge", () => {
     const b = await fixture.get("b");
     assert.equal(b[symbols.parent], fixture);
   });
+
+  test("subtree can overwrite a leaf node", async () => {
+    const fixture = merge(
+      new ObjectTree({
+        a: 1,
+      }),
+      new DeepObjectTree({
+        a: {
+          b: 2,
+        },
+      })
+    );
+    assert.deepEqual([...(await fixture.keys())], ["a/"]);
+    assert.deepEqual(await Tree.plain(fixture), {
+      a: {
+        b: 2,
+      },
+    });
+  });
 });

package/test/trailingSlash.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { add, has, remove, toggle } from "../src/trailingSlash.js";
+
+describe("trailingSlash", () => {
+  test("add adds a trailing slash to a string key for a truthy value", () => {
+    assert.equal(add("key"), "key/");
+    assert.equal(add("key/"), "key/");
+    assert.equal(add(1), 1);
+  });
+
+  test("has returns true if a string key has a trailing slash", () => {
+    assert.equal(has("key/"), true);
+    assert.equal(has("key"), false);
+    assert.equal(has(1), false);
+  });
+
+  test("remove removes a trailing slash from a string key", () => {
+    assert.equal(remove("key/"), "key");
+    assert.equal(remove("key"), "key");
+    assert.equal(remove(1), 1);
+  });
+
+  test("toggle removes a slash if present, adds one if not", () => {
+    assert.equal(toggle("key/"), "key");
+    assert.equal(toggle("key"), "key/");
+    assert.equal(toggle(1), 1);
+  });
+
+  test("toggle can force toggling on or off", () => {
+    assert.equal(toggle("key/", false), "key");
+    assert.equal(toggle("key/", true), "key/");
+    assert.equal(toggle("key", false), "key");
+    assert.equal(toggle("key", true), "key/");
+  });
+});

package/test/transforms/cachedKeyFunctions.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
+import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
+
+describe("cachedKeyFunctions", () => {
+  test("maps keys with caching", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+
+    let callCount = 0;
+    const addUnderscore = async (sourceKey, tree) => {
+      callCount++;
+      return `_${sourceKey}`;
+    };
+
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscore);
+
+    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
+    assert.equal(callCount, 1);
+    assert.equal(await inverseKey("_a", tree), "a");
+    assert.equal(callCount, 1);
+    assert.equal(await inverseKey("_b", tree), "b"); // Cache miss
+    assert.equal(callCount, 2);
+
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await key("b", tree), "_b");
+    assert.equal(callCount, 2);
+
+    // `c` isn't in tree, so we should get undefined.
+    assert.equal(await inverseKey("_c", tree), undefined);
+    // But key mapping is still possible.
+    assert.equal(await key("c", tree), "_c");
+    // And now we have a cache hit.
+    assert.equal(await inverseKey("_c", tree), "c");
+    assert.equal(callCount, 3);
+  });
+
+  test("maps keys with caching and deep option", async () => {
+    const tree = new DeepObjectTree({
+      a: "letter a",
+      b: {
+        c: "letter c",
+      },
+    });
+
+    let callCount = 0;
+    const addUnderscore = async (sourceKey, tree) => {
+      callCount++;
+      return `_${sourceKey}`;
+    };
+
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscore, true);
+
+    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
+    assert.equal(await inverseKey("_a", tree), "a");
+    assert.equal(callCount, 1);
+
+    // Subtree key left alone
+    assert.equal(await inverseKey("_b", tree), undefined);
+    assert.equal(await inverseKey("b", tree), "b");
+    assert.equal(await inverseKey("b/", tree), "b/");
+    assert.equal(callCount, 1);
+
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(await key("a", tree), "_a");
+    assert.equal(callCount, 1);
+
+    assert.equal(await key("b/", tree), "b/");
+    assert.equal(await key("b", tree), "b");
+    assert.equal(callCount, 1);
+  });
+
+  test("preserves trailing slashes", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+    });
+    const addUnderscore = async (sourceKey) => `_${sourceKey}`;
+    const { inverseKey, key } = cachedKeyFunctions(addUnderscore);
+
+    assert.equal(await key("a/", tree), "_a/");
+    assert.equal(await key("a", tree), "_a");
+
+    assert.equal(await inverseKey("_a/", tree), "a/");
+    assert.equal(await inverseKey("_a", tree), "a");
+  });
+});

package/test/transforms/keyFunctionsForExtensions.test.js

@@ -10,18 +10,22 @@ describe("keyMapsForExtensions", () => {
       sourceExtension: "txt",
     });
     assert.equal(await inverseKey("file.txt"), "file.txt");
+    assert.equal(await inverseKey("file.txt/"), "file.txt");
     assert.equal(await key("file.txt"), "file.txt");
+    assert.equal(await key("file.txt/"), "file.txt/");
     assert.equal(await inverseKey("file.foo"), undefined);
     assert.equal(await key("file.foo"), undefined);
   });
 
   test("returns key functions that can map extensions", async () => {
     const { inverseKey, key } = keyFunctionsForExtensions({
-      resultExtension: "html",
+      resultExtension: "json",
       sourceExtension: "md",
     });
-    assert.equal(await inverseKey("file.html"), "file.md");
-    assert.equal(await key("file.md"), "file.html");
+    assert.equal(await inverseKey("file.json"), "file.md");
+    assert.equal(await inverseKey("file.json/"), "file.md");
+    assert.equal(await key("file.md"), "file.json");
+    assert.equal(await key("file.md/"), "file.json/");
     assert.equal(await inverseKey("file.foo"), undefined);
     assert.equal(await key("file.foo"), undefined);
   });

package/test/transforms/mapFn.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import FunctionTree from "../../src/FunctionTree.js";
 import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
+import * as trailingSlash from "../../src/trailingSlash.js";
 import mapFn from "../../src/transforms/mapFn.js";
 
 describe("mapFn", () => {
@@ -59,11 +60,11 @@ describe("mapFn", () => {
       a: "letter a",
       b: "letter b",
     };
-    const doubleKeys = mapFn({
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+    const underscopeKeys = mapFn({
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
     });
-    const mapped = doubleKeys(tree);
+    const mapped = underscopeKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "letter a",
       _b: "letter b",
@@ -75,12 +76,12 @@ describe("mapFn", () => {
       a: "letter a",
       b: "letter b",
     };
-    const doubleKeysUppercaseValues = mapFn({
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+    const underscoreKeysUppercaseValues = mapFn({
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
       value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    const mapped = doubleKeysUppercaseValues(tree);
+    const mapped = underscoreKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
       _b: "LETTER B",
@@ -94,12 +95,12 @@ describe("mapFn", () => {
         b: "letter b",
       },
     };
-    const doubleKeys = mapFn({
+    const underscopeKeys = mapFn({
       key: async (sourceKey, tree) => `_${sourceKey}`,
       inverseKey: async (resultKey, tree) => resultKey.slice(1),
       value: async (sourceValue, sourceKey, tree) => sourceKey,
     });
-    const mapped = doubleKeys(tree);
+    const mapped = underscopeKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "a",
       _more: "more",
@@ -108,8 +109,8 @@ describe("mapFn", () => {
 
   test("value can provide a default key and inverse key functions", async () => {
     const uppercase = (s) => s.toUpperCase();
-    uppercase.key = (sourceKey) => `_${sourceKey}`;
-    uppercase.inverseKey = (resultKey) => resultKey.slice(1);
+    uppercase.key = addUnderscore;
+    uppercase.inverseKey = removeUnderscore;
     const tree = {
       a: "letter a",
       b: "letter b",
@@ -148,12 +149,12 @@ describe("mapFn", () => {
         b: "letter b",
       },
     });
-    const doubleKeys = mapFn({
+    const underscoreKeys = mapFn({
       deep: true,
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
     });
-    const mapped = doubleKeys(tree);
+    const mapped = underscoreKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "letter a",
       more: {
@@ -169,13 +170,13 @@ describe("mapFn", () => {
         b: "letter b",
       },
     });
-    const doubleKeysUppercaseValues = mapFn({
+    const underscoreKeysUppercaseValues = mapFn({
       deep: true,
-      key: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      key: addUnderscore,
+      inverseKey: removeUnderscore,
       value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
-    const mapped = doubleKeysUppercaseValues(tree);
+    const mapped = underscoreKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
       more: {
@@ -201,3 +202,11 @@ describe("mapFn", () => {
     assert(!flag);
   });
 });
+
+function addUnderscore(key) {
+  return `_${key}`;
+}
+
+function removeUnderscore(key) {
+  return trailingSlash.has(key) ? key : key.slice(1);
+}

package/test/utilities.test.js

@@ -41,8 +41,12 @@ describe("utilities", () => {
   });
 
   test("keysFromPath() returns the keys from a slash-separated path", () => {
-    assert.deepEqual(utilities.keysFromPath("a/b/c"), ["a", "b", "c"]);
-    assert.deepEqual(utilities.keysFromPath("foo/"), ["foo", ""]);
+    assert.deepEqual(utilities.keysFromPath(""), []);
+    assert.deepEqual(utilities.keysFromPath("/"), []);
+    assert.deepEqual(utilities.keysFromPath("a/b/c"), ["a/", "b/", "c"]);
+    assert.deepEqual(utilities.keysFromPath("a/b/c/"), ["a/", "b/", "c/"]);
+    assert.deepEqual(utilities.keysFromPath("/foo/"), ["foo/"]);
+    assert.deepEqual(utilities.keysFromPath("a///b"), ["a/", "b"]);
   });
 
   test("naturalOrder compares strings in natural order", () => {

package/test/transforms/cachedKeyMaps.test.js

@@ -1,41 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import { ObjectTree } from "../../src/internal.js";
-import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
-
-describe("cachedKeyFunctions", () => {
-  test("maps keys with caching", async () => {
-    const tree = new ObjectTree({
-      a: "letter a",
-      b: "letter b",
-    });
-
-    let callCount = 0;
-    const underscoreKeys = async (sourceKey, tree) => {
-      callCount++;
-      return `_${sourceKey}`;
-    };
-
-    const { inverseKey, key } = cachedKeyFunctions(underscoreKeys);
-
-    assert.equal(await inverseKey("_a", tree), "a"); // Cache miss
-    assert.equal(callCount, 1);
-    assert.equal(await inverseKey("_a", tree), "a");
-    assert.equal(callCount, 1);
-    assert.equal(await inverseKey("_b", tree), "b"); // Cache miss
-    assert.equal(callCount, 2);
-
-    assert.equal(await key("a", tree), "_a");
-    assert.equal(await key("a", tree), "_a");
-    assert.equal(await key("b", tree), "_b");
-    assert.equal(callCount, 2);
-
-    // `c` isn't in tree, so we should get undefined.
-    assert.equal(await inverseKey("_c", tree), undefined);
-    // But key mapping is still possible.
-    assert.equal(await key("c", tree), "_c");
-    // And now we have a cache hit.
-    assert.equal(await inverseKey("_c", tree), "c");
-    assert.equal(callCount, 3);
-  });
-});