fix: improve file metrics (#579)

Author: dkrutskikh

CHANGELOG.md

@@ -5,6 +5,7 @@
 * feat: add alphabetical sorting by type for `member-ordering-extended` rule.
 * feat: add support mixins, extensions and enums for `prefer-match-file-name` rule.
 * fix: prefer conditional expressions rule breaks code with increment / decrement operators.
+* fix: improve file metrics.
 * chore: restrict `analyzer` version to `>=2.4.0 <2.9.0`.
 * chore: tune GitHub workflows.
 

lib/src/analyzers/lint_analyzer/lint_analyzer.dart

@@ -194,7 +194,7 @@ class LintAnalyzer {
         final classMetrics =
             _checkClassMetrics(visitor, internalResult, config);
 
-        final fileMetrics = _checkFileMetrics(internalResult);
+        final fileMetrics = _checkFileMetrics(visitor, internalResult, config);
 
         final functionMetrics =
             _checkFunctionMetrics(visitor, internalResult, config);
@@ -322,9 +322,31 @@ class LintAnalyzer {
     return classRecords;
   }
 
-  Report _checkFileMetrics(InternalResolvedUnitResult source) {
+  Report _checkFileMetrics(
+    ScopeVisitor visitor,
+    InternalResolvedUnitResult source,
+    LintAnalysisConfig config,
+  ) {
     final metrics = <MetricValue<num>>[];
 
+    for (final metric in config.fileMetrics) {
+      if (metric.supports(
+        source.unit,
+        visitor.classes,
+        visitor.functions,
+        source,
+        metrics,
+      )) {
+        metrics.add(metric.compute(
+          source.unit,
+          visitor.classes,
+          visitor.functions,
+          source,
+          metrics,
+        ));
+      }
+    }
+
     return Report(
       location: nodeLocation(node: source.unit, source: source),
       declaration: source.unit,

lib/src/analyzers/lint_analyzer/metrics/metric_utils.dart

@@ -15,12 +15,21 @@ Uri documentation(String metricId) => Uri(
 T? readNullableThreshold<T extends num>(
   Map<String, Object?> config,
   String metricId,
-) {
+) =>
+    readConfigValue<T>(config, metricId, 'threshold') ??
+    readConfigValue<T>(config, metricId);
+
+/// Returns a nullable value from [config] for metric with [metricId]
+T? readConfigValue<T extends Object>(
+  Map<String, Object?> config,
+  String metricId, [
+  String? valueName,
+]) {
   final metricConfig = config[metricId];
 
   final configValue = metricConfig is Map<String, Object?>
-      ? metricConfig['threshold']?.toString()
-      : metricConfig?.toString();
+      ? metricConfig[valueName]?.toString()
+      : (valueName == null ? metricConfig?.toString() : null);
 
   if (configValue != null && T == int) {
     return int.tryParse(configValue) as T?;

test/src/analyzers/lint_analyzer/metrics/metric_utils_test.dart

@@ -55,6 +55,32 @@ void main() {
       expect(readNullableThreshold<int>(_config, metricId5), isNull);
     });
 
+    test('readConfigValue returns a value from Map based config', () {
+      const metricId3 = 'metric-id-3';
+      const metricId4 = 'metric-id-4';
+      const metricId5 = 'metric-id-5';
+
+      const metricId1Value = 10;
+      const metricId2Value = 0.5;
+
+      const _config = {
+        metricId1: '$metricId1Value',
+        metricId2: {'value': '$metricId1Value'},
+        metricId3: {'value': '$metricId2Value'},
+        metricId4: null,
+      };
+
+      expect(readConfigValue<int>(_config, metricId1, 'value'), isNull);
+
+      expect(readConfigValue<int>(_config, metricId2, 'value'), equals(10));
+
+      expect(readConfigValue<double>(_config, metricId3, 'value'), equals(0.5));
+
+      expect(readConfigValue<double>(_config, metricId4, 'value'), isNull);
+
+      expect(readConfigValue<int>(_config, metricId5, 'value'), isNull);
+    });
+
     test('valueLevel returns a level of passed value', () {
       expect(valueLevel(null, 10), equals(MetricValueLevel.none));
       expect(valueLevel(30, null), equals(MetricValueLevel.none));

test/src/analyzers/lint_analyzer/rules/rules_factory_test.dart

@@ -40,15 +40,20 @@ void main() {
         'avoid-nested-conditional-expressions': <String, Object>{},
         'prefer-const-border-radius': <String, Object>{},
         'prefer-correct-identifier-length': <String, Object>{},
+        'avoid-missing-enum-constant-in-map': <String, Object>{},
+        'avoid-throw-in-catch-block': <String, Object>{},
+        'prefer-correct-type-name': <String, Object>{},
       }).map((rule) => rule.id),
       equals([
         'always-remove-listener',
         'avoid-ignoring-return-values',
         'avoid-late-keyword',
+        'avoid-missing-enum-constant-in-map',
         'avoid-nested-conditional-expressions',
         'avoid-non-null-assertion',
         'avoid-preserve-whitespace-false',
         'avoid-returning-widgets',
+        'avoid-throw-in-catch-block',
         'avoid-unnecessary-setstate',
         'avoid-unused-parameters',
         'avoid-wrapping-in-padding',
@@ -67,6 +72,7 @@ void main() {
         'prefer-conditional-expressions',
         'prefer-const-border-radius',
         'prefer-correct-identifier-length',
+        'prefer-correct-type-name',
         'prefer-extracting-callbacks',
         'prefer-intl-name',
         'prefer-match-file-name',