dependency-cruiser 17.3.9 → 17.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dependency-cruiser",
-	"version": "17.3.9",
+	"version": "17.4.0",
 	"description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
 	"keywords": [
 		"static analysis",
@@ -149,12 +149,12 @@
 		"acorn-loose": "8.5.2",
 		"acorn-walk": "8.3.5",
 		"commander": "14.0.3",
-		"enhanced-resolve": "5.20.0",
+		"enhanced-resolve": "5.21.0",
 		"ignore": "7.0.5",
 		"interpret": "3.1.1",
 		"is-installed-globally": "1.0.0",
 		"json5": "2.2.3",
-		"picomatch": "4.0.3",
+		"picomatch": "4.0.4",
 		"prompts": "2.4.2",
 		"rechoir": "0.8.0",
 		"safe-regex": "2.1.1",

package/src/analyze/summarize/summarize-modules.mjs

@@ -17,6 +17,8 @@ function toDependencyViolationSummary(pRule, pModule, pDependency, pRuleSet) {
 		type: "dependency",
 		from: pModule.source,
 		to: pDependency.resolved,
+		unresolvedTo: pDependency.module,
+		dependencyTypes: pDependency.dependencyTypes,
 		rule: pRule,
 	};
 

package/src/cli/init-config/build-config.mjs

@@ -3,7 +3,7 @@ import { folderNameArrayToRE } from "./utl.mjs";
 import configTemplate from "./config-template.mjs";
 
 /**
- * @import { IInitConfig } from "./types.js";
+ * @import { IInitConfig } from "./types.mjs";
  */
 
 /**

package/src/cli/init-config/check-and-warn-inconsistencies.mjs

@@ -0,0 +1,111 @@
+/* eslint-disable prefer-template */
+/**
+ * @import { IInitConfig } from "./types.mjs";
+ * @import { IAvailableTranspiler } from "../../../types/dependency-cruiser.mjs"
+ */
+
+import { EOL } from "node:os";
+import { styleText } from "node:util";
+import { getAvailableTranspilers } from "#extract/transpile/meta.mjs";
+
+/**
+ * returns true if
+ * - typescript features are detected _and_ a typescript compiler is present
+ * - no typescript features were detected
+ * returns false in all other cases
+ *
+ * @param {IInitConfig} pInitOptions
+ * @param {IAvailableTranspiler[]} pAvailableTranspilers
+ * @return {boolean}
+ */
+function typescriptIsConsistent(pInitOptions, pAvailableTranspilers) {
+	if (pInitOptions.usesTypeScript) {
+		return pAvailableTranspilers.some(
+			(pAvailableTranspiler) =>
+				pAvailableTranspiler.name === "typescript" &&
+				pAvailableTranspiler.available,
+		);
+	}
+	return true;
+}
+
+/**
+ * returns true if
+ * - babel features are detected _and_ the babel transpiler is present
+ * - no babel features were detected
+ * returns false in all other cases
+ *
+ * @param {IInitConfig} pInitOptions
+ * @param {IAvailableTranspiler[]} pAvailableTranspilers
+ * @return {boolean}
+ */
+function babelIsConsistent(pInitOptions, pAvailableTranspilers) {
+	if (pInitOptions.babelConfig) {
+		return pAvailableTranspilers.some(
+			(pAvailableTranspiler) =>
+				pAvailableTranspiler.name === "babel" && pAvailableTranspiler.available,
+		);
+	}
+	return true;
+}
+
+/**
+ * Prints warnings to stderr if there's inconsistencies in the init options.
+ * E.g. typescript options are used, but the (microsoft) typescript compiler
+ * isn't installed.
+ *
+ * @param {IInitConfig} pInitOptions
+ * @param {NodeJS.WritableStream} [pErrorStream]
+ * @param {typeof getAvailableTranspilers} [pAvailableTranspilerFunction]
+ * @return {IInitConfig} pInitOptions
+ */
+export function checkAndWarnInconsistencies(
+	pInitOptions,
+	pErrorStream = process.stderr,
+	pAvailableTranspilerFunction = getAvailableTranspilers,
+) {
+	const lAvailableTranspilers = pAvailableTranspilerFunction();
+	const lWarningMessages = [];
+
+	if (!typescriptIsConsistent(pInitOptions, lAvailableTranspilers)) {
+		lWarningMessages.push(
+			EOL +
+				"   ‼ TypeScript compiler not found" +
+				EOL +
+				"     TypeScript features are used but the TypeScript compiler isn't installed. " +
+				EOL +
+				"     Install it to ensure dependency-cruiser cruises TypeScript sources e.g. by running" +
+				EOL +
+				EOL +
+				"       npm i -D typescript" +
+				EOL,
+		);
+	}
+	if (!babelIsConsistent(pInitOptions, lAvailableTranspilers)) {
+		lWarningMessages.push(
+			EOL +
+				"   ‼ Babel not found " +
+				EOL +
+				"     Babel features are used but Babel isn't installed. " +
+				EOL +
+				"     Install it to ensure dependency-cruiser takes them into account. E.g. by running" +
+				EOL +
+				EOL +
+				"       npm i -D @babel/core" +
+				EOL,
+		);
+	}
+
+	// future features: do the same for ...
+	// ... webpack
+	// ... svelte
+	// ... vue
+	// ... coffeescript
+	// ... livescript?
+	if (lWarningMessages.length > 0) {
+		pErrorStream.write(styleText("yellow", lWarningMessages.join("")));
+	}
+
+	// as it's used in a promise chain ...
+	return pInitOptions;
+}

package/src/cli/init-config/get-user-input.mjs

@@ -163,7 +163,7 @@ const QUESTIONS = [
 ];
 
 /**
- * @return {Promise<import("./types").IPartialInitConfig>}
+ * @return {Promise<import("./types.d.mts").IPartialInitConfig>}
  */
 export default function getUserInput() {
 	return prompts(QUESTIONS);

package/src/cli/init-config/index.mjs

@@ -4,6 +4,7 @@ import normalizeInitOptions from "./normalize-init-options.mjs";
 import buildConfig from "./build-config.mjs";
 import writeConfig from "./write-config.mjs";
 import getUserInput from "./get-user-input.mjs";
+import { checkAndWarnInconsistencies } from "./check-and-warn-inconsistencies.mjs";
 import {
 	isLikelyMonoRepo,
 	fileExists,
@@ -22,7 +23,7 @@ import {
 import { writeRunScriptsToManifest } from "./write-run-scripts-to-manifest.mjs";
 
 /**
- * @import { IInitConfig, IPartialInitConfig, OneShotConfigIDType } from "./types.js";
+ * @import { IInitConfig, IPartialInitConfig, OneShotConfigIDType } from "./types.mjs";
  */
 
 const PACKAGE_MANIFEST = `./${_PACKAGE_MANIFEST}`;
@@ -95,6 +96,9 @@ export default function initConfig(pInit, pConfigFileName, pStreams) {
 	if (pInit === true) {
 		getUserInput()
 			.then(normalizeInitOptions)
+			.then((pNormalizedInitOptions) =>
+				checkAndWarnInconsistencies(pNormalizedInitOptions, lStreams.stderr),
+			)
 			.then(buildConfig)
 			.then(writeConfig)
 			.catch((pError) => {
@@ -103,6 +107,7 @@ export default function initConfig(pInit, pConfigFileName, pStreams) {
 		/* c8 ignore stop */
 	} else if (pInit !== false) {
 		const lNormalizedInitConfig = normalizeInitOptions(getOneShotConfig(pInit));
+		checkAndWarnInconsistencies(lNormalizedInitConfig, lStreams.stderr);
 		const lConfigFileName = pConfigFileName || getDefaultConfigFileName();
 
 		if (manifestIsUpdatable(lNormalizedInitConfig)) {

package/src/cli/init-config/normalize-init-options.mjs

@@ -8,7 +8,7 @@ import findExtensions from "./find-extensions.mjs";
 import meta from "#meta.cjs";
 
 /**
- * @import { IInitConfig, IPartialInitConfig } from "./types.js";
+ * @import { IInitConfig, IPartialInitConfig } from "./types.mjs";
  */
 
 /**

package/src/cli/init-config/types.d.mts

@@ -0,0 +1,114 @@
+export type OneShotConfigIDType = "yes" | "x-scripts";
+
+export interface IInitConfig {
+	/**
+	 * Whether or not the current folder houses a mono repo
+	 */
+	isMonoRepo: boolean;
+	/**
+	 * Whether or not the current folder is a package is an ESM package
+	 * by default (and resolutions of external dependencies should be
+	 * treated as such)
+	 */
+	isTypeModule: boolean;
+	/**
+	 * Whether or not you allow usage of external dependencies declared in
+	 * package.jsons of parent folders
+	 */
+	combinedDependencies: boolean;
+	/**
+	 * Whether or not to use a TypeScript config
+	 */
+	useJsConfig: boolean;
+	/**
+	 * The file name of the TypeScript config to use
+	 */
+	jsConfig?: string;
+	/**
+	 * Whether or not to use a TypeScript config
+	 */
+	useTsConfig: boolean;
+	/**
+	 * The file name of the TypeScript config to use
+	 */
+	tsConfig?: string;
+	/**
+	 * Whether or not to detect JSDoc imports
+	 */
+	detectJSDocImports?: boolean;
+	/**
+	 * Whether or not to detect calls to `process.getBuiltinModule`/
+	 * `globalThis.process.getBuiltinModule` as imports
+	 */
+	detectProcessBuiltinModuleCalls?: boolean;
+	/**
+	 * Whether or not to take dependencies into account that only exist before
+	 * compilation to javascript
+	 */
+	tsPreCompilationDeps: boolean;
+	/**
+	 * Derived attribute. True if the current project likely uses typescript (has a
+	 * tsconfig, has files with typescript extensions in source and/ or test
+	 * folders, or has a truthy tsPreCompilationDeps)
+	 */
+	usesTypeScript: boolean;
+	/**
+	 * Whether or not to use a Webpack config
+	 */
+	useWebpackConfig: boolean;
+	/**
+	 * The file name of the Webpack config to use
+	 */
+	webpackConfig?: string;
+	/**
+	 * Whether or not to use a Babel config
+	 */
+	useBabelConfig: boolean;
+	/**
+	 * The file name of the Babel config to use
+	 */
+	babelConfig?: string;
+	/**
+	 * Whether or not to include some useful scripts in your package.json
+	 */
+	updateManifest: boolean;
+	/**
+	 * An array of (relative) paths to folders to understand as source code
+	 */
+	sourceLocation: string[];
+	/**
+	 * Whether tests are housed in a folder separate from sources
+	 * or are embedded within the source folder
+	 */
+	hasTestsOutsideSource: boolean;
+	/**
+	 * An array of (relative) paths to folders to understand as test code
+	 */
+	testLocation?: string[];
+	/**
+	 * Whether or not to explicitly pass extensions to the resolver. When not
+	 * set explicitly dependency-cruiser will pass it all extensions it knows
+	 * to handle - which makes it more sure to catch everything, at the trade-off
+	 * of potentially being slower if the number of extensions used in reality
+	 * is (a lot) smaller.
+	 */
+	specifyResolutionExtensions: boolean;
+	/**
+	 * An array of extensions the resolver should use when resolving dependencies
+	 */
+	resolutionExtensions?: string[];
+	/**
+	 * Dependency-cruiser version used
+	 */
+	version: string;
+	/**
+	 * (Formatted) date this config is created
+	 */
+	date: string;
+	/**
+	 * bun is used as package manager cq runtime
+	 */
+	usesBun: boolean;
+}
+
+export type IPartialInitConfig = Partial<IInitConfig>;

package/src/cli/init-config/write-run-scripts-to-manifest.mjs

@@ -59,7 +59,7 @@ const EXPERIMENTAL_SCRIPT_DOC = [
 ];
 
 /**
- * @param {import("./types").IInitConfig} pInitOptions
+ * @param {import("./types.d.mts").IInitConfig} pInitOptions
  * @return {any} an bunch of key value pairs that can be plonked into a `scripts` attribute in a package.json
  */
 export function compileRunScripts(pInitOptions) {

package/src/extract/transpile/meta.mjs

@@ -3,7 +3,7 @@ import {
 	isAvailable as swcIsAvailable,
 	version as swcVersion,
 } from "../swc/parse.mjs";
-import tryAvailable from "./try-import-available.mjs";
+import tryImportAvailable from "./try-import-available.mjs";
 import javascriptWrap from "./javascript-wrap.mjs";
 import babelWrap from "./babel-wrap.mjs";
 import coffeeScriptWrapFunction from "./coffeescript-wrap.mjs";
@@ -13,6 +13,10 @@ import typescriptWrapFunction from "./typescript-wrap.mjs";
 import vueTemplateWrap from "./vue-template-wrap.cjs";
 import meta from "#meta.cjs";
 
+/**
+ * @import { IAvailableTranspiler } from "../../../types/dependency-cruiser.mjs";
+ */
+
 const swcWrap = {
 	isAvailable: () => swcIsAvailable(),
 	version: () => swcVersion(),
@@ -23,25 +27,43 @@ const typescriptWrap = typescriptWrapFunction("esm");
 
 function gotCoffee() {
 	return (
-		tryAvailable("coffeescript", meta.supportedTranspilers.coffeescript) ||
-		tryAvailable("coffee-script", meta.supportedTranspilers["coffee-script"])
+		tryImportAvailable(
+			"coffeescript",
+			meta.supportedTranspilers.coffeescript,
+		) ||
+		/* c8 ignore start */
+		// fallback for ancient versions of the coffeescript compilers
+		tryImportAvailable(
+			"coffee-script",
+			meta.supportedTranspilers["coffee-script"],
+		)
+		/* c8 ignore stop */
 	);
 }
 
 const TRANSPILER2AVAILABLE = {
-	babel: tryAvailable("@babel/core", meta.supportedTranspilers.babel),
+	babel: tryImportAvailable("@babel/core", meta.supportedTranspilers.babel),
 	javascript: true,
 	"coffee-script": gotCoffee(),
 	coffeescript: gotCoffee(),
-	livescript: tryAvailable("livescript", meta.supportedTranspilers.livescript),
-	svelte: tryAvailable("svelte/compiler", meta.supportedTranspilers.svelte),
-	swc: tryAvailable("@swc/core", meta.supportedTranspilers.swc),
-	typescript: tryAvailable("typescript", meta.supportedTranspilers.typescript),
-	"vue-template-compiler": tryAvailable(
+	livescript: tryImportAvailable(
+		"livescript",
+		meta.supportedTranspilers.livescript,
+	),
+	svelte: tryImportAvailable(
+		"svelte/compiler",
+		meta.supportedTranspilers.svelte,
+	),
+	swc: tryImportAvailable("@swc/core", meta.supportedTranspilers.swc),
+	typescript: tryImportAvailable(
+		"typescript",
+		meta.supportedTranspilers.typescript,
+	),
+	"vue-template-compiler": tryImportAvailable(
 		"vue-template-compiler",
 		meta.supportedTranspilers["vue-template-compiler"],
 	),
-	"@vue/compiler-sfc": tryAvailable(
+	"@vue/compiler-sfc": tryImportAvailable(
 		"@vue/compiler-sfc",
 		meta.supportedTranspilers["@vue/compiler-sfc"],
 	),

package/src/meta.cjs

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

package/src/report/error-html/error-html-template.mjs

@@ -159,6 +159,31 @@ export default `<!DOCTYPE html>
     .extra {
       color: gray;
     }
+    .dependency-type {
+      font-family: courier;
+      padding: 4px;
+      border-radius: 3px;
+    }
+    .local {
+      background-color: lightgray;
+      color: black;
+    }
+    .npm-bundled, .npm-dev, .npm-no-pkg, .npm-optional, .npm-peer, .npm-unknown, .npm {
+      background-color: darkred;
+      color: white;
+    }
+    .aliased {
+      background-color: blue;
+      color: white;
+    }
+    .aliased-subpath-import, .core {
+      background-color: green;
+      color: white;
+    }
+    .type-import, .type-only {
+      background-color: blue;
+      color: white;
+    }
   </style>
   <style type="text/css" media="print">
     th,

package/src/report/error-html/index.mjs

@@ -5,6 +5,7 @@ import {
 } from "./utl.mjs";
 import template from "./error-html-template.mjs";
 import meta from "#meta.cjs";
+import { getOneLetterDependencyType } from "#report/utl/index.mjs";
 
 function getViolatedRuleRowClass(pViolatedRule) {
 	return pViolatedRule.unviolated ? ' class="unviolated"' : "";
@@ -76,13 +77,13 @@ function constructViolatedRulesTable(pResults) {
 function getViolationRowClass(pViolation) {
 	return pViolation.rule.severity === "ignore" ? ' class="ignored"' : "";
 }
-
 /**
  * @param {import('../../../types/cruise-result.mjs').IViolation} pViolation
  * @returns {string}
  */
-function constructViolationRow(pPrefix) {
+function constructViolationRow(pPrefix, pOptions) {
 	return (pViolation) => {
+		const lDependencyTypes = pViolation?.dependencyTypes ?? [];
 		return `  <tr${getViolationRowClass(pViolation)}>
     <td class="${pViolation.rule.severity}">${pViolation.rule.severity}</td>
     <td class="nowrap">
@@ -93,7 +94,8 @@ function constructViolationRow(pPrefix) {
     <td><a href="${pPrefix}${pViolation.from}">${
 			pViolation.from
 		}</a>${determineFromExtras(pViolation)}</td>
-    <td>${determineTo(pViolation)}</td>
+    <td><span class="dependency-type ${lDependencyTypes.join(" ")}" title="dependency types: ${lDependencyTypes.join(", ")}">${getOneLetterDependencyType(lDependencyTypes)}</span></td>
+    <td>${determineTo(pViolation, pOptions)}</td>
   </tr>`;
 	};
 }
@@ -102,7 +104,7 @@ function constructViolationRow(pPrefix) {
  * @param {import('../../../types/cruise-result.mjs').ICruiseResult} pResults
  * @returns {string}
  */
-function constructViolationsList(pResults) {
+function constructViolationsList(pResults, pOptions) {
 	if (pResults.summary.violations.length > 0) {
 		return `<span id="show-ignored-violations">
       <h2><svg class="p__svg--inline" viewBox="0 0 12 16" version="1.1" aria-hidden="true">
@@ -116,17 +118,23 @@ function constructViolationsList(pResults) {
           <th>severity</th>
           <th>rule</th>
           <th>from</th>
+          <th>types</th>
           <th>to</th>
         </tr>
       </thead>
       <tbody>
       ${pResults.summary.violations
-				.map(constructViolationRow(pResults.summary.optionsUsed.prefix ?? ""))
+				.map(
+					constructViolationRow(
+						pResults.summary.optionsUsed.prefix ?? "",
+						pOptions,
+					),
+				)
 				.join("\n")}
       ${
 				pResults.summary.ignore > 0
 					? `<tr>
-        <td colspan="4" class="controls">
+        <td colspan="5" class="controls">
           <div id="show-ignored">
             &downarrow; <a href="#show-ignored-violations">also show ignored violations</a>
           </div>
@@ -149,7 +157,12 @@ function constructViolationsList(pResults) {
  * @param {import('../../../types/cruise-result.mjs')} pResults
  * @returns {string}
  */
-function report(pResults) {
+function report(pResults, pOptions) {
+	const lOptions = {
+		showExternalModulesUnresolved: false,
+		showAliasedModulesUnresolved: false,
+		...pOptions,
+	};
 	return template
 		.replace("{{totalCruised}}", pResults.summary.totalCruised)
 		.replace(
@@ -161,7 +174,7 @@ function report(pResults) {
 		.replace("{{info}}", pResults.summary.info)
 		.replace("{{ignore}}", pResults.summary.ignore ?? 0)
 		.replace("{{violatedRulesTable}}", constructViolatedRulesTable(pResults))
-		.replace("{{violationsList}}", constructViolationsList(pResults))
+		.replace("{{violationsList}}", constructViolationsList(pResults, lOptions))
 		.replace("{{depcruiseVersion}}", `dependency-cruiser@${meta.version}`)
 		.replace("{{runDate}}", new Date().toISOString());
 }
@@ -173,9 +186,9 @@ function report(pResults) {
  * @returns {import("../../../types/dependency-cruiser.js").IReporterOutput} - output: an html program showing the summary & the violations (if any)
  *                              exitCode: 0
  */
-export default function errorHtml(pResults) {
+export default function errorHtml(pResults, pOptions) {
 	return {
-		output: report(pResults),
+		output: report(pResults, pOptions || {}),
 		exitCode: 0,
 	};
 }

package/src/report/error-html/utl.mjs

@@ -1,4 +1,8 @@
-import { formatViolation, formatPercentage } from "../utl/index.mjs";
+import {
+	formatViolation,
+	formatPercentage,
+	formatDependencyTo,
+} from "../utl/index.mjs";
 import meta from "#meta.cjs";
 
 export function getFormattedAllowedRule(pRuleSetUsed) {
@@ -40,21 +44,17 @@ function formatReachabilityTo(pViolation) {
 		.join(" &rightarrow;<br/>")}`;
 }
 
-function formatDependencyTo(pViolation) {
-	return pViolation.to;
-}
-
 function formatModuleTo() {
 	return "";
 }
 
-function formatInstabilityTo(pViolation) {
-	return `${pViolation.to}&nbsp;<span class="extra">(I: ${formatPercentage(
+function formatInstabilityTo(pViolation, pOptions) {
+	return `${formatDependencyTo(pViolation, pOptions)}&nbsp;<span class="extra">(I: ${formatPercentage(
 		pViolation.metrics.to.instability,
 	)})</span>`;
 }
 
-export function determineTo(pViolation) {
+export function determineTo(pViolation, pOptions) {
 	const lViolationType2Formatter = {
 		dependency: formatDependencyTo,
 		module: formatModuleTo,
@@ -66,6 +66,7 @@ export function determineTo(pViolation) {
 		pViolation,
 		lViolationType2Formatter,
 		formatDependencyTo,
+		pOptions,
 	);
 }
 

package/src/report/error.mjs

@@ -3,6 +3,7 @@ import { styleText } from "node:util";
 import {
 	formatPercentage,
 	formatViolation as _formatViolation,
+	formatDependencyTo,
 } from "./utl/index.mjs";
 import { findRuleByName } from "#graph-utl/rule-set.mjs";
 import wrapAndIndent from "#utl/wrap-and-indent.mjs";
@@ -29,8 +30,8 @@ function formatModuleViolation(pViolation) {
 	return styleText("bold", pViolation.from);
 }
 
-function formatDependencyViolation(pViolation) {
-	return `${styleText("bold", pViolation.from)} → ${styleText("bold", pViolation.to)}`;
+function formatDependencyViolation(pViolation, pOptions) {
+	return `${styleText("bold", pViolation.from)} → ${styleText("bold", formatDependencyTo(pViolation, pOptions))}`;
 }
 
 function formatCycleViolation(pViolation) {
@@ -41,8 +42,8 @@ function formatReachabilityViolation(pViolation) {
 	return `${styleText("bold", pViolation.from)} → ${styleText("bold", pViolation.to)}${formatMiniDependency(pViolation.via)}`;
 }
 
-function formatInstabilityViolation(pViolation) {
-	return `${formatDependencyViolation(pViolation)}${EOL}${styleText(
+function formatInstabilityViolation(pViolation, pOptions) {
+	return `${formatDependencyViolation(pViolation, pOptions)}${EOL}${styleText(
 		"dim",
 		wrapAndIndent(
 			`instability: ${formatPercentage(pViolation.metrics.from.instability)} → ${formatPercentage(pViolation.metrics.to.instability)}`,
@@ -51,7 +52,7 @@ function formatInstabilityViolation(pViolation) {
 	)}`;
 }
 
-function formatViolation(pViolation) {
+function formatViolation(pViolation, pOptions) {
 	const lViolationType2Formatter = {
 		module: formatModuleViolation,
 		dependency: formatDependencyViolation,
@@ -63,6 +64,7 @@ function formatViolation(pViolation) {
 		pViolation,
 		lViolationType2Formatter,
 		formatDependencyViolation,
+		pOptions,
 	);
 
 	return (
@@ -115,7 +117,13 @@ function formatIgnoreWarning(pNumberOfIgnoredViolations) {
 	return "";
 }
 
-function report(pResults, pLong) {
+function report(pResults, pOptions) {
+	const lOptions = {
+		long: false,
+		showExternalModulesUnresolved: false,
+		showAliasedModulesUnresolved: false,
+		...pOptions,
+	};
 	const lNonIgnorableViolations = pResults.summary.violations.filter(
 		(pViolation) => pViolation.rule.severity !== "ignore",
 	);
@@ -132,8 +140,11 @@ function report(pResults, pLong) {
 
 	return lNonIgnorableViolations
 		.reverse()
-		.map(addExplanation(pResults.summary.ruleSetUsed, pLong))
-		.reduce((pAll, pThis) => `${pAll}  ${formatViolation(pThis)}${EOL}`, EOL)
+		.map(addExplanation(pResults.summary.ruleSetUsed, lOptions.long))
+		.reduce(
+			(pAll, pThis) => `${pAll}  ${formatViolation(pThis, lOptions)}${EOL}`,
+			EOL,
+		)
 		.concat(formatSummary(pResults.summary))
 		.concat(formatIgnoreWarning(pResults.summary.ignore))
 		.concat(EOL);
@@ -154,7 +165,7 @@ function report(pResults, pLong) {
  */
 export default function error(pResults, pOptions) {
 	return {
-		output: report(pResults, (pOptions || {}).long),
+		output: report(pResults, pOptions || {}),
 		exitCode: pResults.summary.error,
 	};
 }