JS-1352 Allow customization of all analyzable file extensions via sonar properties (#6673)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: vdiez

its/ruling/src/test/expected/jquery/css-S4664.json

@@ -15,23 +15,19 @@
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
 import type { AnalysisInput, AnalysisOutput } from '../../../shared/src/types/analysis.js';
-import type { RuleConfig } from '../linter/config.js';
 import type { CssIssue } from '../linter/issues/issue.js';
+import type { FileType } from '../../../shared/src/helpers/files.js';
 
 /**
- * A CSS analysis input
+ * A CSS analysis input.
  *
- * A CSS analysis input only needs an input file and a set
- * of rule configurations to analyze a stylesheet.
+ * CSS analysis uses the global linter configuration initialized by
+ * `LinterWrapper.initialize()` in project analysis.
  *
- * When `rules` are provided (bridge per-request path), a fresh config is created.
- * When `rules` are absent (analyzeProject path), the linter must be pre-initialized.
- *
- * @param rules the rules from the active quality profile (optional when linter is pre-initialized)
+ * For TEST files, rules are overridden to an empty set internally.
  */
 export interface CssAnalysisInput extends AnalysisInput {
-  rules?: RuleConfig[];
-  fileType?: string;
+  fileType?: FileType;
 }
 
 /**
@@ -60,20 +56,12 @@ export interface CssSyntaxHighlight {
 /**
  * Metrics computed from a CSS source file.
  *
- * CSS files have limited metric semantics compared to JS/TS, so
- * functions, statements, classes, complexity, and cognitiveComplexity
- * are always 0. The primary metrics are ncloc and commentLines.
+ * CSS metrics only include line-based metrics and NOSONAR locations.
  */
 export interface CssMetrics {
-  ncloc: number[];
-  commentLines: number[];
+  ncloc?: number[];
+  commentLines?: number[];
   nosonarLines: number[];
-  executableLines: number[];
-  functions: number;
-  statements: number;
-  classes: number;
-  complexity: number;
-  cognitiveComplexity: number;
 }
 
 /**

its/ruling/src/test/expected/jquery/css-S4666.json

@@ -14,24 +14,17 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-import type { LinterOptions } from 'stylelint';
 import type { CssAnalysisInput, CssAnalysisOutput } from './analysis.js';
 import { linter } from '../linter/wrapper.js';
-import { createStylelintConfig } from '../linter/config.js';
 import { computeMetrics } from './metrics.js';
 import { computeHighlighting } from './highlighting.js';
 import { APIError } from '../../../shared/src/errors/error.js';
 import {
   toProjectFailureResult,
   type ProjectFailureResult,
 } from '../../../shared/src/errors/project-analysis.js';
-import { error, warn } from '../../../shared/src/helpers/logging.js';
+import { warn } from '../../../shared/src/helpers/logging.js';
 import type { CssIssue } from '../linter/issues/issue.js';
-import {
-  shouldIgnoreFile,
-  type ShouldIgnoreFileParams,
-} from '../../../shared/src/helpers/filter/filter.js';
-import { isAlsoCssFile } from '../../../shared/src/helpers/configuration.js';
 
 /**
  * Analyzes a CSS analysis input
@@ -42,73 +35,80 @@ import { isAlsoCssFile } from '../../../shared/src/helpers/configuration.js';
  *
  * The input must be fully sanitized (all fields required) before calling this function.
  *
- * When `input.rules` is provided (bridge per-request path), a fresh Stylelint
- * config is created from them. When absent (analyzeProject path), the linter's
- * pre-initialized config is used instead (see `LinterWrapper.initialize()`).
+ * Stylelint config comes from the pre-initialized linter
+ * (`LinterWrapper.initialize()`). For TEST files, rules are overridden to an
+ * empty config to suppress issues while preserving parsing/highlighting behavior.
+ * The CSS linter must be initialized before calling this function.
+ *
+ * Behavior:
+ *
+ * CSS in HTML/Vue MAIN: linted for issues, no CSS metrics.
+ * CSS in HTML/Vue TEST: not linted (noMetrics + TEST early return), so no CSS issues.
+ * Pure CSS MAIN: issues + metrics/highlighting.
+ * Pure CSS TEST: no issues/metrics, highlighting only
  *
  * @param input the sanitized CSS analysis input to analyze
- * @param shouldIgnoreParams parameters needed to determine whether a file should be ignored
+ * @param includeMetrics whether to include metrics calculation
  * @returns a promise of the CSS analysis output
  */
 export async function analyzeCSS(
   input: CssAnalysisInput,
-  shouldIgnoreParams: ShouldIgnoreFileParams,
+  includeMetrics = true,
 ): Promise<CssAnalysisOutput> {
-  const { filePath, fileContent, rules, fileType } = input;
-  if (await shouldIgnoreFile({ filePath, fileContent }, shouldIgnoreParams)) {
-    return { issues: [] };
-  }
+  const { filePath, fileContent, fileType } = input;
 
   const isTestFile = fileType === 'TEST';
-  const sanitizedCode = fileContent.replaceAll(/[\u2000-\u200F]/g, ' ');
-
-  // If rules are provided explicitly (bridge path), create a fresh config.
-  // Otherwise, use the linter's pre-initialized config (analyzeProject path).
-  const config = rules ? createStylelintConfig(rules) : undefined;
 
-  const options: LinterOptions = {
-    code: sanitizedCode,
-    codeFilename: filePath,
-    ...(config && { config }),
-  };
+  // Mixed-file CSS analysis (HTML/Vue) runs with noMetrics=true. For TEST files,
+  // preserve legacy behavior by skipping CSS linting entirely.
+  if (isTestFile && !includeMetrics) {
+    return { issues: [] };
+  }
+  const sanitizedCode = fileContent.replaceAll(/[\u2000-\u200F]/g, ' ');
 
-  // TEST files only get highlighting (matching old CssMetricSensor behavior).
-  // Old CssRuleSensor never analyzed TEST files for issues, but we still
-  // need to run Stylelint to get the PostCSS root for highlighting.
-  const { issues, root } = await linter.lint(filePath, options).catch(err => {
-    error(`Linter failed to parse file ${filePath}: ${err}`);
-    throw APIError.linterError(`Linter failed to parse file ${filePath}: ${err}`);
-  });
-  throwIfCssParsingError(issues);
+  // TEST files keep highlighting (parity with old CssMetricSensor), but issues remain suppressed.
+  const lintResult = await linter.lint(filePath, sanitizedCode, fileType);
+  const { root, issues: lintingIssues } = lintResult;
+  throwIfCssParsingError(lintingIssues);
+  const issues = isTestFile ? [] : lintingIssues;
 
-  // Skip metrics and highlighting in SonarLint mode and for non-pure-CSS files
+  // Skip metrics and highlighting for non-pure-CSS files
   // (HTML/Vue files are handled by their own analyzers for metrics)
-  if (input.sonarlint || isAlsoCssFile(filePath) || !root) {
-    return { issues: isTestFile ? [] : issues };
+  if (!includeMetrics || !root) {
+    return { issues };
   }
 
   try {
-    const highlights = computeHighlighting(root, sanitizedCode);
-    if (isTestFile) {
-      return { issues: [], highlights };
+    if (input.sonarlint) {
+      const metrics = computeMetrics(root);
+      // In SonarLint context, keep only NOSONAR lines (parity with JS/TS and old sensors).
+      return {
+        issues,
+        metrics: { nosonarLines: metrics.nosonarLines },
+      };
+    } else {
+      const highlights = computeHighlighting(root, sanitizedCode);
+      if (isTestFile) {
+        return { issues, highlights };
+      }
+      return {
+        issues,
+        highlights,
+        metrics: computeMetrics(root),
+      };
     }
-    return {
-      issues,
-      highlights,
-      metrics: computeMetrics(root),
-    };
   } catch (err) {
     warn(`Failed to compute metrics/highlighting for ${filePath}: ${err}`);
-    return { issues: isTestFile ? [] : issues };
+    return { issues };
   }
 }
 
 export async function analyzeCSSProject(
   input: CssAnalysisInput,
-  shouldIgnoreParams: ShouldIgnoreFileParams,
+  includeMetrics = true,
 ): Promise<CssAnalysisOutput | ProjectFailureResult> {
   try {
-    return await analyzeCSS(input, shouldIgnoreParams);
+    return await analyzeCSS(input, includeMetrics);
   } catch (err) {
     return toProjectFailureResult(err, 'css');
   }

its/ruling/src/test/expected/jquery/css-S4667.json

@@ -83,11 +83,5 @@ export function computeMetrics(root: Root | Document): CssMetrics {
     ncloc: Array.from(codeLines).sort((a, b) => a - b),
     commentLines: Array.from(commentCandidates).sort((a, b) => a - b),
     nosonarLines: nosonarLines.sort((a, b) => a - b),
-    executableLines: [],
-    functions: 0,
-    statements: 0,
-    classes: 0,
-    complexity: 0,
-    cognitiveComplexity: 0,
   };
 }