dependency-cruiser 18.2.0-beta-2 → 18.2.0

package/package.json

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

package/src/meta.cjs

@@ -1,6 +1,6 @@
 /* generated - don't edit */
 module.exports = {
-	version: "18.2.0-beta-2",
+	version: "18.2.0",
 	engines: {
 		node: "^22||^24||>=26",
 	},

package/src/utl/find-all-files.mjs

@@ -1,5 +1,5 @@
 import { readdirSync, statSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path/posix";
 import ignore from "ignore";
 import pathToPosix from "./path-to-posix.mjs";
 
@@ -7,6 +7,10 @@ import pathToPosix from "./path-to-posix.mjs";
  * @typedef {(pString:string, pIndex: number, pArray: string[]) => boolean} FilterFunctionType
  */
 
+/**
+ * @typedef {{directoryName: string; ignoreMatcher: import("ignore").Ignore}} IgnoreRuleType
+ */
+
 /**
  * @param {string} pFullPathToFile
  * @param {string} pBaseDirectory
@@ -19,18 +23,200 @@ function fileIsDirectory(pFullPathToFile, pBaseDirectory) {
 	return lStat?.isDirectory() ?? false;
 }
 
+/**
+ * @param {string} pFileName
+ * @returns {string}
+ */
+function readIgnoreFile(pFileName) {
+	try {
+		return readFileSync(pFileName, "utf8");
+	} catch {
+		return "";
+	}
+}
+
+/**
+ * @param {string} pDirectoryName
+ * @param {string} pBaseDirectory
+ * @returns {string}
+ */
+function normalizeDirectoryName(pDirectoryName, pBaseDirectory) {
+	return pathToPosix(
+		relative(pBaseDirectory, join(pBaseDirectory, pDirectoryName)),
+	);
+}
+
+/**
+ * @param {string} pDirectoryName
+ * @param {string} pIgnoreFileContents
+ * @param {string[]=} pAdditionalIgnorePatterns
+ * @returns {IgnoreRuleType}
+ */
+function createIgnoreRule(
+	pDirectoryName,
+	pIgnoreFileContents,
+	pAdditionalIgnorePatterns = [],
+) {
+	return {
+		directoryName: pDirectoryName,
+		ignoreMatcher: ignore()
+			.add(pIgnoreFileContents)
+			.add(pAdditionalIgnorePatterns),
+	};
+}
+
 /**
  * @param {string} pDirectoryName
- * @param {{baseDir: string; ignoreFilterFn: FilterFunctionType; excludeFilterFn: FilterFunctionType; includeOnlyFilterFn: FilterFunctionType}} pOptions
+ * @param {string} pBaseDirectory
+ * @param {{ignoreFileContents?: string}} pOptions
+ * @returns {IgnoreRuleType}
+ */
+function createIgnoreRuleForDirectory(
+	pDirectoryName,
+	pBaseDirectory,
+	pOptions,
+) {
+	const lIgnoreFileContents =
+		pOptions.ignoreFileContents === undefined
+			? readIgnoreFile(join(pBaseDirectory, pDirectoryName, ".gitignore"))
+			: pOptions.ignoreFileContents;
+
+	return createIgnoreRule(pDirectoryName, lIgnoreFileContents);
+}
+
+/**
+ * @param {string[]} pAncestorDirectoryNames
+ * @param {string} pBaseDirectory
+ * @returns {IgnoreRuleType[]}
+ */
+function createIgnoreRulesFromDirectoryNames(
+	pAncestorDirectoryNames,
+	pBaseDirectory,
+) {
+	return pAncestorDirectoryNames.map((pAncestorDirectoryName) =>
+		createIgnoreRuleForDirectory(pAncestorDirectoryName, pBaseDirectory, {}),
+	);
+}
+
+/**
+ * @param {string} pDirectoryName
+ * @param {string} pBaseDirectory
+ * @returns {IgnoreRuleType[]}
+ */
+function createIgnoreRulesBeforeDirectory(pDirectoryName, pBaseDirectory) {
+	const lNormalizedDirectoryName = normalizeDirectoryName(
+		pDirectoryName,
+		pBaseDirectory,
+	);
+
+	if (lNormalizedDirectoryName === "") {
+		return [];
+	}
+
+	const lDirectorySegments = lNormalizedDirectoryName.split("/");
+	const lAncestorDirectoryNames = [""];
+	let lCurrentDirectoryName = "";
+
+	for (const lDirectorySegment of lDirectorySegments.slice(0, -1)) {
+		lCurrentDirectoryName = lCurrentDirectoryName
+			? join(lCurrentDirectoryName, lDirectorySegment)
+			: lDirectorySegment;
+		lAncestorDirectoryNames.push(pathToPosix(lCurrentDirectoryName));
+	}
+
+	return createIgnoreRulesFromDirectoryNames(
+		lAncestorDirectoryNames,
+		pBaseDirectory,
+	);
+}
+
+/**
+ * @param {string} pFilePath
+ * @param {IgnoreRuleType[]} pIgnoreRules
+ * @param {IgnoreRuleType} pMandatoryIgnoreRule
+ * @returns {boolean}
+ */
+function fileShouldBeKept(pFilePath, pIgnoreRules, pMandatoryIgnoreRule) {
+	let lFileIsIgnored = false;
+
+	for (const lIgnoreRule of pIgnoreRules) {
+		const lDirectoryName = lIgnoreRule.directoryName;
+		const lIgnoreMatcher = lIgnoreRule.ignoreMatcher;
+		let lRelativePath = null;
+
+		if (lDirectoryName === "") {
+			lRelativePath = pFilePath;
+		} else if (pFilePath.startsWith(`${lDirectoryName}/`)) {
+			lRelativePath = pFilePath.slice(lDirectoryName.length + 1);
+		}
+
+		if (lRelativePath !== null) {
+			const { ignored: lIgnored, unignored: lUnignored } =
+				lIgnoreMatcher.test(lRelativePath);
+
+			if (lIgnored) {
+				lFileIsIgnored = true;
+			}
+			if (lUnignored) {
+				lFileIsIgnored = false;
+			}
+		}
+	}
+
+	const { ignored: lIgnored, unignored: lUnignored } =
+		pMandatoryIgnoreRule.ignoreMatcher.test(pFilePath);
+
+	if (lIgnored) {
+		lFileIsIgnored = true;
+	}
+	if (lUnignored) {
+		lFileIsIgnored = false;
+	}
+
+	return !lFileIsIgnored;
+}
+
+/**
+ * @type FilterFunctionType
+ */
+
+function identityFilter(_pString, _pIndex, _pArray) {
+	return true;
+}
+
+/**
+ * @param {string} pDirectoryName
+ * @param {{baseDir: string; ignoreRules: IgnoreRuleType[]; mandatoryIgnoreRule: IgnoreRuleType; startDirectoryName: string; startDirectoryIgnoreFileContents?: string; excludeFilterFn: FilterFunctionType; includeOnlyFilterFn: FilterFunctionType}}
+ *   pOptions
  * @returns {string[]}
  */
 function walk(
 	pDirectoryName,
-	{ baseDir, ignoreFilterFn, excludeFilterFn, includeOnlyFilterFn },
+	{
+		baseDir,
+		ignoreRules,
+		mandatoryIgnoreRule,
+		startDirectoryName,
+		startDirectoryIgnoreFileContents,
+		excludeFilterFn,
+		includeOnlyFilterFn,
+	},
 ) {
+	const lCurrentDirectoryName = normalizeDirectoryName(pDirectoryName, baseDir);
+	const lCurrentIgnoreRules = ignoreRules.concat(
+		createIgnoreRuleForDirectory(lCurrentDirectoryName, baseDir, {
+			...(lCurrentDirectoryName === startDirectoryName &&
+			startDirectoryIgnoreFileContents !== undefined
+				? { ignoreFileContents: startDirectoryIgnoreFileContents }
+				: {}),
+		}),
+	);
+
 	const lFilesInCurrentDirectory = readdirSync(join(baseDir, pDirectoryName))
 		.map((pFileName) => join(pDirectoryName, pFileName))
-		.filter(ignoreFilterFn)
+		.filter((pFilePath) =>
+			fileShouldBeKept(pFilePath, lCurrentIgnoreRules, mandatoryIgnoreRule),
+		)
 		.filter(excludeFilterFn)
 		.filter(includeOnlyFilterFn);
 
@@ -40,7 +226,10 @@ function walk(
 			lFiles.push(
 				...walk(lFile, {
 					baseDir,
-					ignoreFilterFn,
+					ignoreRules: lCurrentIgnoreRules,
+					mandatoryIgnoreRule,
+					startDirectoryName,
+					startDirectoryIgnoreFileContents,
 					excludeFilterFn,
 					includeOnlyFilterFn,
 				}),
@@ -53,25 +242,10 @@ function walk(
 	return lFiles;
 }
 
-function readIgnoreFile(pFileName) {
-	try {
-		return readFileSync(pFileName, "utf8");
-	} catch {
-		return "";
-	}
-}
-
-/**
- * @type FilterFunctionType
- */
-
-function identityFilter(_pString, _pIndex, _pArray) {
-	return true;
-}
-
 /**
  * @param {string} pDirectoryName
- * @param {{baseDir: string; ignoreFileContents?: string; additionalIgnorePatterns?: string[]; excludeFilterFn?: FilterFunctionType; includeOnlyFilterFn?: FilterFunctionType}} pOptions
+ * @param {{baseDir: string; ignoreFileContents?: string; additionalIgnorePatterns?: string[]; excludeFilterFn?: FilterFunctionType; includeOnlyFilterFn?: FilterFunctionType}}
+ *   pOptions
  * @returns {string[]}
  */
 export default function findAllFiles(
@@ -84,17 +258,24 @@ export default function findAllFiles(
 		includeOnlyFilterFn,
 	},
 ) {
-	const lIgnoreFileContents =
-		ignoreFileContents ?? readIgnoreFile(join(baseDir, ".gitignore"));
 	const lAdditionalIgnorePatterns = additionalIgnorePatterns ?? [".git"];
-	const lIgnoreFilterFunction = ignore()
-		.add(lIgnoreFileContents)
-		.add(lAdditionalIgnorePatterns)
-		.createFilter();
+	const lStartDirectoryName = normalizeDirectoryName(pDirectoryName, baseDir);
+	const lMandatoryIgnoreRule = createIgnoreRule(
+		"",
+		"",
+		lAdditionalIgnorePatterns,
+	);
+	const lIgnoreRules = createIgnoreRulesBeforeDirectory(
+		pDirectoryName,
+		baseDir,
+	);
 
 	return walk(pDirectoryName, {
 		baseDir,
-		ignoreFilterFn: lIgnoreFilterFunction,
+		ignoreRules: lIgnoreRules,
+		mandatoryIgnoreRule: lMandatoryIgnoreRule,
+		startDirectoryName: lStartDirectoryName,
+		startDirectoryIgnoreFileContents: ignoreFileContents,
 		excludeFilterFn: excludeFilterFn ?? identityFilter,
 		includeOnlyFilterFn: includeOnlyFilterFn ?? identityFilter,
 	});