feat(lint): implement event_base_class_suffix rule

Implements: #7

README.md

@@ -11,6 +11,7 @@ The example folder contains a dart project to unit test the rules. (see custom_l
 
 - [avoid_public_methods_on_bloc](docs/rules/avoid_public_methods_on_bloc.md)
 - [avoid_public_properties_on_bloc_and_cubit](docs/rules/avoid_public_properties_on_bloc_and_cubit.md)
+- [event_base_class_suffix](docs/rules/event_base_class_suffix.md)
 - [prefer_multi_bloc_listener](docs/rules/prefer_multi_bloc_listener.md)
 - [prefer_multi_bloc_provider](docs/rules/prefer_multi_bloc_provider.md)
 - [prefer_multi_repository_provider](docs/rules/prefer_multi_repository_provider.md)

docs/rules/event_base_class_suffix.md

@@ -0,0 +1,29 @@
+event_base_class_suffix
+===
+severity: WARNING
+
+The base event class should always be suffixed by `Event`.
+
+## Example:
+
+❌ **BAD**:
+
+```dart
+@immutable
+sealed class CounterData {}
+
+final class CounterStarted extends CounterData {}
+```
+
+✅ **GOOD**:
+
+```dart
+@immutable
+sealed class CounterEvent {}
+
+final class CounterStarted extends CounterEvent {}
+```
+
+## Additional Resources
+
+- [Bloc Library Documentation: Naming Conventions / Event Conventions](https://bloclibrary.dev/naming-conventions/#event-conventions)

example/lib/lint_rules/event_base_class_suffix_lint_rule_test_bloc.dart

@@ -0,0 +1,23 @@
+import 'package:bloc/bloc.dart';
+import 'package:meta/meta.dart';
+
+class EventBaseClassSuffixLintRuleTestBloc extends Bloc<
+// expect_lint: event_base_class_suffix
+    EventBaseClassSuffixLintRuleTestError,
+    EventBaseClassSuffixLintRuleTestState> {
+  EventBaseClassSuffixLintRuleTestBloc()
+      : super(EventBaseClassSuffixLintRuleTestInitial()) {
+    on<EventBaseClassSuffixLintRuleTestError>((event, emit) {
+      // TODO: implement event handler
+    });
+  }
+}
+
+@immutable
+sealed class EventBaseClassSuffixLintRuleTestError {}
+
+@immutable
+sealed class EventBaseClassSuffixLintRuleTestState {}
+
+final class EventBaseClassSuffixLintRuleTestInitial
+    extends EventBaseClassSuffixLintRuleTestState {}

lib/bloc_lint.dart

@@ -1,5 +1,6 @@
 import 'package:bloc_lint/lint_rules/avoid_public_methods_on_bloc_lint_rule.dart';
 import 'package:bloc_lint/lint_rules/avoid_public_properties_on_bloc_and_cubit_lint_rule.dart';
+import 'package:bloc_lint/lint_rules/event_base_class_suffix.dart';
 import 'package:bloc_lint/lint_rules/prefer_multi_bloc_listener_lint_rule.dart';
 import 'package:bloc_lint/lint_rules/prefer_multi_bloc_provider_lint_rule.dart';
 import 'package:bloc_lint/lint_rules/prefer_multi_repository_provider_lint_rule.dart';
@@ -13,6 +14,7 @@ class _BlocLintPlugin extends PluginBase {
   List<LintRule> getLintRules(CustomLintConfigs configs) => [
         const AvoidPublicMethodsOnBlocLintRule(),
         const AvoidPublicPropertiesOnBlocAndCubitLintRule(),
+        const EventBaseClassSuffix(),
         const PreferMultiBlocListenerLintRule(),
         const PreferMultiBlocProviderLintRule(),
         const PreferMultiRepositoryProviderLintRule(),

lib/lint_rules/event_base_class_suffix.dart

@@ -0,0 +1,56 @@
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/error/listener.dart';
+import 'package:bloc_lint/bloc_lint_constants.dart';
+import 'package:custom_lint_builder/custom_lint_builder.dart';
+
+class EventBaseClassSuffix extends DartLintRule {
+  const EventBaseClassSuffix()
+      : super(
+          code: const LintCode(
+            name: 'event_base_class_suffix',
+            problemMessage:
+                '''The base event class should always be suffixed by 'Event'.''',
+            errorSeverity: ErrorSeverity.WARNING,
+          ),
+        );
+
+  static const _ignoredType = [
+    'int',
+    'double',
+    'num',
+    'String',
+    'bool',
+    'List',
+    'Set',
+    'Map',
+  ];
+
+  @override
+  void run(
+    CustomLintResolver resolver,
+    ErrorReporter reporter,
+    CustomLintContext context,
+  ) {
+    context.registry.addExtendsClause((node) {
+      final superClass = node.superclass;
+      TypeAnnotation? stateNode;
+
+      if (superClass.element?.name == BlocLintConstants.blocClass) {
+        stateNode = superClass.typeArguments?.arguments[0];
+      }
+      if (stateNode == null) {
+        return;
+      }
+      final stateType = stateNode.type as InterfaceType?;
+      if (stateType == null || _ignoredType.contains(stateType.element.name)) {
+        return;
+      }
+
+      if (stateType.element.name.endsWith('Event') == false) {
+        reporter.atNode(stateNode, code);
+      }
+    });
+  }
+}