feat: add new rule avoid-banned-imports & modify prefer-extracting-callbacks allow short callbacks to exist

CHANGELOG.md

@@ -5,6 +5,7 @@
 * test: added test case in [`prefer-const-border-radius`](https://dartcodemetrics.dev/docs/rules/flutter/prefer-const-border-radius) rule.
 * chore: restrict `analyzer` version to `>=2.4.0 <4.2.0`.
 * fix: improve context root included files calculation.
+* feat: add [`avoid-banned-imports`](https://dartcodemetrics.dev/docs/rules/common/avoid-banned-imports) rule
 
 ## 4.15.2
 

lib/src/analyzers/lint_analyzer/rules/rules_factory.dart

@@ -1,5 +1,6 @@
 import 'models/rule.dart';
 import 'rules_list/always_remove_listener/always_remove_listener_rule.dart';
+import 'rules_list/avoid_banned_imports/avoid_banned_imports_rule.dart';
 import 'rules_list/avoid_border_all/avoid_border_all_rule.dart';
 import 'rules_list/avoid_collection_methods_with_unrelated_types/avoid_collection_methods_with_unrelated_types_rule.dart';
 import 'rules_list/avoid_dynamic/avoid_dynamic_rule.dart';
@@ -54,6 +55,7 @@ import 'rules_list/tag_name/tag_name_rule.dart';
 
 final _implementedRules = <String, Rule Function(Map<String, Object>)>{
   AlwaysRemoveListenerRule.ruleId: (config) => AlwaysRemoveListenerRule(config),
+  AvoidBannedImportsRule.ruleId: (config) => AvoidBannedImportsRule(config),
   AvoidBorderAllRule.ruleId: (config) => AvoidBorderAllRule(config),
   AvoidCollectionMethodsWithUnrelatedTypesRule.ruleId: (config) =>
       AvoidCollectionMethodsWithUnrelatedTypesRule(config),

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_banned_imports/avoid_banned_imports_rule.dart

@@ -0,0 +1,51 @@
+// ignore_for_file: public_member_api_docs
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+
+import '../../../../../utils/node_utils.dart';
+import '../../../lint_utils.dart';
+import '../../../models/internal_resolved_unit_result.dart';
+import '../../../models/issue.dart';
+import '../../../models/severity.dart';
+import '../../models/common_rule.dart';
+import '../../rule_utils.dart';
+
+part 'visitor.dart';
+
+part 'utils/config_parser.dart';
+
+class AvoidBannedImportsRule extends CommonRule {
+  static const String ruleId = 'avoid-banned-imports';
+
+  final List<_AvoidBannedImportsConfigEntry> _entries;
+
+  AvoidBannedImportsRule([Map<String, Object> config = const {}])
+      : _entries = _ConfigParser._parseEntryConfig(config),
+        super(
+          id: ruleId,
+          severity: readSeverity(config, Severity.style),
+          excludes: readExcludes(config),
+        );
+
+  @override
+  Iterable<Issue> check(InternalResolvedUnitResult source) {
+    final activeEntries = _entries
+        .where((entry) => entry.paths.any((path) => path.hasMatch(source.path)))
+        .toList();
+
+    final visitor = _Visitor(activeEntries);
+
+    source.unit.visitChildren(visitor);
+
+    return visitor.nodes
+        .map(
+          (node) => createIssue(
+            rule: this,
+            location: nodeLocation(node: node.node, source: source),
+            message: node.message,
+          ),
+        )
+        .toList(growable: false);
+  }
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_banned_imports/utils/config_parser.dart

@@ -0,0 +1,40 @@
+part of '../avoid_banned_imports_rule.dart';
+
+const _entriesLabel = 'entries';
+const _pathsLabel = 'paths';
+const _denyLabel = 'deny';
+const _messageLabel = 'message';
+
+/// Parser for rule configuration.
+class _ConfigParser {
+  static List<_AvoidBannedImportsConfigEntry> _parseEntryConfig(
+    Map<String, Object> config,
+  ) =>
+      (config[_entriesLabel] as Iterable<Object?>? ?? []).map((entry) {
+        final entryMap = entry as Map<Object?, Object?>;
+
+        return _AvoidBannedImportsConfigEntry(
+          paths: _parseListRegExp(entryMap[_pathsLabel]),
+          deny: _parseListRegExp(entryMap[_denyLabel]),
+          message: entryMap[_messageLabel] as String,
+        );
+      }).toList();
+
+  static List<RegExp> _parseListRegExp(Object? object) =>
+      (object! as List<Object?>)
+          .map((e) => e! as String)
+          .map((e) => RegExp(e))
+          .toList();
+}
+
+class _AvoidBannedImportsConfigEntry {
+  final List<RegExp> paths;
+  final List<RegExp> deny;
+  final String message;
+
+  _AvoidBannedImportsConfigEntry({
+    required this.paths,
+    required this.deny,
+    required this.message,
+  });
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_banned_imports/visitor.dart

@@ -0,0 +1,35 @@
+part of 'avoid_banned_imports_rule.dart';
+
+class _Visitor extends RecursiveAstVisitor<void> {
+  final List<_AvoidBannedImportsConfigEntry> _activeEntries;
+
+  final _nodes = <_NodeWithMessage>[];
+
+  Iterable<_NodeWithMessage> get nodes => _nodes;
+
+  _Visitor(this._activeEntries);
+
+  @override
+  void visitImportDirective(ImportDirective node) {
+    final uri = node.uri.stringValue;
+    if (uri == null) {
+      return;
+    }
+
+    for (final entry in _activeEntries) {
+      if (entry.deny.any((deny) => deny.hasMatch(uri))) {
+        _nodes.add(_NodeWithMessage(
+          node,
+          'Avoid banned imports (${entry.message})',
+        ));
+      }
+    }
+  }
+}
+
+class _NodeWithMessage {
+  final AstNode node;
+  final String message;
+
+  _NodeWithMessage(this.node, this.message);
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_extracting_callbacks/config_parser.dart

@@ -2,10 +2,16 @@ part of 'prefer_extracting_callbacks_rule.dart';
 
 class _ConfigParser {
   static const _ignoredArgumentsConfig = 'ignored-named-arguments';
+  static const _allowedLineCountConfig = 'allowed-line-count';
 
   static Iterable<String> parseIgnoredArguments(Map<String, Object> config) =>
       config.containsKey(_ignoredArgumentsConfig) &&
               config[_ignoredArgumentsConfig] is Iterable
           ? List<String>.from(config[_ignoredArgumentsConfig] as Iterable)
           : <String>[];
+
+  static int? parseAllowedLineCount(Map<String, Object> config) {
+    final raw = config[_allowedLineCountConfig];
+    return raw is int? ? raw : null;
+  }
 }

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_extracting_callbacks/prefer_extracting_callbacks_rule.dart

@@ -6,6 +6,7 @@ import 'package:analyzer/dart/ast/visitor.dart';
 import '../../../../../utils/flutter_types_utils.dart';
 import '../../../../../utils/node_utils.dart';
 import '../../../lint_utils.dart';
+import '../../../metrics/metrics_list/source_lines_of_code/source_code_visitor.dart';
 import '../../../models/internal_resolved_unit_result.dart';
 import '../../../models/issue.dart';
 import '../../../models/severity.dart';
@@ -22,9 +23,11 @@ class PreferExtractingCallbacksRule extends FlutterRule {
       'Prefer extracting the callback to a separate widget method.';
 
   final Iterable<String> _ignoredArguments;
+  final int? _allowedLineCount;
 
   PreferExtractingCallbacksRule([Map<String, Object> config = const {}])
       : _ignoredArguments = _ConfigParser.parseIgnoredArguments(config),
+        _allowedLineCount = _ConfigParser.parseAllowedLineCount(config),
         super(
           id: ruleId,
           severity: readSeverity(config, Severity.style),
@@ -33,7 +36,7 @@ class PreferExtractingCallbacksRule extends FlutterRule {
 
   @override
   Iterable<Issue> check(InternalResolvedUnitResult source) {
-    final visitor = _Visitor(_ignoredArguments);
+    final visitor = _Visitor(source, _ignoredArguments, _allowedLineCount);
 
     source.unit.visitChildren(visitor);
 

lib/src/analyzers/lint_analyzer/rules/rules_list/prefer_extracting_callbacks/visitor.dart

@@ -3,11 +3,13 @@ part of 'prefer_extracting_callbacks_rule.dart';
 class _Visitor extends SimpleAstVisitor<void> {
   final _expressions = <Expression>[];
 
+  final InternalResolvedUnitResult _source;
   final Iterable<String> _ignoredArguments;
+  final int? _allowedLineCount;
 
   Iterable<Expression> get expressions => _expressions;
 
-  _Visitor(this._ignoredArguments);
+  _Visitor(this._source, this._ignoredArguments, this._allowedLineCount);
 
   @override
   void visitClassDeclaration(ClassDeclaration node) {
@@ -17,7 +19,8 @@ class _Visitor extends SimpleAstVisitor<void> {
       return;
     }
 
-    final visitor = _InstanceCreationVisitor(_ignoredArguments);
+    final visitor =
+        _InstanceCreationVisitor(_source, _ignoredArguments, _allowedLineCount);
     node.visitChildren(visitor);
 
     _expressions.addAll(visitor.expressions);
@@ -27,11 +30,14 @@ class _Visitor extends SimpleAstVisitor<void> {
 class _InstanceCreationVisitor extends RecursiveAstVisitor<void> {
   final _expressions = <Expression>[];
 
+  final InternalResolvedUnitResult _source;
   final Iterable<String> _ignoredArguments;
+  final int? _allowedLineCount;
 
   Iterable<Expression> get expressions => _expressions;
 
-  _InstanceCreationVisitor(this._ignoredArguments);
+  _InstanceCreationVisitor(
+      this._source, this._ignoredArguments, this._allowedLineCount);
 
   @override
   void visitInstanceCreationExpression(InstanceCreationExpression node) {
@@ -44,7 +50,8 @@ class _InstanceCreationVisitor extends RecursiveAstVisitor<void> {
       if (_isNotIgnored(argument) &&
           expression is FunctionExpression &&
           _hasNotEmptyBlockBody(expression) &&
-          !_isFlutterBuilder(expression)) {
+          !_isFlutterBuilder(expression) &&
+          _isLongEnough(expression)) {
         _expressions.add(argument);
       }
     }
@@ -74,4 +81,16 @@ class _InstanceCreationVisitor extends RecursiveAstVisitor<void> {
   bool _isNotIgnored(Expression argument) =>
       argument is! NamedExpression ||
       !_ignoredArguments.contains(argument.name.label.name);
+
+  bool _isLongEnough(Expression expression) {
+    final allowedLineCount = _allowedLineCount;
+    if (allowedLineCount == null) {
+      return true;
+    }
+
+    final visitor = SourceCodeVisitor(_source.lineInfo);
+    expression.visitChildren(visitor);
+
+    return visitor.linesWithCode.length > allowedLineCount;
+  }
 }

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_banned_imports/avoid_banned_imports_rule_test.dart

@@ -0,0 +1,55 @@
+import 'package:dart_code_metrics/src/analyzers/lint_analyzer/models/severity.dart';
+import 'package:dart_code_metrics/src/analyzers/lint_analyzer/rules/rules_list/avoid_banned_imports/avoid_banned_imports_rule.dart';
+import 'package:test/test.dart';
+
+import '../../../../../helpers/rule_test_helper.dart';
+
+const _examplePath = 'avoid_banned_imports/examples/example.dart';
+
+void main() {
+  group('AvoidBannedImportsRule', () {
+    test('initialization', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = AvoidBannedImportsRule().check(unit);
+
+      RuleTestHelper.verifyInitialization(
+        issues: issues,
+        ruleId: 'avoid-banned-imports',
+        severity: Severity.style,
+      );
+    });
+
+    test('reports about all found issues in example.dart', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+
+      final issues = AvoidBannedImportsRule({
+        'entries': <Object>[
+          <String, Object>{
+            'paths': [
+              r'.*examples.*\.dart',
+            ],
+            'deny': [
+              'package:flutter/.*',
+              'package:my_app/ban_folder/.*',
+            ],
+            'message': 'sample message',
+          },
+        ],
+      }).check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startLines: [1, 4],
+        startColumns: [1, 1],
+        locationTexts: [
+          "import 'package:flutter/material.dart';",
+          "import 'package:my_app/ban_folder/something.dart';",
+        ],
+        messages: [
+          'Avoid banned imports (sample message)',
+          'Avoid banned imports (sample message)',
+        ],
+      );
+    });
+  });
+}

test/src/analyzers/lint_analyzer/rules/rules_list/avoid_banned_imports/examples/example.dart

@@ -0,0 +1,5 @@
+import 'package:flutter/material.dart'; // LINT
+import 'package:good_package/good_file.dart';
+
+import 'package:my_app/ban_folder/something.dart'; // LINT
+import 'package:my_app/good_folder/something.dart';

test/src/analyzers/lint_analyzer/rules/rules_list/prefer_extracting_callbacks/examples/example_max_line_count.dart

@@ -0,0 +1,59 @@
+class MyWidget extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    const a = TextButton(
+      onPressed: () => null,
+      child: Container(),
+    );
+
+    const b = TextButton(
+      onPressed: () {
+        firstLine();
+        secondLine();
+        thirdLine();
+      },
+      child: Container(),
+    );
+
+    const c = TextButton(
+      // LINT
+      onPressed: () {
+        firstLine();
+        secondLine();
+        thirdLine();
+        fourthLine();
+      },
+      child: Container(),
+    );
+
+    return Container();
+  }
+}
+
+class Widget {}
+
+class StatelessWidget extends Widget {}
+
+class BuildContext {}
+
+class Container extends Widget {
+  final Widget? child;
+
+  const Container({this.child});
+}
+
+class TextButton {
+  final Widget child;
+  final void Function()? onPressed;
+  final Widget Function(BuildContext)? builder;
+  final Widget Function(BuildContext, int)? anotherBuilder;
+  final MyOtherWidget Function(BuildContext, int)? myOtherWidgetBuilder;
+
+  const TextButton({
+    required this.child,
+    required this.onPressed,
+    this.builder,
+    this.anotherBuilder,
+    this.myOtherWidgetBuilder,
+  });
+}