dependency-cruiser 12.3.0 → 12.5.0-beta-1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2022 Sander Verweij
+Copyright (c) 2016-2023 Sander Verweij
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "12.3.0",
+  "version": "12.5.0-beta-1",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",
@@ -122,7 +122,7 @@
     "test:i": "LANG=en_US.UTF-8 mocha --grep \"^\\[[I]\\]\"",
     "test:u": "LANG=en_US.UTF-8 mocha --grep \"^\\[[U]\\]\"",
     "test:e": "LANG=en_US.UTF-8 mocha --grep \"^\\[[E]\\]\"",
-    "test:cover": "LANG=en_US.UTF-8 c8 --check-coverage --statements 99.9 --branches 99.7 --functions 100 --lines 99.9 --exclude \"{bin,configs/*.js,configs/rules,configs/plugins/3d-*.js,configs/plugins/stats-*.js,doc,docs,coverage,test,tools,webpack.conf.js,tmp*,src/**/*.template.js,src/cli/tools/svg-in-html-snippets/script.snippet.js,src/cli/init-config/get-user-input.js,src/cli/listeners/*/index.js}\" --reporter text-summary --reporter html --reporter json-summary mocha",
+    "test:cover": "LANG=en_US.UTF-8 c8 --check-coverage --statements 99.9 --branches 99.7 --functions 100 --lines 99.9 --exclude \"{bin,configs/*.js,configs/rules,configs/plugins/3d-*.js,configs/plugins/stats-*.js,doc,docs,coverage,test,tools,webpack.conf.js,tmp*,src/**/*.template.js,src/cli/tools/svg-in-html-snippets/script.snippet.js,src/cli/init-config/get-user-input.js,src/cli/listeners/*/index.js,src/cli/listeners/cli-feedback.js}\" --reporter text-summary --reporter html --reporter json-summary mocha",
     "test:glob": "set -f && test \"`bin/dependency-cruise.js test/extract/__mocks__/gather-globbing/packages/**/src/**/*.js | grep \"no dependency violations found\"`\" = \"✔ no dependency violations found (6 modules, 0 dependencies cruised)\"",
     "test:yarn-pnp": "npm-run-all test:yarn-pnp:cleanup test:yarn-pnp:pack test:yarn-pnp:copy test:yarn-pnp:install test:yarn-pnp:version test:yarn-pnp:run test:yarn-pnp:test test:yarn-pnp:cleanup",
     "test:yarn-pnp:pack": "npm pack",
@@ -147,18 +147,19 @@
     "acorn-jsx-walk": "2.0.0",
     "acorn-loose": "8.3.0",
     "acorn-walk": "8.2.0",
-    "ajv": "8.11.2",
+    "ajv": "8.12.0",
     "chalk": "^4.1.2",
-    "commander": "9.4.1",
+    "commander": "9.5.0",
     "enhanced-resolve": "5.12.0",
     "figures": "^3.2.0",
     "get-stream": "^6.0.1",
     "glob": "7.2.0",
     "handlebars": "4.7.7",
+    "ignore": "5.2.4",
     "indent-string": "^4.0.0",
     "interpret": "^3.1.0",
     "is-installed-globally": "0.4.0",
-    "json5": "2.2.2",
+    "json5": "2.2.3",
     "lodash": "4.17.21",
     "prompts": "2.4.2",
     "rechoir": "^0.8.0",
@@ -171,23 +172,23 @@
     "wrap-ansi": "^7.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.20.7",
+    "@babel/core": "7.20.12",
     "@babel/plugin-transform-modules-commonjs": "7.20.11",
     "@babel/preset-typescript": "7.18.6",
-    "@swc/core": "1.3.24",
+    "@swc/core": "1.3.25",
     "@types/lodash": "4.14.191",
     "@types/node": "18.11.18",
     "@types/prompts": "2.4.2",
-    "@typescript-eslint/eslint-plugin": "5.47.1",
-    "@typescript-eslint/parser": "5.47.1",
+    "@typescript-eslint/eslint-plugin": "5.48.0",
+    "@typescript-eslint/parser": "5.48.0",
     "@vue/compiler-sfc": "3.2.45",
     "c8": "7.12.0",
     "chai": "4.3.7",
     "chai-json-schema": "1.5.1",
     "coffeescript": "2.7.0",
-    "eslint": "8.30.0",
+    "eslint": "8.31.0",
     "eslint-config-moving-meadow": "4.0.2",
-    "eslint-config-prettier": "8.5.0",
+    "eslint-config-prettier": "8.6.0",
     "eslint-plugin-budapestian": "5.0.1",
     "eslint-plugin-eslint-comments": "3.2.0",
     "eslint-plugin-import": "2.26.0",
@@ -195,13 +196,13 @@
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-security": "1.5.0",
     "eslint-plugin-unicorn": "^45.0.0",
-    "husky": "8.0.2",
+    "husky": "8.0.3",
     "intercept-stdout": "0.1.2",
     "lint-staged": "13.1.0",
     "mocha": "10.2.0",
     "normalize-newline": "^3.0.0",
     "npm-run-all": "4.1.5",
-    "prettier": "2.8.1",
+    "prettier": "2.8.2",
     "proxyquire": "2.1.3",
     "shx": "0.3.4",
     "svelte": "3.55.0",

package/src/cache/cache.js

@@ -1,56 +1,87 @@
 const { readFileSync, mkdirSync, writeFileSync } = require("fs");
 const { join } = require("path");
+const meta = require("../extract/transpile/meta");
 const { optionsAreCompatible } = require("./options-compatible");
-const { revisionDataEqual } = require("./revision-data");
+const metadataStrategy = require("./metadata-strategy");
+const contentStrategy = require("./content-strategy");
 
 const CACHE_FILE_NAME = "cache.json";
-/**
- *
- * @param {string} pCacheFolder
- * @param {import("../../types/cruise-result").ICruiseResult} pCruiseResult
- */
-function writeCache(pCacheFolder, pCruiseResult) {
-  mkdirSync(pCacheFolder, { recursive: true });
-  writeFileSync(
-    join(pCacheFolder, CACHE_FILE_NAME),
-    JSON.stringify(pCruiseResult),
-    "utf8"
-  );
-}
 
-/**
- *
- * @param {string} pCacheFolder
- * @returns {import("../..").ICruiseResult}
- */
-function readCache(pCacheFolder) {
-  try {
-    return JSON.parse(
-      readFileSync(join(pCacheFolder, CACHE_FILE_NAME), "utf8")
+module.exports = class Cache {
+  /**
+   * @param {import("../../types/cache-options").cacheStrategyType=} pCacheStrategy
+   */
+  constructor(pCacheStrategy) {
+    this.revisionData = null;
+    this.cacheStrategy =
+      pCacheStrategy === "content" ? contentStrategy : metadataStrategy;
+  }
+
+  /**
+   * @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("../..").IRevisionData} pRevisionData
- * @returns {boolean}
- */
-function canServeFromCache(pOptions, pRevisionData) {
-  /** @type {import("../..").ICruiseResult} */
-  const lCachedResults = readCache(pOptions.cache);
+  /**
+   * @param {string} pCacheFolder
+   * @returns {import("../..").ICruiseResult}
+   */
+  read(pCacheFolder) {
+    try {
+      return JSON.parse(
+        readFileSync(join(pCacheFolder, CACHE_FILE_NAME), "utf8")
+      );
+    } catch (pError) {
+      return { modules: [], summary: {} };
+    }
+  }
 
-  return (
-    revisionDataEqual(lCachedResults.revisionData, pRevisionData) &&
-    optionsAreCompatible(lCachedResults.summary.optionsUsed, pOptions)
-  );
-}
+  /**
+   * @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,
+    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,265 @@
+const path = require("path");
+const { isDeepStrictEqual } = require("util");
+const { filenameMatchesPattern } = require("../graph-utl/match-facade");
+const bus = require("../utl/bus");
+const { DEBUG } = require("../utl/bus-log-levels");
+const findAllFiles = require("../utl/find-all-files");
+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(path.extname(pChange.name));
+}
+
+/**
+ * @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("../..").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;
+  };
+}
+
+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,
+    };
+  };
+}
+
+/**
+  - 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,
+    interestingChangeTypes: DEFAULT_INTERESTING_CHANGE_TYPES,
+    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
+      )
+  );
+}
+
+function prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+  const lModules = pCruiseResult.modules.map(addCheckSumToModule);
+  const lRevisionData = {
+    ...pRevisionData,
+    changes: refreshChanges(pRevisionData.changes, lModules),
+  };
+
+  return pRevisionData
+    ? {
+        ...pCruiseResult,
+        modules: lModules,
+        revisionData: lRevisionData,
+      }
+    : pCruiseResult;
+}
+
+module.exports = {
+  getRevisionData,
+  revisionDataEqual,
+  prepareRevisionDataForSaving,
+};

package/src/cache/{revision-data.js → metadata-strategy.js}

@@ -1,8 +1,7 @@
-const { createHash } = require("crypto");
-const { readFileSync } = require("fs");
 const { extname } = require("path");
+const { isDeepStrictEqual } = require("util");
 const { getSHASync, listSync } = require("watskeburt");
-const { objectsAreEqual } = require("./utl");
+const { getFileHash } = require("./utl");
 
 // skipping: "pairing broken", "unmodified", "unmerged", "type changed"
 const DEFAULT_INTERESTING_CHANGE_TYPES = new Set([
@@ -17,7 +16,6 @@ const DEFAULT_INTERESTING_CHANGE_TYPES = new Set([
 ]);
 
 /**
- *
  * @param {Set<string>} pExtensions
  * @returns {(pChange: import("watskeburt").IChange) => boolean}
  */
@@ -36,34 +34,14 @@ function isInterestingChangeType(pInterestingChangeTypes) {
   return (pChange) => pInterestingChangeTypes.has(pChange.changeType);
 }
 
-/**
- * @param {string} pString
- * @returns {string}
- */
-function hash(pString) {
-  return createHash("sha1").update(pString).digest("base64");
-}
-
-/**
- * @param {import("fs").PathOrFileDescriptor} pFileName
- * @returns {string}
- */
-function getFileHash(pFileName) {
-  try {
-    return hash(readFileSync(pFileName, "utf8"));
-  } catch (pError) {
-    return "file not found";
-  }
-}
-
 /**
  * @param {import("watskeburt").IChange} pChange
- * @param {import("../..").IRevisionChange}
+ * @param {import("../../types/dependency-cruiser").IRevisionChange}
  */
 function addChecksum(pChange) {
   return {
     ...pChange,
-    checksum: getFileHash(pChange.name),
+    checkSum: getFileHash(pChange.name),
   };
 }
 
@@ -71,21 +49,26 @@ function addChecksum(pChange) {
  *
  * @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}
+ * @returns {import("../../types/dependency-cruiser").IRevisionData}
  */
 function getRevisionData(
-  pExtensions,
-  pInterestingChangeTypes = DEFAULT_INTERESTING_CHANGE_TYPES,
+  pDirectory,
+  pCachedCruiseResult,
+  pCruiseOptions,
   pOptions
 ) {
   const lOptions = {
     shaRetrievalFn: getSHASync,
     diffListFn: listSync,
     checkSumFn: addChecksum,
+    interestingChangeTypes: DEFAULT_INTERESTING_CHANGE_TYPES,
     ...pOptions,
   };
   try {
@@ -94,8 +77,9 @@ function getRevisionData(
       SHA1: lSHA,
       changes: lOptions
         .diffListFn(lSHA)
-        .filter(hasInterestingExtension(pExtensions))
-        .filter(isInterestingChangeType(pInterestingChangeTypes))
+        // TODO: optimize - also apply filters for exclude and includeOnly (see content strategy)
+        .filter(hasInterestingExtension(lOptions.extensions))
+        .filter(isInterestingChangeType(lOptions.interestingChangeTypes))
         .map(lOptions.checkSumFn),
     };
   } catch (pError) {
@@ -108,8 +92,8 @@ function getRevisionData(
 }
 
 /**
- * @param {import("../..").IRevisionData} pExistingRevisionData
- * @param {import("../..").IRevisionData} pNewRevisionData
+ * @param {import("../../types/dependency-cruiser").IRevisionData} pExistingRevisionData
+ * @param {import("../../types/dependency-cruiser").IRevisionData} pNewRevisionData
  * @returns {boolean}
  */
 function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
@@ -117,11 +101,27 @@ function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
     Boolean(pExistingRevisionData) &&
     Boolean(pNewRevisionData) &&
     pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
-    objectsAreEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
+    isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
   );
 }
 
+/**
+ *
+ * @param {import("../..").ICruiseResult} pCruiseResult
+ * @param {*} pRevisionData
+ * @returns {import("../..").ICruiseResult}
+ */
+function prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+  return pRevisionData
+    ? {
+        ...pCruiseResult,
+        revisionData: pRevisionData,
+      }
+    : pCruiseResult;
+}
+
 module.exports = {
   getRevisionData,
   revisionDataEqual,
+  prepareRevisionDataForSaving,
 };