@jsenv/snapshot 2.5.3 → 2.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.5.3",
+  "version": "2.6.1",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {
@@ -35,10 +35,10 @@
   },
   "dependencies": {
     "@jsenv/assert": "4.1.6",
-    "@jsenv/ast": "6.2.6",
+    "@jsenv/ast": "6.2.8",
     "@jsenv/exception": "1.0.0",
-    "@jsenv/filesystem": "4.9.3",
-    "@jsenv/urls": "2.3.2",
+    "@jsenv/filesystem": "4.9.4",
+    "@jsenv/urls": "2.4.0",
     "@jsenv/utils": "2.1.2",
     "pixelmatch": "6.0.0",
     "prettier": "3.3.3",

package/src/replace_fluctuating_values.js

@@ -11,8 +11,14 @@ import {
   stringifyHtmlAst,
   visitHtmlNodes,
 } from "@jsenv/ast";
-import { urlToExtension } from "@jsenv/urls";
+import {
+  ensurePathnameTrailingSlash,
+  removePathnameTrailingSlash,
+  urlToExtension,
+} from "@jsenv/urls";
 import { escapeRegexpSpecialChars } from "@jsenv/utils/src/string/escape_regexp_special_chars.js";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import stripAnsi from "strip-ansi";
 
@@ -22,35 +28,133 @@ export const replaceFluctuatingValues = (
     stringType,
     fileUrl,
     removeAnsi = true,
-    rootDirectoryUrl = pathToFileURL(process.cwd()),
+    rootDirectoryUrl,
     // for unit tests
-    rootDirectoryPath,
+    ancestorPackagesDisabled,
+    ancestorPackagesRootDirectoryUrl = "file:///",
+    homedirDisabled,
+    cwdPath = process.cwd(),
+    cwdUrl,
     isWindows = process.platform === "win32",
   } = {},
 ) => {
-  rootDirectoryUrl = String(rootDirectoryUrl);
-  if (rootDirectoryUrl[rootDirectoryUrl.length - 1] === "/") {
-    rootDirectoryUrl = rootDirectoryUrl.slice(0, -1);
+  const wellKownUrlArray = [];
+  const wellKnownPathArray = [];
+  const addWellKnownFileUrl = (url, replacement) => {
+    const urlWithoutTrailingSlash = removePathnameTrailingSlash(url);
+    wellKownUrlArray.push({
+      url: urlWithoutTrailingSlash,
+      replacement,
+      replace: (string) =>
+        string.replaceAll(urlWithoutTrailingSlash, replacement),
+    });
+    const path =
+      url === cwdUrl ? cwdPath : fileURLToPath(urlWithoutTrailingSlash);
+    const windowPathRegex = new RegExp(
+      `${escapeRegexpSpecialChars(path)}(((?:\\\\(?:[\\w !#()-]+|[.]{1,2})+)*)(?:\\\\)?)`,
+      "gm",
+    );
+    const pathReplacement = replacement.startsWith("file:///")
+      ? replacement.slice("file:///".length)
+      : replacement;
+    wellKnownPathArray.push({
+      path,
+      replacement: pathReplacement,
+      replace: isWindows
+        ? (string) => {
+            return string.replaceAll(windowPathRegex, (match, after) => {
+              return `${pathReplacement}${after.replaceAll("\\", "/")}`;
+            });
+          }
+        : (string) => string.replaceAll(path, pathReplacement),
+    });
+  };
+  if (rootDirectoryUrl) {
+    addWellKnownFileUrl(rootDirectoryUrl, "file:///<root>");
+  }
+  /*
+   * When running code inside a node project ancestor packages
+   * should make things super predictible because
+   * it will use a package.json name field
+   * to replace files urls
+   * And uses the highest ancestor package so that even if the file
+   * is executed once within a package then outside that package
+   * the replace value remains predictible as the highest package is used
+   * The highest package is used because it's pushed first by
+   * addWellKnownFileUrl
+   */
+  ancestor_packages: {
+    if (ancestorPackagesDisabled) {
+      break ancestor_packages;
+    }
+    const ancestorPackages = [];
+    const cwd = cwdPath || process.cwd();
+    const cwdUrl = ensurePathnameTrailingSlash(pathToFileURL(cwd));
+    let currentUrl = cwdUrl;
+    while (currentUrl.href !== ancestorPackagesRootDirectoryUrl) {
+      const packageFileUrl = new URL("package.json", currentUrl);
+      const packageDirectoryUrl = currentUrl;
+      currentUrl = new URL(getParentUrl(currentUrl));
+      let packageFileContent;
+      try {
+        packageFileContent = readFileSync(packageFileUrl);
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          continue;
+        }
+        throw e;
+      }
+      let packageObject;
+      try {
+        packageObject = JSON.parse(packageFileContent);
+      } catch (e) {
+        continue;
+      }
+      const packageName = packageObject.name;
+      ancestorPackages.unshift({
+        packageDirectoryUrl,
+        packageName,
+      });
+    }
+    for (const ancestorPackage of ancestorPackages) {
+      addWellKnownFileUrl(
+        ancestorPackage.packageDirectoryUrl,
+        ancestorPackage.packageName,
+      );
+    }
+  }
+  home_dir: {
+    if (!homedirDisabled) {
+      const homedirPath = homedir();
+      const homedirUrl = pathToFileURL(homedirPath);
+      addWellKnownFileUrl(homedirUrl, "file:///~");
+    }
   }
-  if (rootDirectoryPath === undefined) {
-    rootDirectoryPath = fileURLToPath(rootDirectoryUrl);
+  process_cwd: {
+    // we fallback on process.cwd()
+    // but it's brittle because a file might be execute from anywhere
+    // so it should be the last resort
+    cwdUrl = cwdUrl || pathToFileURL(cwdPath);
+    addWellKnownFileUrl(cwdUrl, "file:///cwd()");
   }
   const replaceFileUrls = (value) => {
-    return value.replaceAll(rootDirectoryUrl, "file:///cwd()");
+    for (const wellKownUrl of wellKownUrlArray) {
+      const replaceResult = wellKownUrl.replace(value);
+      if (replaceResult !== value) {
+        return replaceResult;
+      }
+    }
+    return value;
   };
-  const replaceFilePaths = isWindows
-    ? (value) => {
-        const windowPathRegex = new RegExp(
-          `${escapeRegexpSpecialChars(rootDirectoryPath)}(((?:\\\\(?:[\\w !#()-]+|[.]{1,2})+)*)(?:\\\\)?)`,
-          "gm",
-        );
-        return value.replaceAll(windowPathRegex, (match, afterCwd) => {
-          return `cwd()${afterCwd.replaceAll("\\", "/")}`;
-        });
+  const replaceFilePaths = (value) => {
+    for (const wellKownPath of wellKnownPathArray) {
+      const replaceResult = wellKownPath.replace(value);
+      if (replaceResult !== value) {
+        return replaceResult;
       }
-    : (value) => {
-        return value.replaceAll(rootDirectoryPath, "cwd()");
-      };
+    }
+    return value;
+  };
   const replaceThings = (value) => {
     if (removeAnsi) {
       value = stripAnsi(value);
@@ -100,6 +204,27 @@ export const replaceFluctuatingValues = (
   return replaceThings(string);
 };
 
+const getParentUrl = (url) => {
+  url = String(url);
+  // With node.js new URL('../', 'file:///C:/').href
+  // returns "file:///C:/" instead of "file:///"
+  const resource = url.slice("file://".length);
+  const slashLastIndex = resource.lastIndexOf("/");
+  if (slashLastIndex === -1) {
+    return url;
+  }
+  const lastCharIndex = resource.length - 1;
+  if (slashLastIndex === lastCharIndex) {
+    const slashBeforeLastIndex = resource.lastIndexOf("/", slashLastIndex - 1);
+    if (slashBeforeLastIndex === -1) {
+      return url;
+    }
+    return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
+  }
+
+  return `file://${resource.slice(0, slashLastIndex + 1)}`;
+};
+
 const replaceHttpUrls = (source) => {
   return source.replace(/(?:https?|ftp):\/\/\S+[\w/]/g, (match) => {
     const lastChar = match[match.length - 1];