feat: add validation for rule names in analysis_options (#1059)

Author: incendial

CHANGELOG.md

@@ -14,6 +14,7 @@
 * feat: **Breaking change** cleanup public API.
 * chore: restrict `analyzer` version to `>=5.1.0 <5.3.0`.
 * feat: add `print-config` option to all commands.
+* feat: add validation for rule names in `analysis_options.yaml` both for the `analyze` command and the plugin.
 * feat: support `includes` in the rules config.
 * fix: ignore `@override` methods for [`avoid-redundant-async`](https://dartcodemetrics.dev/docs/rules/common/avoid-redundant-async).
 

example/example.dart

@@ -24,6 +24,7 @@ Future<void> main() async {
     },
     antiPatterns: {'long-method': {}},
     shouldPrintConfig: false,
+    analysisOptionsPath: '',
   );
 
   const analyzer = LintAnalyzer();

lib/src/analyzer_plugin/analyzer_plugin.dart

@@ -8,6 +8,7 @@ import 'package:analyzer_plugin/plugin/plugin.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 
 import '../analyzers/lint_analyzer/lint_analysis_config.dart';
+import '../analyzers/lint_analyzer/lint_analysis_options_validator.dart';
 import '../analyzers/lint_analyzer/lint_analyzer.dart';
 import '../analyzers/lint_analyzer/metrics/metrics_list/number_of_parameters_metric.dart';
 import '../analyzers/lint_analyzer/metrics/metrics_list/source_lines_of_code/source_lines_of_code_metric.dart';
@@ -28,7 +29,7 @@ class AnalyzerPlugin extends ServerPlugin {
       'https://github.com/dart-code-checker/dart-code-metrics/issues';
 
   @override
-  List<String> get fileGlobsToAnalyze => const ['*.dart'];
+  List<String> get fileGlobsToAnalyze => const ['*.dart', '*.yaml'];
 
   @override
   String get name => 'Dart Code Metrics $packageVersion';
@@ -62,15 +63,21 @@ class AnalyzerPlugin extends ServerPlugin {
       return;
     }
 
+    final rootPath = analysisContext.contextRoot.root.path;
+    if (path.endsWith('analysis_options.yaml')) {
+      final config = _configs[rootPath];
+      if (config != null) {
+        _validateAnalysisOptions(config, rootPath);
+      }
+    }
+
     try {
       final resolvedUnit =
           await analysisContext.currentSession.getResolvedUnit(path);
 
       if (resolvedUnit is ResolvedUnitResult) {
-        final analysisErrors = _getErrorsForResolvedUnit(
-          resolvedUnit,
-          analysisContext.contextRoot.root.path,
-        );
+        final analysisErrors =
+            _getErrorsForResolvedUnit(resolvedUnit, rootPath);
 
         channel.sendNotification(
           plugin.AnalysisErrorsParams(
@@ -181,6 +188,31 @@ class AnalyzerPlugin extends ServerPlugin {
       );
 
       _configs[rootPath] = lintConfig;
+
+      _validateAnalysisOptions(lintConfig, rootPath);
     }
   }
+
+  void _validateAnalysisOptions(LintAnalysisConfig config, String rootPath) {
+    if (config.analysisOptionsPath == null) {
+      return;
+    }
+
+    final result = <plugin.AnalysisErrorFixes>[];
+
+    final report =
+        LintAnalysisOptionsValidator.validateOptions(config, rootPath);
+    if (report != null) {
+      result.addAll(report.issues.map(
+        (issue) => codeIssueToAnalysisErrorFixes(issue, null),
+      ));
+    }
+
+    channel.sendNotification(
+      plugin.AnalysisErrorsParams(
+        config.analysisOptionsPath!,
+        result.map((analysisError) => analysisError.error).toList(),
+      ).toNotification(),
+    );
+  }
 }

lib/src/analyzers/lint_analyzer/lint_analysis_config.dart

@@ -17,6 +17,7 @@ class LintAnalysisConfig {
   final Iterable<Glob> metricsExcludes;
   final Map<String, Object> metricsConfig;
   final String rootFolder;
+  final String? analysisOptionsPath;
 
   const LintAnalysisConfig(
     this.globalExcludes,
@@ -29,6 +30,7 @@ class LintAnalysisConfig {
     this.metricsExcludes,
     this.metricsConfig,
     this.rootFolder,
+    this.analysisOptionsPath,
   );
 
   Map<String, Object?> toJson() => {
@@ -42,5 +44,6 @@ class LintAnalysisConfig {
         'file-metrics': fileMetrics.map((metric) => metric.id).toList(),
         'metrics-excludes':
             metricsExcludes.map((glob) => glob.pattern).toList(),
+        'analysis-options-path': analysisOptionsPath,
       };
 }

lib/src/analyzers/lint_analyzer/lint_analysis_options_validator.dart

@@ -0,0 +1,114 @@
+import 'dart:io';
+
+import 'package:collection/collection.dart';
+import 'package:path/path.dart';
+import 'package:source_span/source_span.dart';
+import 'package:yaml/yaml.dart';
+
+import 'lint_analysis_config.dart';
+import 'models/issue.dart';
+import 'models/lint_file_report.dart';
+import 'models/severity.dart';
+
+class LintAnalysisOptionsValidator {
+  static LintFileReport? validateOptions(
+    LintAnalysisConfig config,
+    String rootFolder,
+  ) {
+    final path = config.analysisOptionsPath;
+    final file = path != null && File(path).existsSync() ? File(path) : null;
+    if (file == null) {
+      return null;
+    }
+
+    final fileContent = file.readAsStringSync();
+    final node = loadYamlNode(fileContent);
+    final rulesList = _getRulesList(node);
+    if (rulesList == null) {
+      return null;
+    }
+
+    final parsedRuleIds = config.codeRules.map((rule) => rule.id).toList();
+    final issues = <Issue>[];
+
+    for (final rule in rulesList) {
+      if (!parsedRuleIds.contains(rule.ruleName)) {
+        issues.add(
+          Issue(
+            ruleId: 'unknown-config',
+            severity: Severity.warning,
+            message:
+                "'${rule.ruleName}' is not recognized as a valid rule name.",
+            documentation: Uri.parse('https://dartcodemetrics.dev/docs/rules'),
+            location: _copySpanWithOffset(rule.span),
+          ),
+        );
+      }
+    }
+
+    if (issues.isNotEmpty) {
+      final filePath = file.path;
+      final relativePath = relative(filePath, from: rootFolder);
+
+      return LintFileReport.onlyIssues(
+        path: file.path,
+        relativePath: relativePath,
+        issues: issues,
+      );
+    }
+
+    return null;
+  }
+
+  static List<_RuleWithSpan>? _getRulesList(YamlNode node) {
+    if (node is YamlMap) {
+      final rules =
+          (node['dart_code_metrics'] as YamlMap?)?['rules'] as YamlNode?;
+      if (rules is YamlList) {
+        return rules.nodes
+            // ignore: avoid_types_on_closure_parameters
+            .map((Object? rule) {
+              if (rule is YamlMap) {
+                final key = rule.nodes.keys.first as Object?;
+                if (key is YamlScalar && key.value is String) {
+                  return _RuleWithSpan(key.value as String, key.span);
+                }
+              }
+
+              if (rule is YamlScalar && rule.value is String) {
+                return _RuleWithSpan(rule.value as String, rule.span);
+              }
+
+              return null;
+            })
+            .whereNotNull()
+            .toList();
+      }
+    }
+
+    return null;
+  }
+
+  static SourceSpan _copySpanWithOffset(SourceSpan span) => SourceSpan(
+        SourceLocation(
+          span.start.offset,
+          sourceUrl: span.start.sourceUrl,
+          line: span.start.line + 1,
+          column: span.start.column + 1,
+        ),
+        SourceLocation(
+          span.end.offset,
+          sourceUrl: span.end.sourceUrl,
+          line: span.end.line + 1,
+          column: span.end.column + 1,
+        ),
+        span.text,
+      );
+}
+
+class _RuleWithSpan {
+  final String ruleName;
+  final SourceSpan span;
+
+  const _RuleWithSpan(this.ruleName, this.span);
+}

lib/src/analyzers/lint_analyzer/lint_analyzer.dart

@@ -14,6 +14,7 @@ import '../../utils/exclude_utils.dart';
 import '../../utils/node_utils.dart';
 import '../../utils/suppression.dart';
 import 'lint_analysis_config.dart';
+import 'lint_analysis_options_validator.dart';
 import 'lint_config.dart';
 import 'metrics/metrics_list/cyclomatic_complexity/cyclomatic_complexity_metric.dart';
 import 'metrics/metrics_list/source_lines_of_code/source_lines_of_code_metric.dart';
@@ -85,6 +86,14 @@ class LintAnalyzer {
       final lintAnalysisConfig =
           _getAnalysisConfig(context, rootFolder, config);
 
+      final report = LintAnalysisOptionsValidator.validateOptions(
+        lintAnalysisConfig,
+        rootFolder,
+      );
+      if (report != null) {
+        analyzerResult.add(report);
+      }
+
       if (config.shouldPrintConfig) {
         _logger?.printConfig(lintAnalysisConfig.toJson());
       }
@@ -244,7 +253,6 @@ class LintAnalyzer {
     return LintFileReport.onlyIssues(
       path: filePath,
       relativePath: relativePath,
-      file: _getEmptyFileReport(internalResult),
       issues: issues,
     );
   }
@@ -371,14 +379,6 @@ class LintAnalyzer {
     );
   }
 
-  Report _getEmptyFileReport(InternalResolvedUnitResult internalResult) =>
-      Report(
-        location:
-            nodeLocation(node: internalResult.unit, source: internalResult),
-        metrics: const [],
-        declaration: internalResult.unit,
-      );
-
   Map<ScopedFunctionDeclaration, Report> _checkFunctionMetrics(
     ScopeVisitor visitor,
     InternalResolvedUnitResult source,

lib/src/analyzers/lint_analyzer/lint_config.dart

@@ -12,6 +12,7 @@ class LintConfig {
   final Iterable<String> excludeForRulesPatterns;
   final Map<String, Map<String, Object>> antiPatterns;
   final bool shouldPrintConfig;
+  final String? analysisOptionsPath;
 
   const LintConfig({
     required this.excludePatterns,
@@ -21,6 +22,7 @@ class LintConfig {
     required this.excludeForRulesPatterns,
     required this.antiPatterns,
     required this.shouldPrintConfig,
+    required this.analysisOptionsPath,
   });
 
   /// Creates the config from analysis [options].
@@ -35,6 +37,7 @@ class LintConfig {
         antiPatterns:
             options.readMapOfMap(['anti-patterns'], packageRelated: true),
         shouldPrintConfig: false,
+        analysisOptionsPath: options.fullPath,
       );
 
   /// Creates the config from cli [arguments].
@@ -51,6 +54,7 @@ class LintConfig {
         rules: const {},
         excludeForRulesPatterns: const [],
         antiPatterns: const {},
+        analysisOptionsPath: null,
       );
 
   /// Merges two configs into a single one
@@ -74,5 +78,7 @@ class LintConfig {
         antiPatterns:
             mergeMaps(defaults: antiPatterns, overrides: overrides.antiPatterns)
                 .cast<String, Map<String, Object>>(),
+        analysisOptionsPath:
+            analysisOptionsPath ?? overrides.analysisOptionsPath,
       );
 }

lib/src/analyzers/lint_analyzer/models/lint_file_report.dart

@@ -13,7 +13,7 @@ class LintFileReport implements FileReport {
   final String relativePath;
 
   /// The metrics report about the target file.
-  final Report file;
+  final Report? file;
 
   /// The all classes reports in the target file.
   final Map<String, Report> classes;
@@ -40,9 +40,9 @@ class LintFileReport implements FileReport {
   const LintFileReport.onlyIssues({
     required this.path,
     required this.relativePath,
-    required this.file,
     required this.issues,
   })  : classes = const {},
         functions = const {},
-        antiPatternCases = const {};
+        antiPatternCases = const {},
+        file = null;
 }

lib/src/analyzers/lint_analyzer/reporters/reporters_list/checkstyle/lint_checkstyle_reporter.dart

@@ -65,17 +65,20 @@ class LintCheckstyleReporter
   }
 
   void _reportMetrics(XmlBuilder builder, LintFileReport record) {
-    for (final metric in record.file.metrics) {
-      if (_isMetricNeedToReport(metric.level)) {
-        builder.element(
-          'error',
-          attributes: {
-            'line': '0',
-            'severity': _metricSeverityMapping[metric.level] ?? 'ignore',
-            'message': metric.comment,
-            'source': metric.metricsId,
-          },
-        );
+    final metrics = record.file?.metrics;
+    if (metrics != null) {
+      for (final metric in metrics) {
+        if (_isMetricNeedToReport(metric.level)) {
+          builder.element(
+            'error',
+            attributes: {
+              'line': '0',
+              'severity': _metricSeverityMapping[metric.level] ?? 'ignore',
+              'message': metric.comment,
+              'source': metric.metricsId,
+            },
+          );
+        }
       }
     }
 
@@ -107,7 +110,7 @@ class LintCheckstyleReporter
   bool _needToReport(LintFileReport report) =>
       report.issues.isNotEmpty ||
       report.antiPatternCases.isNotEmpty ||
-      _isMetricNeedToReport(report.file.metricsLevel);
+      (report.file != null && _isMetricNeedToReport(report.file!.metricsLevel));
 
   bool _isMetricNeedToReport(MetricValueLevel level) =>
       level > MetricValueLevel.none;