dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/enrich/derive/reachable.mjs

@@ -1,213 +1,210 @@
 /* eslint-disable security/detect-object-injection, no-inline-comments */
 import {
-  matchToModulePath,
-  matchToModulePathNot,
+	matchToModulePath,
+	matchToModulePathNot,
 } from "#validate/matchers.mjs";
 import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 import { extractGroups } from "#utl/regex-util.mjs";
 
 function isReachableRule(pRule) {
-  return Object.hasOwn(pRule?.to ?? {}, "reachable");
+	return Object.hasOwn(pRule?.to ?? {}, "reachable");
 }
 
 function getReachableRules(pRuleSet) {
-  return (pRuleSet?.forbidden ?? [])
-    .filter(isReachableRule)
-    .concat((pRuleSet?.allowed ?? []).filter(isReachableRule))
-    .concat((pRuleSet?.required ?? []).filter(isReachableRule));
+	return (pRuleSet?.forbidden ?? [])
+		.filter(isReachableRule)
+		.concat((pRuleSet?.allowed ?? []).filter(isReachableRule))
+		.concat((pRuleSet?.required ?? []).filter(isReachableRule));
 }
 
 function isModuleInRuleFrom(pRule) {
-  return (pModule) => {
-    const lRuleFrom = pRule.from ?? pRule.module;
-    if (lRuleFrom) {
-      return (
-        (!lRuleFrom.path || pModule.source.match(lRuleFrom.path)) &&
-        (!lRuleFrom.pathNot || !pModule.source.match(lRuleFrom.pathNot))
-      );
-    }
-    return false;
-  };
+	return (pModule) => {
+		const lRuleFrom = pRule.from ?? pRule.module;
+		if (lRuleFrom) {
+			return (
+				(!lRuleFrom.path || pModule.source.match(lRuleFrom.path)) &&
+				(!lRuleFrom.pathNot || !pModule.source.match(lRuleFrom.pathNot))
+			);
+		}
+		return false;
+	};
 }
 
 function isModuleInRuleTo(pRule, pModuleTo, pModuleFrom) {
-  const lGroups = pModuleFrom
-    ? extractGroups(pRule.from ?? pRule.module, pModuleFrom.source)
-    : [];
-
-  return (
-    matchToModulePath(pRule, pModuleTo, lGroups) &&
-    matchToModulePathNot(pRule, pModuleTo, lGroups)
-  );
+	const lGroups = pModuleFrom
+		? extractGroups(pRule.from ?? pRule.module, pModuleFrom.source)
+		: [];
+
+	return (
+		matchToModulePath(pRule, pModuleTo, lGroups) &&
+		matchToModulePathNot(pRule, pModuleTo, lGroups)
+	);
 }
 
 function mergeReachableProperties(pModule, pRule, pPath, pModuleFrom) {
-  const lReachables = pModule.reachable || [];
-  const lIndexExistingReachable = lReachables.findIndex(
-    (pReachable) => pReachable.asDefinedInRule === pRule.name,
-  );
-  const lIsReachable = pPath.length > 0;
-
-  if (lIndexExistingReachable > -1) {
-    lReachables[lIndexExistingReachable].value =
-      lReachables[lIndexExistingReachable].value || lIsReachable;
-    return lReachables;
-  }
-  return lReachables.concat({
-    value: lIsReachable,
-    asDefinedInRule: pRule.name,
-    matchedFrom: pModuleFrom,
-  });
+	const lReachables = pModule.reachable || [];
+	const lIndexExistingReachable = lReachables.findIndex(
+		(pReachable) => pReachable.asDefinedInRule === pRule.name,
+	);
+	const lIsReachable = pPath.length > 0;
+
+	if (lIndexExistingReachable > -1) {
+		lReachables[lIndexExistingReachable].value =
+			lReachables[lIndexExistingReachable].value || lIsReachable;
+		return lReachables;
+	}
+	return lReachables.concat({
+		value: lIsReachable,
+		asDefinedInRule: pRule.name,
+		matchedFrom: pModuleFrom,
+	});
 }
 
 function mergeReachesProperties(pFromModule, pToModule, pRule, pPath) {
-  const lReaches = pFromModule.reaches || [];
-  const lIndexExistingReachable = lReaches.findIndex(
-    (pReachable) => pReachable.asDefinedInRule === pRule.name,
-  );
-
-  if (lIndexExistingReachable > -1) {
-    lReaches[lIndexExistingReachable].modules = (
-      lReaches[lIndexExistingReachable].modules /* c8 ignore next */ || []
-    ).concat({
-      source: pToModule.source,
-      via: pPath,
-    });
-    return lReaches;
-  }
-  return lReaches.concat({
-    asDefinedInRule: pRule.name,
-    modules: [{ source: pToModule.source, via: pPath }],
-  });
+	const lReaches = pFromModule.reaches || [];
+	const lIndexExistingReachable = lReaches.findIndex(
+		(pReachable) => pReachable.asDefinedInRule === pRule.name,
+	);
+
+	if (lIndexExistingReachable > -1) {
+		lReaches[lIndexExistingReachable].modules = (
+			lReaches[lIndexExistingReachable].modules /* c8 ignore next */ || []
+		).concat({
+			source: pToModule.source,
+			via: pPath,
+		});
+		return lReaches;
+	}
+	return lReaches.concat({
+		asDefinedInRule: pRule.name,
+		modules: [{ source: pToModule.source, via: pPath }],
+	});
 }
 
 function shouldAddReaches(pRule, pModule) {
-  return (
-    (pRule.to.reachable === true || pRule.name === "not-in-allowed") &&
-    isModuleInRuleFrom(pRule)(pModule)
-  );
+	return (
+		(pRule.to.reachable === true || pRule.name === "not-in-allowed") &&
+		isModuleInRuleFrom(pRule)(pModule)
+	);
 }
 
 function hasCapturingGroups(pRule) {
-  const lCapturingGroupPlaceholderRe = /\$[0-9]+/;
+	const lCapturingGroupPlaceholderRe = /\$[0-9]+/;
 
-  return (
-    lCapturingGroupPlaceholderRe.test(pRule?.to?.path ?? "") ||
-    lCapturingGroupPlaceholderRe.test(pRule?.to?.pathNot ?? "")
-  );
+	return (
+		lCapturingGroupPlaceholderRe.test(pRule?.to?.path ?? "") ||
+		lCapturingGroupPlaceholderRe.test(pRule?.to?.pathNot ?? "")
+	);
 }
 function shouldAddReachable(pRule, pModuleTo, pGraph) {
-  let lReturnValue = false;
-
-  if (
-    pRule.to.reachable === false ||
-    pRule.name === "not-in-allowed" ||
-    pRule.module
-  ) {
-    if (hasCapturingGroups(pRule)) {
-      const lModulesFrom = pGraph.filter(isModuleInRuleFrom(pRule));
-
-      lReturnValue = lModulesFrom.some((pModuleFrom) =>
-        isModuleInRuleTo(pRule, pModuleTo, pModuleFrom),
-      );
-    } else {
-      lReturnValue = isModuleInRuleTo(pRule, pModuleTo);
-    }
-  }
-  return lReturnValue;
+	let lReturnValue = false;
+
+	if (
+		pRule.to.reachable === false ||
+		pRule.name === "not-in-allowed" ||
+		pRule.module
+	) {
+		if (hasCapturingGroups(pRule)) {
+			const lModulesFrom = pGraph.filter(isModuleInRuleFrom(pRule));
+
+			lReturnValue = lModulesFrom.some((pModuleFrom) =>
+				isModuleInRuleTo(pRule, pModuleTo, pModuleFrom),
+			);
+		} else {
+			lReturnValue = isModuleInRuleTo(pRule, pModuleTo);
+		}
+	}
+	return lReturnValue;
 }
 
 function addReachesToModule(pModule, pGraph, pIndexedGraph, pReachableRule) {
-  const lToModules = pGraph.filter((pToModule) =>
-    isModuleInRuleTo(pReachableRule, pToModule, pModule),
-  );
-
-  for (let lToModule of lToModules) {
-    if (pModule.source !== lToModule.source) {
-      const lPath = pIndexedGraph.getPath(pModule.source, lToModule.source);
-
-      if (lPath.length > 0) {
-        pModule.reaches = mergeReachesProperties(
-          pModule,
-          lToModule,
-          pReachableRule,
-          lPath,
-        );
-      }
-    }
-  }
-  return pModule;
+	const lToModules = pGraph.filter((pToModule) =>
+		isModuleInRuleTo(pReachableRule, pToModule, pModule),
+	);
+
+	for (const lToModule of lToModules) {
+		if (pModule.source !== lToModule.source) {
+			const lPath = pIndexedGraph.getPath(pModule.source, lToModule.source);
+
+			if (lPath.length > 0) {
+				pModule.reaches = mergeReachesProperties(
+					pModule,
+					lToModule,
+					pReachableRule,
+					lPath,
+				);
+			}
+		}
+	}
+	return pModule;
 }
 
 function addReachableToModule(
-  pModule,
-  pIndexedGraph,
-  pReachableRule,
-  pFilteredFromModules,
+	pModule,
+	pIndexedGraph,
+	pReachableRule,
+	pFilteredFromModules,
 ) {
-  let lFound = false;
-
-  for (let lFromModule of pFilteredFromModules) {
-    if (
-      !lFound &&
-      pModule.source !== lFromModule.source &&
-      isModuleInRuleTo(pReachableRule, pModule, lFromModule)
-    ) {
-      const lPath = pIndexedGraph.getPath(lFromModule.source, pModule.source);
-
-      lFound = lPath.length > 0;
-      pModule.reachable = mergeReachableProperties(
-        pModule,
-        pReachableRule,
-        lPath,
-        lFromModule.source,
-      );
-    }
-  }
-  return pModule;
+	let lFound = false;
+
+	for (const lFromModule of pFilteredFromModules) {
+		if (
+			!lFound &&
+			pModule.source !== lFromModule.source &&
+			isModuleInRuleTo(pReachableRule, pModule, lFromModule)
+		) {
+			const lPath = pIndexedGraph.getPath(lFromModule.source, pModule.source);
+
+			lFound = lPath.length > 0;
+			pModule.reachable = mergeReachableProperties(
+				pModule,
+				pReachableRule,
+				lPath,
+				lFromModule.source,
+			);
+		}
+	}
+	return pModule;
 }
 
 function addReachabilityToGraph(pGraph, pIndexedGraph, pReachableRule) {
-  const lFromModules = pGraph.filter(isModuleInRuleFrom(pReachableRule));
-
-  return pGraph.map((pModule) => {
-    // strictly speaking we should clone pModule to prevent mutating it,
-    // but in practice this function is called with a structuredClone'd graph
-    // anyway and the (reference only) copy we use now is faster (observable
-    // even on dependency-cruiser's self scan) and less memory intentsive.
-    let lModule = pModule;
-
-    if (shouldAddReaches(pReachableRule, lModule)) {
-      lModule = addReachesToModule(
-        lModule,
-        pGraph,
-        pIndexedGraph,
-        pReachableRule,
-      );
-    }
-    if (shouldAddReachable(pReachableRule, lModule, pGraph)) {
-      lModule = addReachableToModule(
-        lModule,
-        pIndexedGraph,
-        pReachableRule,
-        lFromModules,
-      );
-    }
-    return lModule;
-  });
+	const lFromModules = pGraph.filter(isModuleInRuleFrom(pReachableRule));
+
+	return pGraph.map((pModule) => {
+		// mutating pModule intentionally for performance; callers pass a cloned graph
+		let lModule = pModule;
+
+		if (shouldAddReaches(pReachableRule, lModule)) {
+			lModule = addReachesToModule(
+				lModule,
+				pGraph,
+				pIndexedGraph,
+				pReachableRule,
+			);
+		}
+		if (shouldAddReachable(pReachableRule, lModule, pGraph)) {
+			lModule = addReachableToModule(
+				lModule,
+				pIndexedGraph,
+				pReachableRule,
+				lFromModules,
+			);
+		}
+		return lModule;
+	});
 }
 
 export default function deriveReachables(pGraph, pRuleSet) {
-  const lReachableRules = pRuleSet ? getReachableRules(pRuleSet) : [];
-
-  if (lReachableRules.length > 0) {
-    const lIndexedGraph = new IndexedModuleGraph(pGraph);
-
-    let lResultGraph = structuredClone(pGraph);
-    for (const lRule of lReachableRules) {
-      lResultGraph = addReachabilityToGraph(lResultGraph, lIndexedGraph, lRule);
-    }
-    return lResultGraph;
-  }
-  return pGraph;
+	const lReachableRules = pRuleSet ? getReachableRules(pRuleSet) : [];
+
+	if (lReachableRules.length > 0) {
+		const lIndexedGraph = new IndexedModuleGraph(pGraph);
+
+		let lResultGraph = structuredClone(pGraph);
+		for (const lRule of lReachableRules) {
+			lResultGraph = addReachabilityToGraph(lResultGraph, lIndexedGraph, lRule);
+		}
+		return lResultGraph;
+	}
+	return pGraph;
 }

package/src/enrich/enrich-modules.mjs

@@ -17,32 +17,32 @@ import { bus } from "#utl/bus.mjs";
  * @returns {IModule[]}
  */
 export default function enrichModules(pModules, pOptions) {
-  bus.info("analyze: cycles");
-  const lIndexedModules = new IndexedModuleGraph(pModules);
-  let lModules = deriveCycles(pModules, lIndexedModules, {
-    pSourceAttribute: "source",
-    pDependencyName: "resolved",
-    pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,
-    pRuleSet: pOptions.ruleSet,
-  });
-  bus.info("analyze: dependents");
-  lModules = addDependents(lModules, pOptions);
-  bus.info("analyze: orphans");
-  lModules = deriveOrphans(lModules, pOptions);
-  bus.info("analyze: reachables");
-  lModules = deriveReachable(lModules, pOptions.ruleSet);
-  bus.info("analyze: module metrics");
-  lModules = deriveModuleMetrics(lModules, pOptions);
-  bus.info("analyze: focus");
-  lModules = addFocus(lModules, pOptions.focus);
+	bus.info("analyze: cycles");
+	const lIndexedModules = new IndexedModuleGraph(pModules);
+	let lModules = deriveCycles(pModules, lIndexedModules, {
+		pSourceAttribute: "source",
+		pDependencyName: "resolved",
+		pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,
+		pRuleSet: pOptions.ruleSet,
+	});
+	bus.info("analyze: dependents");
+	lModules = addDependents(lModules, pOptions);
+	bus.info("analyze: orphans");
+	lModules = deriveOrphans(lModules, pOptions);
+	bus.info("analyze: reachables");
+	lModules = deriveReachable(lModules, pOptions.ruleSet);
+	bus.info("analyze: module metrics");
+	lModules = deriveModuleMetrics(lModules, pOptions);
+	bus.info("analyze: focus");
+	lModules = addFocus(lModules, pOptions.focus);
 
-  // when validate === false we might want to skip the addValidations.
-  // We don't at this time, however, as "valid" is a mandatory
-  // attribute (to simplify reporter logic)
-  bus.info("analyze: validations");
-  lModules = addValidations(lModules, pOptions.ruleSet, pOptions.validate);
+	// when validate === false we might want to skip the addValidations.
+	// We don't at this time, however, as "valid" is a mandatory
+	// attribute (to simplify reporter logic)
+	bus.info("analyze: validations");
+	lModules = addValidations(lModules, pOptions.ruleSet, pOptions.validate);
 
-  lModules = softenKnownViolations(lModules, pOptions.knownViolations);
+	lModules = softenKnownViolations(lModules, pOptions.knownViolations);
 
-  return lModules;
+	return lModules;
 }

package/src/enrich/index.mjs

@@ -17,21 +17,21 @@ import { bus } from "#utl/bus.mjs";
  * @returns {import("../../types/dependency-cruiser.js").ICruiseResult}
  */
 export default function enrich(pModules, pOptions, pFileAndDirectoryArray) {
-  const lModules = enrichModules(pModules, pOptions);
-  bus.info("analyze: aggregate to folders");
-  const lFolders = aggregateToFolders(lModules, pOptions);
+	const lModules = enrichModules(pModules, pOptions);
+	bus.info("analyze: aggregate to folders");
+	const lFolders = aggregateToFolders(lModules, pOptions);
 
-  bus.info("analyze: summary");
-  const lReturnValue = {
-    modules: lModules,
-    ...lFolders,
-    summary: summarize(
-      lModules,
-      pOptions,
-      pFileAndDirectoryArray,
-      lFolders.folders,
-    ),
-  };
+	bus.info("analyze: summary");
+	const lReturnValue = {
+		modules: lModules,
+		...lFolders,
+		summary: summarize(
+			lModules,
+			pOptions,
+			pFileAndDirectoryArray,
+			lFolders.folders,
+		),
+	};
 
-  return lReturnValue;
+	return lReturnValue;
 }