dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/report/teamcity.mjs

@@ -12,26 +12,26 @@ import { formatPercentage, formatViolation } from "./utl/index.mjs";
  * @return {String}
  */
 function escape(pMessageString) {
-  if (pMessageString === null) {
-    return "";
-  }
+	if (pMessageString === null) {
+		return "";
+	}
 
-  return (
-    pMessageString
-      .toString()
-      .replace(/\|/g, "||")
-      .replace(/\n/g, "|n")
-      .replace(/\r/g, "|r")
-      .replace(/\[/g, "|[")
-      .replace(/\]/g, "|]")
-      // next line
-      .replace(/\u0085/g, "|x")
-      // line separator
-      .replace(/\u2028/g, "|l")
-      // paragraph separator
-      .replace(/\u2029/g, "|p")
-      .replace(/'/g, "|'")
-  );
+	return (
+		pMessageString
+			.toString()
+			.replace(/\|/g, "||")
+			.replace(/\n/g, "|n")
+			.replace(/\r/g, "|r")
+			.replace(/\[/g, "|[")
+			.replace(/\]/g, "|]")
+			// next line
+			.replace(/\u0085/g, "|x")
+			// line separator
+			.replace(/\u2028/g, "|l")
+			// paragraph separator
+			.replace(/\u2029/g, "|p")
+			.replace(/'/g, "|'")
+	);
 }
 
 /**
@@ -43,11 +43,11 @@ function escape(pMessageString) {
  * @return {string} a random flowId consisting of 10 numeric digits
  */
 function getRandomFlowIdBare() {
-  const lFlowIdLength = 10;
-  // eslint-disable-next-line no-magic-numbers
-  const lFlowIdMax = 10 ** lFlowIdLength;
+	const lFlowIdLength = 10;
+	// eslint-disable-next-line no-magic-numbers
+	const lFlowIdMax = 10 ** lFlowIdLength;
 
-  return randomInt(1, lFlowIdMax).toString().padStart(lFlowIdLength, "0");
+	return randomInt(1, lFlowIdMax).toString().padStart(lFlowIdLength, "0");
 }
 
 const getRandomFlowId = memoize(getRandomFlowIdBare);
@@ -56,178 +56,178 @@ const getRandomFlowId = memoize(getRandomFlowIdBare);
  * Returns a timestamp in ISO format without the trailing 'Z'. It used to be
  * an issue with TeamCity that it didn't use the trailing 'Z' (this is
  * documented in the teamcity-service-messages source code) - not sure whether
- * this is still the case, but this is what we do to be on the safe side.
+ * this is still the case, but better safe than sorry.
  *
  * @returns {string} a timestamp in ISO format without the trailing 'Z'
  */
 function getTimeStamp() {
-  return new Date().toISOString().slice(0, -1);
+	return new Date().toISOString().slice(0, -1);
 }
 
 function inspectionType(pData) {
-  const lAttributes = [];
-  lAttributes.push(
-    `id='${pData.id}'`,
-    `name='${pData.name}'`,
-    `description='${escape(pData.description)}'`,
-    `category='${pData.category}'`,
-    `flowId='${getRandomFlowId()}'`,
-    `timestamp='${getTimeStamp()}'`,
-  );
-  return `##teamcity[inspectionType ${lAttributes.join(" ")}]`;
+	const lAttributes = [];
+	lAttributes.push(
+		`id='${pData.id}'`,
+		`name='${pData.name}'`,
+		`description='${escape(pData.description)}'`,
+		`category='${pData.category}'`,
+		`flowId='${getRandomFlowId()}'`,
+		`timestamp='${getTimeStamp()}'`,
+	);
+	return `##teamcity[inspectionType ${lAttributes.join(" ")}]`;
 }
 
 function inspection(pData) {
-  const lAttributes = [];
-  lAttributes.push(
-    `typeId='${pData.typeId}'`,
-    `message='${escape(pData.message)}'`,
-  );
-  if (pData.file) {
-    lAttributes.push(`file='${pData.file}'`);
-  }
-  lAttributes.push(
-    `SEVERITY='${pData.SEVERITY}'`,
-    `flowId='${getRandomFlowId()}'`,
-    `timestamp='${getTimeStamp()}'`,
-  );
+	const lAttributes = [];
+	lAttributes.push(
+		`typeId='${pData.typeId}'`,
+		`message='${escape(pData.message)}'`,
+	);
+	if (pData.file) {
+		lAttributes.push(`file='${pData.file}'`);
+	}
+	lAttributes.push(
+		`SEVERITY='${pData.SEVERITY}'`,
+		`flowId='${getRandomFlowId()}'`,
+		`timestamp='${getTimeStamp()}'`,
+	);
 
-  return `##teamcity[inspection ${lAttributes.join(" ")}]`;
+	return `##teamcity[inspection ${lAttributes.join(" ")}]`;
 }
 
 const CATEGORY = "dependency-cruiser";
 const SEVERITY2TEAMCITY_SEVERITY = new Map([
-  ["error", "ERROR"],
-  ["warn", "WARNING"],
-  ["info", "INFO"],
+	["error", "ERROR"],
+	["warn", "WARNING"],
+	["info", "INFO"],
 ]);
 const EOL = "\n";
 
 function severity2teamcitySeverity(pSeverity) {
-  return SEVERITY2TEAMCITY_SEVERITY.get(pSeverity) || "INFO";
+	return SEVERITY2TEAMCITY_SEVERITY.get(pSeverity) || "INFO";
 }
 
 function reportRules(pRules, pViolations) {
-  return pRules
-    .filter((pRule) =>
-      pViolations.some((pViolation) => pRule.name === pViolation.rule.name),
-    )
-    .map((pRule) =>
-      inspectionType({
-        id: pRule.name,
-        name: pRule.name,
-        description: pRule.comment || pRule.name,
-        category: CATEGORY,
-      }),
-    );
+	return pRules
+		.filter((pRule) =>
+			pViolations.some((pViolation) => pRule.name === pViolation.rule.name),
+		)
+		.map((pRule) =>
+			inspectionType({
+				id: pRule.name,
+				name: pRule.name,
+				description: pRule.comment || pRule.name,
+				category: CATEGORY,
+			}),
+		);
 }
 
 function reportAllowedRule(pAllowedRule, pViolations) {
-  let lReturnValue = [];
+	let lReturnValue = [];
 
-  if (
-    pAllowedRule.length > 0 &&
-    pViolations.some((pViolation) => pViolation.rule.name === "not-in-allowed")
-  ) {
-    lReturnValue = inspectionType({
-      id: "not-in-allowed",
-      name: "not-in-allowed",
-      description: "dependency is not in the 'allowed' set of rules",
-      category: CATEGORY,
-    });
-  }
-  return lReturnValue;
+	if (
+		pAllowedRule.length > 0 &&
+		pViolations.some((pViolation) => pViolation.rule.name === "not-in-allowed")
+	) {
+		lReturnValue = inspectionType({
+			id: "not-in-allowed",
+			name: "not-in-allowed",
+			description: "dependency is not in the 'allowed' set of rules",
+			category: CATEGORY,
+		});
+	}
+	return lReturnValue;
 }
 
 function reportIgnoredRules(pIgnoredCount) {
-  let lReturnValue = [];
+	let lReturnValue = [];
 
-  if (pIgnoredCount > 0) {
-    lReturnValue = inspectionType({
-      id: "ignored-known-violations",
-      name: "ignored-known-violations",
-      description:
-        "some dependency violations were ignored; run with --no-ignore-known to see them",
-      category: CATEGORY,
-    });
-  }
-  return lReturnValue;
+	if (pIgnoredCount > 0) {
+		lReturnValue = inspectionType({
+			id: "ignored-known-violations",
+			name: "ignored-known-violations",
+			description:
+				"some dependency violations were ignored; run with --no-ignore-known to see them",
+			category: CATEGORY,
+		});
+	}
+	return lReturnValue;
 }
 
 function reportViolatedRules(pRuleSetUsed, pViolations, pIgnoredCount) {
-  return reportRules(pRuleSetUsed?.forbidden ?? [], pViolations)
-    .concat(reportAllowedRule(pRuleSetUsed?.allowed ?? [], pViolations))
-    .concat(reportRules(pRuleSetUsed?.required ?? [], pViolations))
-    .concat(reportIgnoredRules(pIgnoredCount));
+	return reportRules(pRuleSetUsed?.forbidden ?? [], pViolations)
+		.concat(reportAllowedRule(pRuleSetUsed?.allowed ?? [], pViolations))
+		.concat(reportRules(pRuleSetUsed?.required ?? [], pViolations))
+		.concat(reportIgnoredRules(pIgnoredCount));
 }
 
 function formatModuleViolation(pViolation) {
-  return pViolation.from;
+	return pViolation.from;
 }
 
 function formatDependencyViolation(pViolation) {
-  return `${pViolation.from} -> ${pViolation.to}`;
+	return `${pViolation.from} -> ${pViolation.to}`;
 }
 
 function formatCycleViolation(pViolation) {
-  return `${pViolation.from} -> ${pViolation.cycle
-    .map(({ name }) => name)
-    .join(" -> ")}`;
+	return `${pViolation.from} -> ${pViolation.cycle
+		.map(({ name }) => name)
+		.join(" -> ")}`;
 }
 
 function formatReachabilityViolation(pViolation) {
-  return `${formatDependencyViolation(pViolation)} ${pViolation.via
-    .map(({ name }) => name)
-    .join(" -> ")}`;
+	return `${formatDependencyViolation(pViolation)} ${pViolation.via
+		.map(({ name }) => name)
+		.join(" -> ")}`;
 }
 
 function formatInstabilityViolation(pViolation) {
-  return `${formatDependencyViolation(
-    pViolation,
-  )} (instability: ${formatPercentage(
-    pViolation.metrics.from.instability,
-  )} -> ${formatPercentage(pViolation.metrics.to.instability)})`;
+	return `${formatDependencyViolation(
+		pViolation,
+	)} (instability: ${formatPercentage(
+		pViolation.metrics.from.instability,
+	)} -> ${formatPercentage(pViolation.metrics.to.instability)})`;
 }
 
 function bakeViolationMessage(pViolation) {
-  const lViolationType2Formatter = {
-    module: formatModuleViolation,
-    dependency: formatDependencyViolation,
-    cycle: formatCycleViolation,
-    reachability: formatReachabilityViolation,
-    instability: formatInstabilityViolation,
-  };
-  return formatViolation(
-    pViolation,
-    lViolationType2Formatter,
-    formatDependencyViolation,
-  );
+	const lViolationType2Formatter = {
+		module: formatModuleViolation,
+		dependency: formatDependencyViolation,
+		cycle: formatCycleViolation,
+		reachability: formatReachabilityViolation,
+		instability: formatInstabilityViolation,
+	};
+	return formatViolation(
+		pViolation,
+		lViolationType2Formatter,
+		formatDependencyViolation,
+	);
 }
 
 function reportIgnoredViolation(pIgnoredCount) {
-  let lReturnValue = [];
+	let lReturnValue = [];
 
-  if (pIgnoredCount > 0) {
-    lReturnValue = inspection({
-      typeId: "ignored-known-violations",
-      message: `${pIgnoredCount} known violations ignored. Run with --no-ignore-known to see them.`,
-      SEVERITY: "WARNING",
-    });
-  }
-  return lReturnValue;
+	if (pIgnoredCount > 0) {
+		lReturnValue = inspection({
+			typeId: "ignored-known-violations",
+			message: `${pIgnoredCount} known violations ignored. Run with --no-ignore-known to see them.`,
+			SEVERITY: "WARNING",
+		});
+	}
+	return lReturnValue;
 }
 
 function reportViolations(pViolations, pIgnoredCount) {
-  return pViolations
-    .map((pViolation) =>
-      inspection({
-        typeId: pViolation.rule.name,
-        message: bakeViolationMessage(pViolation),
-        file: pViolation.from,
-        SEVERITY: severity2teamcitySeverity(pViolation.rule.severity),
-      }),
-    )
-    .concat(reportIgnoredViolation(pIgnoredCount));
+	return pViolations
+		.map((pViolation) =>
+			inspection({
+				typeId: pViolation.rule.name,
+				message: bakeViolationMessage(pViolation),
+				file: pViolation.from,
+				SEVERITY: severity2teamcitySeverity(pViolation.rule.severity),
+			}),
+		)
+		.concat(reportIgnoredViolation(pIgnoredCount));
 }
 
 /**
@@ -242,19 +242,19 @@ function reportViolations(pViolations, pIgnoredCount) {
  */
 // eslint-disable-next-line complexity
 export default function teamcity(pResults) {
-  memoizeClear(getRandomFlowId);
+	memoizeClear(getRandomFlowId);
 
-  const lRuleSet = pResults?.summary?.ruleSetUsed ?? [];
-  const lViolations = (pResults?.summary?.violations ?? []).filter(
-    (pViolation) => pViolation.rule.severity !== "ignore",
-  );
-  const lIgnoredCount = pResults?.summary?.ignore ?? 0;
+	const lRuleSet = pResults?.summary?.ruleSetUsed ?? [];
+	const lViolations = (pResults?.summary?.violations ?? []).filter(
+		(pViolation) => pViolation.rule.severity !== "ignore",
+	);
+	const lIgnoredCount = pResults?.summary?.ignore ?? 0;
 
-  return {
-    output:
-      reportViolatedRules(lRuleSet, lViolations, lIgnoredCount)
-        .concat(reportViolations(lViolations, lIgnoredCount))
-        .reduce((pAll, pCurrent) => `${pAll}${pCurrent}\n`, "") || EOL,
-    exitCode: pResults.summary.error,
-  };
+	return {
+		output:
+			reportViolatedRules(lRuleSet, lViolations, lIgnoredCount)
+				.concat(reportViolations(lViolations, lIgnoredCount))
+				.reduce((pAll, pCurrent) => `${pAll}${pCurrent}\n`, "") || EOL,
+		exitCode: pResults.summary.error,
+	};
 }

package/src/report/text.mjs

@@ -1,7 +1,7 @@
 import { styleText } from "node:util";
 
 const DEFAULT_OPTIONS = {
-  highlightFocused: false,
+	highlightFocused: false,
 };
 const EOL = "\n";
 
@@ -13,36 +13,36 @@ const EOL = "\n";
  * @returns {any}
  */
 function toFlatModuleDependencies(pModule, pModulesInFocus, pHighlightFocused) {
-  return pModule.dependencies.map((pDependency) => ({
-    from: {
-      name: pModule.source,
-      highlight: pHighlightFocused && pModule.matchesFocus,
-    },
-    to: {
-      name: pDependency.resolved,
-      highlight: pHighlightFocused && pModulesInFocus.has(pDependency.resolved),
-    },
-  }));
+	return pModule.dependencies.map((pDependency) => ({
+		from: {
+			name: pModule.source,
+			highlight: pHighlightFocused && pModule.matchesFocus,
+		},
+		to: {
+			name: pDependency.resolved,
+			highlight: pHighlightFocused && pModulesInFocus.has(pDependency.resolved),
+		},
+	}));
 }
 
 function toFlatDependencies(pModules, pModulesInFocus, pHighlightFocused) {
-  return pModules.reduce(
-    (pAll, pModule) =>
-      pAll.concat(
-        toFlatModuleDependencies(pModule, pModulesInFocus, pHighlightFocused),
-      ),
-    [],
-  );
+	return pModules.reduce(
+		(pAll, pModule) =>
+			pAll.concat(
+				toFlatModuleDependencies(pModule, pModulesInFocus, pHighlightFocused),
+			),
+		[],
+	);
 }
 
 function stringifyModule(pModule) {
-  return pModule.highlight
-    ? styleText("underline", pModule.name)
-    : pModule.name;
+	return pModule.highlight
+		? styleText("underline", pModule.name)
+		: pModule.name;
 }
 
 function stringify(pFlatDependency) {
-  return `${stringifyModule(pFlatDependency.from)} → ${stringifyModule(pFlatDependency.to)}`;
+	return `${stringifyModule(pFlatDependency.from)} → ${stringifyModule(pFlatDependency.to)}`;
 }
 
 /**
@@ -51,11 +51,11 @@ function stringify(pFlatDependency) {
  * @returns {Set<string>}
  */
 function getModulesInFocus(pModules) {
-  return new Set(
-    pModules
-      .filter((pModule) => pModule.matchesFocus || pModule.matchesReaches)
-      .map((pModule) => pModule.source),
-  );
+	return new Set(
+		pModules
+			.filter((pModule) => pModule.matchesFocus || pModule.matchesReaches)
+			.map((pModule) => pModule.source),
+	);
 }
 
 /**
@@ -65,18 +65,18 @@ function getModulesInFocus(pModules) {
  * @returns {string}
  */
 function report(pResults, pOptions) {
-  const lOptions = { ...DEFAULT_OPTIONS, ...pOptions };
+	const lOptions = { ...DEFAULT_OPTIONS, ...pOptions };
 
-  return (
-    toFlatDependencies(
-      pResults.modules,
-      getModulesInFocus(pResults.modules),
-      lOptions.highlightFocused === true,
-    ).reduce(
-      (pAll, pDependency) => pAll.concat(stringify(pDependency)).concat(EOL),
-      "",
-    ) || EOL
-  );
+	return (
+		toFlatDependencies(
+			pResults.modules,
+			getModulesInFocus(pResults.modules),
+			lOptions.highlightFocused === true,
+		).reduce(
+			(pAll, pDependency) => pAll.concat(stringify(pDependency)).concat(EOL),
+			"",
+		) || EOL
+	);
 }
 
 /**
@@ -87,8 +87,8 @@ function report(pResults, pOptions) {
  * @returns {import("../../types/dependency-cruiser").IReporterOutput}
  */
 export default function text(pResults, pOptions) {
-  return {
-    output: report(pResults, pOptions || {}),
-    exitCode: 0,
-  };
+	return {
+		output: report(pResults, pOptions || {}),
+		exitCode: 0,
+	};
 }

package/src/report/utl/dependency-to-incidence-transformer.mjs

@@ -1,50 +1,50 @@
 function deriveSortKey(pModule) {
-  return `${pModule.coreModule ? "1" : "0"}-${pModule.source}`;
+	return `${pModule.coreModule ? "1" : "0"}-${pModule.source}`;
 }
 
 function compareOnSource(pOne, pTwo) {
-  return deriveSortKey(pOne) > deriveSortKey(pTwo) ? 1 : -1;
+	return deriveSortKey(pOne) > deriveSortKey(pTwo) ? 1 : -1;
 }
 
 function determineIncidenceType(pFromListEntry) {
-  return (pModule) => {
-    let lDependency = pModule.dependencies.find(
-      (pDependency) => pDependency.resolved === pFromListEntry.source,
-    );
+	return (pModule) => {
+		let lDependency = pModule.dependencies.find(
+			(pDependency) => pDependency.resolved === pFromListEntry.source,
+		);
 
-    if (lDependency) {
-      return lDependency.valid
-        ? {
-            incidence: "true",
-          }
-        : {
-            incidence: lDependency.rules[0].severity,
-            rule: `${lDependency.rules[0].name}${
-              lDependency.rules.length > 1
-                ? ` (+${lDependency.rules.length - 1} others)`
-                : ""
-            }`,
-          };
-    }
+		if (lDependency) {
+			return lDependency.valid
+				? {
+						incidence: "true",
+					}
+				: {
+						incidence: lDependency.rules[0].severity,
+						rule: `${lDependency.rules[0].name}${
+							lDependency.rules.length > 1
+								? ` (+${lDependency.rules.length - 1} others)`
+								: ""
+						}`,
+					};
+		}
 
-    return {
-      incidence: "false",
-    };
-  };
+		return {
+			incidence: "false",
+		};
+	};
 }
 
 function addIncidences(pFromList) {
-  return (pDependency) => ({
-    ...pDependency,
-    incidences: pFromList.map((pFromListEntry) => ({
-      to: pFromListEntry.source,
-      ...determineIncidenceType(pFromListEntry)(pDependency),
-    })),
-  });
+	return (pDependency) => ({
+		...pDependency,
+		incidences: pFromList.map((pFromListEntry) => ({
+			to: pFromListEntry.source,
+			...determineIncidenceType(pFromListEntry)(pDependency),
+		})),
+	});
 }
 /*
 
 */
 export default function transformDependenciesToIncidences(pFromList) {
-  return pFromList.sort(compareOnSource).map(addIncidences(pFromList));
+	return pFromList.sort(compareOnSource).map(addIncidences(pFromList));
 }