feat: create tag-name; create ban-name (#722)

* add doc

* add empty ban_name_rule

* add tests

* config parser

* implement rule (without visitor)

* try to implement visitor

* fix bugs

* enhance tests

* fix wrong ruleid

* change severity

* rephrase

* changelog

* add more tests

* scaffold for tag-name

* add tests

* partial impl

* more implementations

* pass tests

* enhance tests and still pass tests

* format code

* update changelog

* fix linter issue

* regsiter TagNameRule

* add stripPrefix, stripPostfix

* explain limitation

Co-authored-by: Dmitry Zhifarsky <dimannich2380@gmail.com>
Co-authored-by: Dmitry Krutskikh <dmitry.krutskikh@gmail.com>

Author: 3 people

.gitignore

@@ -2,6 +2,7 @@
 
 # JetBrains IDEs
 .idea/
+*.iml
 
 # Files and directories created by pub
 .dart_tool/

CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ## Unreleased
 
-* feat: add static code diagnostic `avoid-collection-methods-with-unrelated-types`
+* feat: add static code diagnostics `avoid-collection-methods-with-unrelated-types`, `ban-name`, `tag-name`.
 * fix: added parameter constant check in `avoid-border-all`.
 * chore: set min `mocktail` version to `^0.3.0`.
 

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

@@ -18,6 +18,7 @@ import 'rules_list/avoid_unnecessary_type_casts/avoid_unnecessary_type_casts_rul
 import 'rules_list/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule.dart';
 import 'rules_list/avoid_unused_parameters/avoid_unused_parameters_rule.dart';
 import 'rules_list/avoid_wrapping_in_padding/avoid_wrapping_in_padding_rule.dart';
+import 'rules_list/ban_name/ban_name_rule.dart';
 import 'rules_list/binary_expression_operand_order/binary_expression_operand_order_rule.dart';
 import 'rules_list/component_annotation_arguments_ordering/component_annotation_arguments_ordering_rule.dart';
 import 'rules_list/double_literal_format/double_literal_format_rule.dart';
@@ -45,6 +46,7 @@ import 'rules_list/prefer_on_push_cd_strategy/prefer_on_push_cd_strategy_rule.da
 import 'rules_list/prefer_single_widget_per_file/prefer_single_widget_per_file_rule.dart';
 import 'rules_list/prefer_trailing_comma/prefer_trailing_comma_rule.dart';
 import 'rules_list/provide_correct_intl_args/provide_correct_intl_args_rule.dart';
+import 'rules_list/tag_name/tag_name_rule.dart';
 
 final _implementedRules = <String, Rule Function(Map<String, Object>)>{
   AlwaysRemoveListenerRule.ruleId: (config) => AlwaysRemoveListenerRule(config),
@@ -80,6 +82,7 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
       AvoidUnusedParametersRule(config),
   AvoidWrappingInPaddingRule.ruleId: (config) =>
       AvoidWrappingInPaddingRule(config),
+  BanNameRule.ruleId: (config) => BanNameRule(config),
   BinaryExpressionOperandOrderRule.ruleId: (config) =>
       BinaryExpressionOperandOrderRule(config),
   ComponentAnnotationArgumentsOrderingRule.ruleId: (config) =>
@@ -119,6 +122,7 @@ final _implementedRules = <String, Rule Function(Map<String, Object>)>{
   PreferTrailingCommaRule.ruleId: (config) => PreferTrailingCommaRule(config),
   ProvideCorrectIntlArgsRule.ruleId: (config) =>
       ProvideCorrectIntlArgsRule(config),
+  TagNameRule.ruleId: (config) => TagNameRule(config),
 };
 
 Iterable<Rule> get allRules =>

lib/src/analyzers/lint_analyzer/rules/rules_list/ban_name/ban_name_rule.dart

@@ -0,0 +1,46 @@
+// 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 BanNameRule extends CommonRule {
+  static const String ruleId = 'ban-name';
+
+  final List<_BanNameConfigEntry> _entries;
+
+  BanNameRule([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 visitor = _Visitor(_entries);
+
+    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/ban_name/utils/config_parser.dart

@@ -0,0 +1,27 @@
+part of '../ban_name_rule.dart';
+
+const _entriesLabel = 'entries';
+const _identLabel = 'ident';
+const _descriptionLabel = 'description';
+
+/// Parser for rule configuration.
+class _ConfigParser {
+  static List<_BanNameConfigEntry> _parseEntryConfig(
+    Map<String, Object> config,
+  ) =>
+      (config[_entriesLabel] as Iterable<Object?>? ?? []).map((entry) {
+        final entryMap = entry as Map<Object?, Object?>;
+
+        return _BanNameConfigEntry(
+          ident: entryMap[_identLabel] as String,
+          description: entryMap[_descriptionLabel] as String,
+        );
+      }).toList();
+}
+
+class _BanNameConfigEntry {
+  final String ident;
+  final String description;
+
+  _BanNameConfigEntry({required this.ident, required this.description});
+}

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

@@ -0,0 +1,50 @@
+part of 'ban_name_rule.dart';
+
+class _Visitor extends RecursiveAstVisitor<void> {
+  final Map<String, _BanNameConfigEntry> _entryMap;
+
+  final _nodes = <_NodeWithMessage>[];
+
+  Iterable<_NodeWithMessage> get nodes => _nodes;
+
+  _Visitor(List<_BanNameConfigEntry> entries)
+      : _entryMap = Map.fromEntries(entries.map((e) => MapEntry(e.ident, e)));
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    super.visitSimpleIdentifier(node);
+    _visitIdent(node, node);
+  }
+
+  @override
+  void visitPrefixedIdentifier(PrefixedIdentifier node) {
+    super.visitPrefixedIdentifier(node);
+    _visitIdent(node, node.identifier);
+    _visitIdent(node, node.prefix);
+  }
+
+  @override
+  void visitLibraryIdentifier(LibraryIdentifier node) {
+    super.visitLibraryIdentifier(node);
+    for (final component in node.components) {
+      _visitIdent(node, component);
+    }
+  }
+
+  void _visitIdent(Expression node, SimpleIdentifier ident) {
+    final name = ident.name;
+    if (_entryMap.containsKey(name)) {
+      _nodes.add(_NodeWithMessage(
+        node,
+        '${_entryMap[name]!.description} ($name is banned)',
+      ));
+    }
+  }
+}
+
+class _NodeWithMessage {
+  final Expression node;
+  final String message;
+
+  _NodeWithMessage(this.node, this.message);
+}

lib/src/analyzers/lint_analyzer/rules/rules_list/tag_name/tag_name_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/replacement.dart';
+import '../../../models/severity.dart';
+import '../../models/common_rule.dart';
+import '../../rule_utils.dart';
+
+part 'visitor.dart';
+part 'utils/config_parser.dart';
+
+class TagNameRule extends CommonRule {
+  static const String ruleId = 'tag-name';
+
+  static const _warning = 'Tag name should match class name';
+
+  final _ParsedConfig _parsedConfig;
+
+  TagNameRule([Map<String, Object> config = const {}])
+      : _parsedConfig = _ConfigParser._parseConfig(config),
+        super(
+          id: ruleId,
+          severity: readSeverity(config, Severity.warning),
+          excludes: readExcludes(config),
+        );
+
+  @override
+  Iterable<Issue> check(InternalResolvedUnitResult source) {
+    final visitor = _Visitor(_parsedConfig);
+
+    source.unit.visitChildren(visitor);
+
+    return visitor.nodes
+        .map((node) => createIssue(
+              rule: this,
+              location: nodeLocation(
+                node: node.initializer,
+                source: source,
+              ),
+              message: _warning,
+              replacement: node.replacement,
+            ))
+        .toList(growable: false);
+  }
+}

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

@@ -0,0 +1,28 @@
+part of '../tag_name_rule.dart';
+
+const _varNamesLabel = 'var-names';
+const _stripPrefixLabel = 'strip-prefix';
+const _stripPostfixLabel = 'strip-postfix';
+
+/// Parser for rule configuration.
+class _ConfigParser {
+  static _ParsedConfig _parseConfig(Map<String, Object> value) => _ParsedConfig(
+        varNames: (value[_varNamesLabel] as List<Object>? ?? <Object>[])
+            .map((item) => item as String)
+            .toList(),
+        stripPrefix: value[_stripPrefixLabel] as String? ?? '',
+        stripPostfix: value[_stripPostfixLabel] as String? ?? '',
+      );
+}
+
+class _ParsedConfig {
+  final List<String> varNames;
+  final String stripPrefix;
+  final String stripPostfix;
+
+  _ParsedConfig({
+    required this.varNames,
+    required this.stripPrefix,
+    required this.stripPostfix,
+  });
+}

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

@@ -0,0 +1,73 @@
+part of 'tag_name_rule.dart';
+
+class _Visitor extends RecursiveAstVisitor<void> {
+  final _ParsedConfig _parsedConfig;
+
+  _Visitor(this._parsedConfig);
+
+  final _nodes = <_NodeWithMessage>[];
+
+  Iterable<_NodeWithMessage> get nodes => _nodes;
+
+  @override
+  void visitFieldDeclaration(FieldDeclaration node) {
+    super.visitFieldDeclaration(node);
+
+    for (final fieldVariable in node.fields.variables) {
+      _checkField(node, fieldVariable);
+    }
+  }
+
+  void _checkField(FieldDeclaration node, VariableDeclaration fieldVariable) {
+    final fieldName = fieldVariable.name.name;
+    final fieldType = fieldVariable.declaredElement?.type;
+
+    if (!(fieldType != null &&
+        fieldType.isDartCoreString &&
+        _parsedConfig.varNames.contains(fieldName))) {
+      return;
+    }
+
+    final fieldInitializer = fieldVariable.initializer;
+    if (fieldInitializer is! StringLiteral) {
+      return;
+    }
+    final fieldInitValue = fieldInitializer.stringValue;
+
+    final classDeclaration = node.thisOrAncestorOfType<ClassDeclaration>();
+    final className = classDeclaration?.name.name;
+    if (className == null) {
+      return;
+    }
+    final expectFieldValue = _calculateExpectFieldValue(className);
+
+    if (fieldInitValue != expectFieldValue) {
+      _nodes.add(_NodeWithMessage(
+        fieldInitializer,
+        Replacement(
+          comment: "Replace with '$expectFieldValue'",
+          replacement: "'$expectFieldValue'",
+        ),
+      ));
+    }
+  }
+
+  String _calculateExpectFieldValue(String className) {
+    var ans = className;
+    if (className.startsWith(_parsedConfig.stripPrefix)) {
+      ans = ans.substring(_parsedConfig.stripPrefix.length);
+    }
+    if (className.endsWith(_parsedConfig.stripPostfix)) {
+      ans = ans.substring(0, ans.length - _parsedConfig.stripPostfix.length);
+    }
+
+    return ans;
+  }
+}
+
+class _NodeWithMessage {
+  final StringLiteral initializer;
+  final Replacement replacement;
+
+  _NodeWithMessage(this.initializer, this.replacement);
+}

test/src/analyzers/lint_analyzer/rules/rules_list/ban_name/ban_name_rule_test.dart

@@ -0,0 +1,56 @@
+import 'package:dart_code_metrics/src/analyzers/lint_analyzer/models/severity.dart';
+import 'package:dart_code_metrics/src/analyzers/lint_analyzer/rules/rules_list/ban_name/ban_name_rule.dart';
+import 'package:test/test.dart';
+
+import '../../../../../helpers/rule_test_helper.dart';
+
+const _examplePath = 'ban_name/examples/example.dart';
+
+void main() {
+  group('BanNameRule', () {
+    test('initialization', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+      final issues = BanNameRule().check(unit);
+
+      RuleTestHelper.verifyInitialization(
+        issues: issues,
+        ruleId: 'ban-name',
+        severity: Severity.style,
+      );
+    });
+
+    test('reports about all found issues in example.dart', () async {
+      final unit = await RuleTestHelper.resolveFromFile(_examplePath);
+
+      final issues = BanNameRule({
+        'entries': [
+          {'ident': 'showDialog', 'description': 'Please use myShowDialog'},
+          {'ident': 'strangeName', 'description': 'The name is too strange'},
+          {'ident': 'AnotherStrangeName', 'description': 'Oops'},
+        ],
+      }).check(unit);
+
+      RuleTestHelper.verifyIssues(
+        issues: issues,
+        startLines: [6, 7, 9, 12, 15, 16],
+        startColumns: [3, 12, 7, 6, 7, 12],
+        locationTexts: [
+          'showDialog',
+          'showDialog',
+          'strangeName',
+          'strangeName',
+          'AnotherStrangeName',
+          'strangeName',
+        ],
+        messages: [
+          'Please use myShowDialog (showDialog is banned)',
+          'Please use myShowDialog (showDialog is banned)',
+          'The name is too strange (strangeName is banned)',
+          'The name is too strange (strangeName is banned)',
+          'Oops (AnotherStrangeName is banned)',
+          'The name is too strange (strangeName is banned)',
+        ],
+      );
+    });
+  });
+}