feat: add rules for leaf preview and lifecycle mixin singleton requirements

Author: mcquenji

README.md

@@ -2,16 +2,68 @@
 
 Lint rules for using [Grumpy](https://github.com/necodeIT/grumpy) architecture correctly.
 
+## Installation
+
+To use the recommended lint rules drop the following into your `analysis_options.yaml`
+
+```yaml
+plugins:
+  grumpy_lints:
+    diagnostics:
+			leaf_preview_must_not_use_injectables_or_navigation: true
+			must_call_in_constructor: true
+			abstract_classes_should_set_log_group: true
+			concrete_classes_should_set_log_tag: true
+			base_class: true
+			domain_factory_from_di: true
+			prefer_domain_di_factory: true
+			lifecycle_mixin_requires_singleton: true
+```
+
+
 ## Rules
 
 | Rule | Overview | Severity | Fix Available | Codes |
 | --- | --- | --- | --- | --- |
+| [leaf_preview_must_not_use_injectables_or_navigation](#leaf_preview_must_not_use_injectables_or_navigation) | Leaf.preview must remain side-effect free: do not resolve/use injectables or navigation APIs in preview, including through reachable helper calls. | WARNING | ❌ | 1 |
 | [must_call_in_constructor](#must_call_in_constructor) | Requires constructors to call methods annotated with @mustCallInConstructor from supertypes or mixins. It respects concreteOnly (abstract classes must not call those methods) and exempt (subtypes listed as exempt must not call the method at all). | ERROR | ✅ | 6 |
 | [abstract_classes_should_set_log_group](#abstract_classes_should_set_log_group) | Abstract classes that mix in LogMixin must override `group` to return their class name. If they extend another abstract LogMixin class, they must append their class name to `super.group` to keep group names hierarchical. | INFO | ✅ | 1 |
 | [concrete_classes_should_set_log_tag](#concrete_classes_should_set_log_tag) | Concrete (non-abstract) classes that mix in LogMixin must override `logTag` to return their own class name. This applies even when inheriting from another LogMixin class so each class logs with a specific tag. | INFO | ✅ | 1 |
 | [base_class](#base_class) | Enforces the BaseClass contract: subclasses must live in allowed layers, use the base class name as a suffix when forceSuffix is true, reside in the configured type directory with a snake_case filename, be the only class in the file, and any class inside the type directory must extend the base class. Test files are exempt. | INFO | ❌ | 6 |
-| [domain_factory_from_di](#domain_factory_from_di) | Requires domain services and datasources (excluding base classes) to declare an unnamed factory constructor that resolves the implementation from DI. | INFO | ✅ | 1 |
+| [domain_factory_from_di](#domain_factory_from_di) | Requires domain services and datasources (excluding base classes) to declare an unnamed factory constructor that retrieves the implementation from DI. | INFO | ✅ | 1 |
 | [prefer_domain_di_factory](#prefer_domain_di_factory) | Prefer using the domain contract factory constructor over direct DI access (Service.get/Datasource.get) outside the domain layer. | INFO | ✅ | 1 |
+| [lifecycle_mixin_requires_singleton](#lifecycle_mixin_requires_singleton) | Classes that combine Injectable and LifecycleMixin must resolve as singletons by returning true from singelton. | ERROR | ❌ | 1 |
+
+
+
+### leaf_preview_must_not_use_injectables_or_navigation
+
+Leaf.preview must remain side-effect free: do not resolve/use injectables or navigation APIs in preview, including through reachable helper calls.
+#### Codes
+- `leaf_preview_must_not_use_injectables_or_navigation` (WARNING)
+
+#### Examples
+**❌ DON'T**
+```dart
+class HomeLeaf extends Leaf<String> {
+  @override
+  String preview(RouteContext ctx) {
+    final api = Service.get<NetworkService>();
+    return api.toString();
+  }
+}
+
+```
+
+**✅ DO**
+```dart
+class HomeLeaf extends Leaf<String> {
+  @override
+  String preview(RouteContext ctx) => 'loading';
+}
+
+```
+
 
 
 
@@ -297,25 +349,28 @@ abstract class UserService {}
 
 
 
+
 ### domain_factory_from_di
 
-Requires domain services and datasources (excluding base classes) to declare an unnamed factory constructor that resolves the implementation from DI.
+Requires domain services and datasources (excluding base classes) to declare an unnamed factory constructor that retrieves the implementation from DI.
 #### Codes
 - `domain_factory_from_di_missing_factory` (INFO)
 
 #### Examples
 **❌ DON'T**
 ```dart
-// Missing factory constructor.
+// BAD: missing factory constructor
 abstract class RoutingService<T, Config> extends Service {}
 
 ```
 
 **✅ DO**
 ```dart
-// Factory constructor resolves from DI.
+// GOOD: factory constructor resolves from DI
 abstract class RoutingService<T, Config> extends Service {
   /// Returns the DI-registered implementation of [RoutingService].
+///
+/// Shorthand for [Service.get]
   factory RoutingService() {
     return Service.get<RoutingService<T, Config>>();
   }
@@ -325,6 +380,7 @@ abstract class RoutingService<T, Config> extends Service {
 
 
 
+
 ### prefer_domain_di_factory
 
 Prefer using the domain contract factory constructor over direct DI access (Service.get/Datasource.get) outside the domain layer.
@@ -334,14 +390,41 @@ Prefer using the domain contract factory constructor over direct DI access (Serv
 #### Examples
 **❌ DON'T**
 ```dart
-// Direct DI access from a non-domain layer.
 final routing = Service.get<RoutingService>();
 
 ```
 
 **✅ DO**
 ```dart
-// Use the domain factory constructor.
 final routing = RoutingService();
 
 ```
+
+
+
+
+### lifecycle_mixin_requires_singleton
+
+Classes that combine Injectable and LifecycleMixin must resolve as singletons by returning true from singelton.
+#### Codes
+- `lifecycle_mixin_requires_singleton` (ERROR)
+
+#### Examples
+**❌ DON'T**
+```dart
+class RoutingService with LifecycleMixin implements Injectable {
+  @override
+  bool get singelton => false;
+}
+
+```
+
+**✅ DO**
+```dart
+class RoutingService with LifecycleMixin implements Injectable {
+  @override
+  bool get singelton => true;
+}
+
+```
+

README.template

@@ -2,6 +2,18 @@
 
 Lint rules for using [Grumpy](https://github.com/necodeIT/grumpy) architecture correctly.
 
+## Installation
+
+To use the recommended lint rules drop the following into your `analysis_options.yaml`
+
+```yaml
+plugins:
+  grumpy_lints:
+    diagnostics:
+{{yaml_rules(4)}}
+```
+
+
 ## Rules
 
 {{rules(3)}}

bin/readme.dart

@@ -7,9 +7,9 @@ void main(List<String> args) {
   final f = File('README.template');
   var template = f.readAsStringSync();
 
-  final regex = RegExp(r"{{rules\((\d*)\)}}");
+  final rulesRegex = RegExp(r"{{rules\((\d*)\)}}");
 
-  final match = regex.firstMatch(template)!;
+  final match = rulesRegex.firstMatch(template)!;
 
   final count = int.parse(match.group(1) ?? '0');
 
@@ -65,7 +65,17 @@ void main(List<String> args) {
     rulesBuffer.writeln('$subHeaderLevel Examples\n$examples\n');
   }
 
-  template = template.replaceFirst(regex, rulesBuffer.toString());
+  template = template.replaceFirst(rulesRegex, rulesBuffer.toString());
+
+  final yamlRulesRegex = RegExp(r"{{yaml_rules\((\d*)\)}}");
+
+  final yamlMatch = yamlRulesRegex.firstMatch(template)!;
+
+  final indent = '\t' * int.parse(match.group(1) ?? '0');
+
+  final yamlRules = rules.map((r) => '$indent${r.name}: true').join('\n');
+
+  template = template.replaceFirst(yamlRulesRegex, yamlRules);
 
   final outputFile = File('README.md');
   outputFile.writeAsStringSync(template);

lib/main.dart

@@ -5,6 +5,8 @@ import 'package:grumpy_lints/src/rules/abstract_classes_should_set_log_group_rul
 import 'package:grumpy_lints/src/rules/base_class_rule.dart';
 import 'package:grumpy_lints/src/rules/concrete_classes_should_set_log_tag_rule.dart';
 import 'package:grumpy_lints/src/rules/domain_factory_from_di_rule.dart';
+import 'package:grumpy_lints/src/rules/leaf_preview_must_not_use_injectables_or_navigation_rule.dart';
+import 'package:grumpy_lints/src/rules/lifecycle_mixin_requires_singleton_rule.dart';
 import 'package:grumpy_lints/src/rules/prefer_domain_di_factory_rule.dart';
 import 'package:grumpy_lints/src/rules/must_call_in_constructor_rule.dart';
 
@@ -14,14 +16,17 @@ class GrumpyLints extends Plugin {
   @override
   String get name => 'grumpy';
 
-  static List<GrumpyRule> warnings = [];
+  static List<GrumpyRule> warnings = [
+    LeafPreviewMustNotUseInjectablesOrNavigationRule(),
+  ];
   static List<GrumpyRule> errors = [
     MustCallInConstructorRule(),
     AbstractClassesShouldSetLogGroupRule(),
     ConcreteClassesShouldSetLogTagRule(),
     BaseClassRule(),
     DomainFactoryFromDiRule(),
     PreferDomainDiFactoryRule(),
+    LifecycleMixinRequiresSingletonRule(),
   ];
 
   @override