dependency-cruiser 12.4.0 → 12.5.0-beta-2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "12.4.0",
+  "version": "12.5.0-beta-2",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",

package/src/cache/cache.js

@@ -2,73 +2,86 @@ const { readFileSync, mkdirSync, writeFileSync } = require("fs");
 const { join } = require("path");
 const meta = require("../extract/transpile/meta");
 const { optionsAreCompatible } = require("./options-compatible");
-const { getRevisionData, revisionDataEqual } = require("./git-revision-data");
+const metadataStrategy = require("./metadata-strategy");
+const contentStrategy = require("./content-strategy");
 
 const CACHE_FILE_NAME = "cache.json";
-let gRevisionData = null;
 
-/**
- * @param {string} pCacheFolder
- * @param {import("../..").ICruiseResult} pCruiseResult
- * @param {import("../..").IRevisionData=} pRevisionData
- */
-function writeCache(pCacheFolder, pCruiseResult, pRevisionData) {
-  const lRevisionData = pRevisionData ?? gRevisionData;
-
-  mkdirSync(pCacheFolder, { recursive: true });
-  writeFileSync(
-    join(pCacheFolder, CACHE_FILE_NAME),
-    JSON.stringify(
-      lRevisionData
-        ? {
-            ...pCruiseResult,
-            revisionData: lRevisionData,
-          }
-        : pCruiseResult
-    ),
-    "utf8"
-  );
-}
+module.exports = class Cache {
+  /**
+   * @param {import("../../types/cache-options").cacheStrategyType=} pCacheStrategy
+   */
+  constructor(pCacheStrategy) {
+    this.revisionData = null;
+    this.cacheStrategy =
+      pCacheStrategy === "content" ? contentStrategy : metadataStrategy;
+  }
 
-/**
- * @param {string} pCacheFolder
- * @returns {import("../..").ICruiseResult}
- */
-function readCache(pCacheFolder) {
-  try {
-    return JSON.parse(
-      readFileSync(join(pCacheFolder, CACHE_FILE_NAME), "utf8")
+  /**
+   * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
+   * @param {import("../..").ICruiseResult} pCachedCruiseResult
+   * @param {import("../..").IRevisionData=} pRevisionData
+   * @returns {boolean}
+   */
+  canServeFromCache(pCruiseOptions, pCachedCruiseResult, pRevisionData) {
+    this.revisionData =
+      pRevisionData ??
+      this.cacheStrategy.getRevisionData(
+        ".",
+        pCachedCruiseResult,
+        pCruiseOptions,
+        {
+          extensions: new Set(
+            meta.scannableExtensions.concat(
+              pCruiseOptions.extraExtensionsToScan
+            )
+          ),
+        }
+      );
+    return (
+      this.cacheStrategy.revisionDataEqual(
+        pCachedCruiseResult.revisionData,
+        this.revisionData
+      ) &&
+      optionsAreCompatible(
+        pCachedCruiseResult.summary.optionsUsed,
+        pCruiseOptions
+      )
     );
-  } catch (pError) {
-    return { modules: [], summary: {} };
   }
-}
 
-/**
- * @param {import("../../types/strict-options").IStrictCruiseOptions} pOptions
- * @param {import("../..").ICruiseResult} pCachedCruiseResult
- * @param {import("../..").IRevisionData=} pRevisionData
- * @returns {boolean}
- */
-function canServeFromCache(pOptions, pCachedCruiseResult, pRevisionData) {
-  gRevisionData =
-    pRevisionData ??
-    getRevisionData(
-      new Set(meta.scannableExtensions.concat(pOptions.extraExtensionsToScan))
-    );
-  return (
-    revisionDataEqual(pCachedCruiseResult.revisionData, gRevisionData) &&
-    optionsAreCompatible(pCachedCruiseResult.summary.optionsUsed, pOptions)
-  );
-}
+  /**
+   * @param {string} pCacheFolder
+   * @returns {import("../..").ICruiseResult}
+   */
+  read(pCacheFolder) {
+    try {
+      return JSON.parse(
+        readFileSync(join(pCacheFolder, CACHE_FILE_NAME), "utf8")
+      );
+    } catch (pError) {
+      return { modules: [], summary: {} };
+    }
+  }
 
-function clearCache() {
-  gRevisionData = null;
-}
+  /**
+   * @param {string} pCacheFolder
+   * @param {import("../..").ICruiseResult} pCruiseResult
+   * @param {import("../..").IRevisionData=} pRevisionData
+   */
+  write(pCacheFolder, pCruiseResult, pRevisionData) {
+    const lRevisionData = pRevisionData ?? this.revisionData;
 
-module.exports = {
-  writeCache,
-  readCache,
-  canServeFromCache,
-  clearCache,
+    mkdirSync(pCacheFolder, { recursive: true });
+    writeFileSync(
+      join(pCacheFolder, CACHE_FILE_NAME),
+      JSON.stringify(
+        this.cacheStrategy.prepareRevisionDataForSaving(
+          pCruiseResult,
+          lRevisionData
+        )
+      ),
+      "utf8"
+    );
+  }
 };

package/src/cache/content-strategy.js

@@ -0,0 +1,215 @@
+const { isDeepStrictEqual } = require("util");
+const bus = require("../utl/bus");
+const { DEBUG } = require("../utl/bus-log-levels");
+const findAllFiles = require("../utl/find-all-files");
+const {
+  getFileHash,
+  excludeFilter,
+  includeOnlyFilter,
+  isInterestingChangeType,
+  hasInterestingExtension,
+  addCheckSumToChange,
+} = require("./utl");
+
+/**
+ * @param {Set<string>} pFileSet
+ * @param {typeof getFileHash} pFileHashFunction
+ * @returns {import('../..').IRevisionChange}
+ */
+function diffCachedModuleAgainstFileSet(
+  pFileSet,
+  pFileHashFunction = getFileHash
+) {
+  // eslint-disable-next-line complexity
+  return (pModule) => {
+    if (
+      !pModule.consolidated &&
+      !pModule.coreModule &&
+      !pModule.couldNotResolve &&
+      !pModule.matchesDoNotFollow
+    ) {
+      if (!pFileSet.has(pModule.source)) {
+        return { name: pModule.source, changeType: "deleted" };
+      }
+      const lNewCheckSum = pFileHashFunction(pModule.source);
+      if (lNewCheckSum !== pModule.checksum) {
+        return {
+          name: pModule.source,
+          changeType: "modified",
+          checksum: lNewCheckSum,
+        };
+      }
+    }
+    return {
+      name: pModule.source,
+      changeType: "unmodified",
+      checksum: pModule.checksum,
+    };
+  };
+}
+
+/**
+  We can run into these scenarios:
+  - there is no cache yet:
+    modules will === []; all files will be marked as 'added'
+  - there is a cache and it contains checksums:
+    - existing files that are not in the cache => added
+    - modules that are in the cache:
+      - don't exist anymore => deleted TODO: 
+        we might wrongly bump into this for files that are gitignored and that don't have an interesting extension
+      - cached checksum === current checksum => not a change; left out
+      - cached checksum !== current checksum => modified
+  - there is a cache, but it doesn't contain checksums => same as before, except
+    all files will be marked as 'modified'
+ * @param {string} pDirectory
+ * @param {import("../..").ICruiseResult} pCachedCruiseResult
+ * @param {Object} pOptions
+ * @param {Set<string>} pOptions.extensions
+ * @param {string} pOptions.baseDir
+ * @returns {{source: string; changeType: import("watskeburt").changeTypeType; checksum: string}[]}
+ */
+function findChanges(pDirectory, pCachedCruiseResult, pOptions) {
+  bus.emit("progress", "cache: - hauling revision data", { level: DEBUG });
+  const lFileSet = new Set(
+    findAllFiles(pDirectory, {
+      baseDir: pOptions.baseDir,
+    })
+      .filter(excludeFilter(pOptions.exclude))
+      .filter(includeOnlyFilter(pOptions.includeOnly))
+  );
+
+  bus.emit("progress", "cache: - determining cached vs new", { level: DEBUG });
+  const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
+    diffCachedModuleAgainstFileSet(lFileSet)
+  );
+
+  bus.emit("progress", "cache: - determining new vs cached", { level: DEBUG });
+  lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
+
+  const lDiffNewVsCached = [];
+  for (let lFileName of lFileSet) {
+    lDiffNewVsCached.push({
+      name: lFileName,
+      changeType: "added",
+      checksum: getFileHash(lFileName),
+    });
+  }
+
+  bus.emit("progress", "cache: - returning revision data", { level: DEBUG });
+  return lDiffCachedVsNew
+    .concat(lDiffNewVsCached)
+    .filter(hasInterestingExtension(pOptions.extensions));
+}
+
+/**
+ *
+ * @param {string} pDirectory
+ * @param {import("../..").ICruiseResult} pCachedCruiseResult
+ * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
+ * @param {Object} pOptions
+ * @param {Set<string>} pOptions.extensions
+ * @param {Set<import("watskeburt").changeTypeType>} pOptions.interestingChangeTypes
+ * @param {string} pOptions.baseDir
+ * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
+ * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
+ * @returns {import("../..").IRevisionData}
+ */
+function getRevisionData(
+  pDirectory,
+  pCachedCruiseResult,
+  pCruiseOptions,
+  pOptions
+) {
+  const lOptions = {
+    diffListFn: findChanges,
+    checksumFn: addCheckSumToChange,
+    baseDir: process.cwd(),
+    ...pOptions,
+  };
+  return {
+    SHA1: "unknown-in-content-cache-strategy",
+    changes: lOptions
+      .diffListFn(pDirectory, pCachedCruiseResult, {
+        baseDir: lOptions.baseDir,
+        extensions: lOptions.extensions,
+        includeOnly: pCruiseOptions.includeOnly,
+        exclude: pCruiseOptions.exclude,
+      })
+      .filter(isInterestingChangeType(lOptions.interestingChangeTypes)),
+  };
+}
+
+/**
+ * @param {import("../..").IRevisionData} pExistingRevisionData
+ * @param {import("../..").IRevisionData} pNewRevisionData
+ * @returns {boolean}
+ */
+function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
+  return (
+    Boolean(pExistingRevisionData) &&
+    Boolean(pNewRevisionData) &&
+    isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
+  );
+}
+
+/**
+ * @param {import("../..").IModule} pModule
+ * @param {import("../..").IRevisionChange}
+ */
+function addCheckSumToModule(pModule) {
+  if (
+    !pModule.consolidated &&
+    !pModule.coreModule &&
+    !pModule.couldNotResolve &&
+    !pModule.matchesDoNotFollow
+  ) {
+    return {
+      ...pModule,
+      checksum: getFileHash(pModule.source),
+    };
+  }
+  return pModule;
+}
+
+/**
+ * @param {import("../..").IRevisionChange[]} pChanges
+ * @param {import("../..").IModule[]} pModules
+ * @returns {import("../..").IRevisionChange[]}
+ */
+function refreshChanges(pChanges, pModules) {
+  return pChanges.filter(
+    (pChange) =>
+      !pModules.some(
+        (pModule) =>
+          pModule.source === pChange.name &&
+          pModule.checksum === pChange.checksum
+      )
+  );
+}
+
+/**
+ * @param {import("../..").ICruiseResult} pCruiseResult
+ * @param {import("../..").IRevisionData} pRevisionData
+ * @returns {import("../..").ICruiseResult}
+ */
+function prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+  const lModulesWithCheckSum = pCruiseResult.modules.map(addCheckSumToModule);
+  const lRevisionData = {
+    ...pRevisionData,
+    changes: refreshChanges(pRevisionData.changes, lModulesWithCheckSum),
+  };
+
+  return pRevisionData
+    ? {
+        ...pCruiseResult,
+        modules: lModulesWithCheckSum,
+        revisionData: lRevisionData,
+      }
+    : pCruiseResult;
+}
+
+module.exports = {
+  getRevisionData,
+  revisionDataEqual,
+  prepareRevisionDataForSaving,
+};

package/src/cache/metadata-strategy.js

@@ -0,0 +1,90 @@
+const { isDeepStrictEqual } = require("util");
+const { getSHASync, listSync } = require("watskeburt");
+const {
+  isInterestingChangeType,
+  addCheckSumToChange,
+  excludeFilter,
+  includeOnlyFilter,
+  hasInterestingExtension,
+} = require("./utl");
+
+/**
+ * @param {Set<string>} pExtensions
+ * @param {Set<import("watskeburt").changeTypeType>} pInterestingChangeTypes
+ * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
+ * @param {Object} pOptions
+ * @param {Set<string>} pOptions.extensions
+ * @param {Set<import("watskeburt").changeTypeType>} pOptions.interestingChangeTypes
+ * @param {() => string} pOptions.shaRetrievalFn
+ * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
+ * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
+ * @returns {import("../..").IRevisionData}
+ */
+function getRevisionData(
+  pDirectory,
+  pCachedCruiseResult,
+  pCruiseOptions,
+  pOptions
+) {
+  const lOptions = {
+    shaRetrievalFn: getSHASync,
+    diffListFn: listSync,
+    checksumFn: addCheckSumToChange,
+    ...pOptions,
+  };
+  try {
+    const lSHA = lOptions.shaRetrievalFn();
+    return {
+      SHA1: lSHA,
+      changes: lOptions
+        .diffListFn(lSHA)
+        .filter(({ name }) => excludeFilter(pCruiseOptions.exclude)(name))
+        .filter(({ name }) =>
+          includeOnlyFilter(pCruiseOptions.includeOnly)(name)
+        )
+        .filter(hasInterestingExtension(lOptions.extensions))
+        .filter(isInterestingChangeType(lOptions.interestingChangeTypes))
+        .map(lOptions.checksumFn),
+    };
+  } catch (pError) {
+    throw new Error(
+      "The --cache option works in concert with git - and it seems either the " +
+        "current folder isn't version managed or git isn't installed. Error:" +
+        `\n\n          ${pError}\n`
+    );
+  }
+}
+
+/**
+ * @param {import("../..").IRevisionData} pExistingRevisionData
+ * @param {import("../..").IRevisionData} pNewRevisionData
+ * @returns {boolean}
+ */
+function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
+  return (
+    Boolean(pExistingRevisionData) &&
+    Boolean(pNewRevisionData) &&
+    pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
+    isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
+  );
+}
+
+/**
+ * @param {import("../..").ICruiseResult} pCruiseResult
+ * @param {import("../..").IRevisionData} pRevisionData
+ * @returns {import("../..").ICruiseResult}
+ */
+function prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+  return pRevisionData
+    ? {
+        ...pCruiseResult,
+        revisionData: pRevisionData,
+      }
+    : pCruiseResult;
+}
+
+module.exports = {
+  getRevisionData,
+  revisionDataEqual,
+  prepareRevisionDataForSaving,
+};

package/src/cache/options-compatible.js

@@ -6,7 +6,7 @@ const { isDeepStrictEqual } = require("util");
   -i, --info                  
   -V, --version               
   -h, --help         
-  -T, --output-type <type>    unless counting implicit shizzle like dependendents, metrics calculation
+  -T, --output-type <type>    unless counting implicit shizzle like dependents, metrics calculation
   -f, --output-to <file>      
   -p, --progress [type]       
   -P, --prefix <prefix>       
@@ -123,9 +123,9 @@ function optionsAreCompatible(pOldOptions, pNewOptions) {
 
 module.exports = {
   optionsAreCompatible,
-  filtersAreCompatible: optionIsCompatible,
-  limitsAreCompatible: limitIsCompatible,
-  metricsAreCompatible: metricsIsCompatible,
-  includeOnlyFiltersAreCompatible: includeOnlyIsCompatible,
+  optionIsCompatible,
+  limitIsCompatible,
+  metricsIsCompatible,
+  includeOnlyIsCompatible,
   cacheOptionIsCompatible,
 };

package/src/cache/utl.js

@@ -1,5 +1,8 @@
 const { createHash } = require("crypto");
 const { readFileSync } = require("fs");
+const path = require("path");
+const memoize = require("lodash/memoize");
+const { filenameMatchesPattern } = require("../graph-utl/match-facade");
 
 /**
  * @param {string} pString
@@ -13,7 +16,7 @@ function hash(pString) {
  * @param {import("fs").PathOrFileDescriptor} pFileName
  * @returns {string}
  */
-function getFileHash(pFileName) {
+function _getFileHash(pFileName) {
   try {
     return hash(readFileSync(pFileName, "utf8"));
   } catch (pError) {
@@ -21,4 +24,84 @@ function getFileHash(pFileName) {
   }
 }
 
-module.exports = { getFileHash };
+const getFileHash = memoize(_getFileHash);
+
+/**
+ * @param {import("watskeburt").IChange} pChange
+ * @param {import("../..").IRevisionChange}
+ */
+function addCheckSumToChange(pChange) {
+  return {
+    ...pChange,
+    checksum: getFileHash(pChange.name),
+  };
+}
+
+/**
+ *
+ * @param {import("../../types/strict-filter-types").IStrictExcludeType} pExcludeOption
+ * @returns {(pFileName: string) => boolean}
+ */
+function excludeFilter(pExcludeOption) {
+  return (pFileName) => {
+    if (pExcludeOption.path) {
+      return !filenameMatchesPattern(pFileName, pExcludeOption.path);
+    }
+    return true;
+  };
+}
+
+/**
+ * @param {import("../../types/strict-filter-types").IStrictIncludeOnlyType} pIncludeOnlyFilter
+ * @returns {(pFileName: string) => boolean}
+ */
+function includeOnlyFilter(pIncludeOnlyFilter) {
+  return (pFileName) => {
+    if (pIncludeOnlyFilter) {
+      return filenameMatchesPattern(pFileName, pIncludeOnlyFilter.path);
+    }
+    return true;
+  };
+}
+
+/**
+ * @param {Set<string>} pExtensions
+ * @returns {(pChange: import("watskeburt").IChange) => boolean}
+ */
+function hasInterestingExtension(pExtensions) {
+  return (pChange) =>
+    pExtensions.has(path.extname(pChange.name)) ||
+    (pChange.oldName && pExtensions.has(path.extname(pChange.oldName)));
+}
+
+// skipping: "pairing broken", "unmodified", "unmerged", "type changed"
+const DEFAULT_INTERESTING_CHANGE_TYPES = new Set([
+  "added",
+  "copied",
+  "deleted",
+  "ignored",
+  "modified",
+  "renamed",
+  "unmerged",
+  "untracked",
+]);
+
+/**
+ * @param {Set<import("watskeburt").changeTypeType>} pInterestingChangeTypes
+ * @returns {(pChange: import("watskeburt").IChange) => boolean}
+ */
+function isInterestingChangeType(pInterestingChangeTypes) {
+  return (pChange) =>
+    (pInterestingChangeTypes ?? DEFAULT_INTERESTING_CHANGE_TYPES).has(
+      pChange.changeType
+    );
+}
+
+module.exports = {
+  getFileHash,
+  excludeFilter,
+  includeOnlyFilter,
+  hasInterestingExtension,
+  isInterestingChangeType,
+  addCheckSumToChange,
+};

package/src/main/index.js

@@ -6,12 +6,7 @@ const enrich = require("../enrich");
 const cruiseResultSchema = require("../schema/cruise-result.schema.js");
 const meta = require("../extract/transpile/meta");
 const bus = require("../utl/bus");
-const {
-  canServeFromCache,
-  readCache,
-  writeCache,
-  clearCache,
-} = require("../cache/cache");
+const Cache = require("../cache/cache");
 const normalizeFilesAndDirectories = require("./files-and-dirs/normalize");
 const validateRuleSet = require("./rule-set/validate");
 const normalizeRuleSet = require("./rule-set/normalize");
@@ -65,13 +60,15 @@ function futureCruise(
     validateCruiseOptions(pCruiseOptions),
     pFileAndDirectoryArray
   );
+  let lCache = null;
 
   if (lCruiseOptions.cache) {
     bus.emit("progress", "cache: checking freshness", c(2));
 
-    const lCachedResults = readCache(lCruiseOptions.cache.folder);
+    lCache = new Cache(lCruiseOptions?.cache.strategy);
+    const lCachedResults = lCache.read(lCruiseOptions.cache.folder);
 
-    if (canServeFromCache(lCruiseOptions, lCachedResults)) {
+    if (lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
       bus.emit("progress", "cache: reporting from cache", c(8));
       return reportWrap(lCachedResults, lCruiseOptions);
     }
@@ -112,8 +109,7 @@ function futureCruise(
 
   if (lCruiseOptions.cache) {
     bus.emit("progress", "cache: saving", c(7));
-    writeCache(lCruiseOptions.cache.folder, lCruiseResult);
-    clearCache();
+    lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
   }
 
   bus.emit("progress", "reporting", c(8));

package/src/meta.js

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "12.4.0",
+  version: "12.5.0-beta-2",
   engines: {
     node: "^14||^16||>=18",
   },

package/types/cache-options.d.ts

@@ -12,9 +12,9 @@ export interface ICacheOptions {
    * - 'metadata': use git metadata to detect changes;
    * - 'content': use (a checksum of) the contents of files to detect changes.
    *
-   * The last one is useful if you're not on git or work on partial clones
-   * (which is typical on CI's). Trade-of: might be a bit slower, will not
-   * detect changes on files that are entirely new.
+   * 'content'is useful if you're not on git or work on partial clones
+   * (which is typical on CI's). Trade-of: the 'content' strategy is typically
+   * slower.
    *
    * Defaults to 'metadata'
    */

package/src/cache/git-revision-data.js

@@ -1,106 +0,0 @@
-const { extname } = require("path");
-const { isDeepStrictEqual } = require("util");
-const { getSHASync, listSync } = require("watskeburt");
-const { getFileHash } = require("./utl");
-
-// skipping: "pairing broken", "unmodified", "unmerged", "type changed"
-const DEFAULT_INTERESTING_CHANGE_TYPES = new Set([
-  "added",
-  "copied",
-  "deleted",
-  "ignored",
-  "modified",
-  "renamed",
-  "unmerged",
-  "untracked",
-]);
-
-/**
- *
- * @param {Set<string>} pExtensions
- * @returns {(pChange: import("watskeburt").IChange) => boolean}
- */
-function hasInterestingExtension(pExtensions) {
-  return (pChange) =>
-    pExtensions.has(extname(pChange.name)) ||
-    (pChange.oldName && pExtensions.has(extname(pChange.oldName)));
-}
-
-/**
- *
- * @param {Set<import("watskeburt").changeTypeType>} pInterestingChangeTypes
- * @returns {(pChange: import("watskeburt").IChange) => boolean}
- */
-function isInterestingChangeType(pInterestingChangeTypes) {
-  return (pChange) => pInterestingChangeTypes.has(pChange.changeType);
-}
-
-/**
- * @param {import("watskeburt").IChange} pChange
- * @param {import("../../types/dependency-cruiser").IRevisionChange}
- */
-function addChecksum(pChange) {
-  return {
-    ...pChange,
-    checksum: getFileHash(pChange.name),
-  };
-}
-
-/**
- *
- * @param {Set<string>} pExtensions
- * @param {Set<import("watskeburt").changeTypeType>} pInterestingChangeTypes
- * @param {Object} pOptions
- * @param {() => string} pOptions.shaRetrievalFn
- * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
- * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checkSumFn
- * @returns {import("../../types/dependency-cruiser").IRevisionData}
- */
-function getRevisionData(
-  pExtensions,
-  pInterestingChangeTypes = DEFAULT_INTERESTING_CHANGE_TYPES,
-  pOptions
-) {
-  const lOptions = {
-    shaRetrievalFn: getSHASync,
-    diffListFn: listSync,
-    checkSumFn: addChecksum,
-    ...pOptions,
-  };
-  try {
-    const lSHA = lOptions.shaRetrievalFn();
-    return {
-      SHA1: lSHA,
-      changes: lOptions
-        .diffListFn(lSHA)
-        .filter(hasInterestingExtension(pExtensions))
-        .filter(isInterestingChangeType(pInterestingChangeTypes))
-        .map(lOptions.checkSumFn),
-    };
-  } catch (pError) {
-    throw new Error(
-      "The --cache option works in concert with git - and it seems either the " +
-        "current folder isn't version managed or git isn't installed. Error:" +
-        `\n\n          ${pError}\n`
-    );
-  }
-}
-
-/**
- * @param {import("../../types/dependency-cruiser").IRevisionData} pExistingRevisionData
- * @param {import("../../types/dependency-cruiser").IRevisionData} pNewRevisionData
- * @returns {boolean}
- */
-function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
-  return (
-    Boolean(pExistingRevisionData) &&
-    Boolean(pNewRevisionData) &&
-    pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
-    isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
-  );
-}
-
-module.exports = {
-  getRevisionData,
-  revisionDataEqual,
-};