diff --git a/lib/import_resolver.dart b/lib/import_resolver.dart index f7f22c6..a5f7ef4 100644 --- a/lib/import_resolver.dart +++ b/lib/import_resolver.dart @@ -1,14 +1,14 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:path/path.dart' as p; class ImportResolver { - final List libs; + final List libs; final String targetFilePath; const ImportResolver(this.libs, this.targetFilePath); - String? resolve(Element2? element) { + String? resolve(Element? element) { // return early if source is null or element is a core type final elementSourceUri = _sourceUriOfElement(element); if (elementSourceUri == null || _isCoreDartType(element)) { @@ -49,7 +49,7 @@ class ImportResolver { Set resolveAll(DartType type) { final imports = {}; - final resolvedValue = resolve(type.element3); + final resolvedValue = resolve(type.element); if (resolvedValue != null) { imports.add(resolvedValue); } @@ -61,7 +61,7 @@ class ImportResolver { final imports = {}; if (typeToCheck is ParameterizedType) { for (DartType type in typeToCheck.typeArguments) { - final resolvedValue = resolve(type.element3); + final resolvedValue = resolve(type.element); if (resolvedValue != null) { imports.add(resolvedValue); } diff --git a/lib/src/generators/bottomsheets/resolve/bottomsheet_config_resolver.dart b/lib/src/generators/bottomsheets/resolve/bottomsheet_config_resolver.dart index 155c0ae..107f195 100644 --- a/lib/src/generators/bottomsheets/resolve/bottomsheet_config_resolver.dart +++ b/lib/src/generators/bottomsheets/resolve/bottomsheet_config_resolver.dart @@ -1,5 +1,5 @@ import 'package:analyzer/dart/constant/value.dart'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; import 'package:stacked_generator/src/generators/bottomsheets/bottomsheet_config.dart'; @@ -21,15 +21,19 @@ class BottomsheetConfigResolver { final bottomsheetClassType = bottomsheetReader.read('classType').typeValue; - final classElement = bottomsheetClassType.element3 as ClassElement2?; + final classElement = bottomsheetClassType.element as ClassElement?; // Get the import of the class type that's defined for the bottomSheet final import = importResolver.resolve(classElement!); final className = toDisplayString(bottomsheetClassType); - bottomSheetConfig.add(BottomsheetConfig( - bottomsheetClassName: className, import: import ?? '')); + bottomSheetConfig.add( + BottomsheetConfig( + bottomsheetClassName: className, + import: import ?? '', + ), + ); } return bottomSheetConfig; diff --git a/lib/src/generators/bottomsheets/resolve/stacked_bottomsheet_generator.dart b/lib/src/generators/bottomsheets/resolve/stacked_bottomsheet_generator.dart index 1ed1a45..d44cfb0 100644 --- a/lib/src/generators/bottomsheets/resolve/stacked_bottomsheet_generator.dart +++ b/lib/src/generators/bottomsheets/resolve/stacked_bottomsheet_generator.dart @@ -1,6 +1,6 @@ import 'dart:async'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; @@ -12,7 +12,7 @@ import 'bottomsheet_config_resolver.dart'; class StackedBottomsheetGenerator extends GeneratorForAnnotation { @override FutureOr generateForAnnotatedElement( - Element2 element, + Element element, ConstantReader annotation, BuildStep buildStep, ) async { @@ -35,7 +35,9 @@ class StackedBottomsheetGenerator extends GeneratorForAnnotation { importResolver, ); - return BottomsheetClassGenerator(dialogConfig, locatorName: locatorName) - .generate(); + return BottomsheetClassGenerator( + dialogConfig, + locatorName: locatorName, + ).generate(); } } diff --git a/lib/src/generators/dialogs/resolve/dialog_config_resolver.dart b/lib/src/generators/dialogs/resolve/dialog_config_resolver.dart index 85b1019..189a523 100644 --- a/lib/src/generators/dialogs/resolve/dialog_config_resolver.dart +++ b/lib/src/generators/dialogs/resolve/dialog_config_resolver.dart @@ -1,5 +1,5 @@ import 'package:analyzer/dart/constant/value.dart'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; import 'package:stacked_generator/src/generators/dialogs/dialog_config.dart'; @@ -21,17 +21,16 @@ class DialogConfigResolver { // Get the type of the dialog that we want to register final dialogClassType = dialogReader.read('classType').typeValue; - final classElement = dialogClassType.element3 as ClassElement2?; + final classElement = dialogClassType.element as ClassElement?; // Get the import of the class type that's defined for the dialog final import = importResolver.resolve(classElement!); final className = toDisplayString(dialogClassType); - dialogConfigs.add(DialogConfig( - dialogClassName: className, - import: import ?? '', - )); + dialogConfigs.add( + DialogConfig(dialogClassName: className, import: import ?? ''), + ); } return dialogConfigs; diff --git a/lib/src/generators/dialogs/resolve/stacked_dialog_generator.dart b/lib/src/generators/dialogs/resolve/stacked_dialog_generator.dart index 687dda9..f55034f 100644 --- a/lib/src/generators/dialogs/resolve/stacked_dialog_generator.dart +++ b/lib/src/generators/dialogs/resolve/stacked_dialog_generator.dart @@ -1,6 +1,6 @@ import 'dart:async'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; @@ -12,7 +12,7 @@ import 'dialog_config_resolver.dart'; class StackedDialogGenerator extends GeneratorForAnnotation { @override FutureOr generateForAnnotatedElement( - Element2 element, + Element element, ConstantReader annotation, BuildStep buildStep, ) async { @@ -30,12 +30,11 @@ class StackedDialogGenerator extends GeneratorForAnnotation { if (dialogsConfig == null) return ''; - final dialogConfig = dialogResolver.resolve( - dialogsConfig, - importResolver, - ); + final dialogConfig = dialogResolver.resolve(dialogsConfig, importResolver); - return DialogClassGenerator(dialogConfig, locatorName: locatorName) - .generate(); + return DialogClassGenerator( + dialogConfig, + locatorName: locatorName, + ).generate(); } } diff --git a/lib/src/generators/exceptions/invalid_generator_input_exception.dart b/lib/src/generators/exceptions/invalid_generator_input_exception.dart index 2f9b825..bff1ef5 100644 --- a/lib/src/generators/exceptions/invalid_generator_input_exception.dart +++ b/lib/src/generators/exceptions/invalid_generator_input_exception.dart @@ -1,9 +1,9 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; class InvalidGeneratorInputException implements Exception { final String message; final String? todo; - final Element2? element; + final Element? element; const InvalidGeneratorInputException(this.message, {this.todo, this.element}); @override diff --git a/lib/src/generators/forms/field_config.dart b/lib/src/generators/forms/field_config.dart index e41ee67..211483e 100644 --- a/lib/src/generators/forms/field_config.dart +++ b/lib/src/generators/forms/field_config.dart @@ -1,6 +1,6 @@ // ignore_for_file: unnecessary_this -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; /// Described a single field to be generated. /// @@ -55,7 +55,8 @@ class ExecutableElementData { }); factory ExecutableElementData.fromExecutableElement( - ExecutableElement executableElement) { + ExecutableElement executableElement, + ) { final enclosingElementName = executableElement.enclosingElement?.name; return ExecutableElementData( returnType: executableElement.returnType.toString(), diff --git a/lib/src/generators/forms/stacked_form_generator.dart b/lib/src/generators/forms/stacked_form_generator.dart index 150f040..d5780ec 100644 --- a/lib/src/generators/forms/stacked_form_generator.dart +++ b/lib/src/generators/forms/stacked_form_generator.dart @@ -1,7 +1,7 @@ import 'dart:async'; import 'package:analyzer/dart/constant/value.dart'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; @@ -14,14 +14,16 @@ class StackedFormGenerator extends GeneratorForAnnotation { @override FutureOr generateForAnnotatedElement( // ignore: avoid_renaming_method_parameters - Element2 classForAnnotation, + Element classForAnnotation, // ignore: avoid_renaming_method_parameters ConstantReader formView, BuildStep buildStep, ) async { var libs = await buildStep.resolver.libraries.toList(); - var importResolver = - ImportResolver(libs, classForAnnotation.firstFragment.libraryFragment?.source.uri.path ?? ''); + var importResolver = ImportResolver( + libs, + classForAnnotation.firstFragment.libraryFragment?.source.uri.path ?? '', + ); final viewName = classForAnnotation.displayName; @@ -32,10 +34,12 @@ class StackedFormGenerator extends GeneratorForAnnotation { if (fieldsConfig != null) { for (final fieldConfig in fieldsConfig) { - final serialisedField = _readFieldConfig( - fieldConfig: fieldConfig, importResolver: importResolver); + final serializedField = _readFieldConfig( + fieldConfig: fieldConfig, + importResolver: importResolver, + ); - fields.add(serialisedField); + fields.add(serializedField); } } @@ -55,28 +59,31 @@ FieldConfig _readFieldConfig({ }) { var fieldReader = ConstantReader(fieldConfig); - bool isTextField = fieldReader.instanceOf(const TypeChecker.typeNamed( - FormTextField, - inPackage: 'stacked_shared', - )); - bool isDateField = fieldReader.instanceOf(const TypeChecker.typeNamed( - FormDateField, - inPackage: 'stacked_shared', - )); - bool isDropdownField = fieldReader.instanceOf(const TypeChecker.typeNamed( - FormDropdownField, - inPackage: 'stacked_shared', - )); + bool isTextField = fieldReader.instanceOf( + const TypeChecker.typeNamed(FormTextField, inPackage: 'stacked_shared'), + ); + bool isDateField = fieldReader.instanceOf( + const TypeChecker.typeNamed(FormDateField, inPackage: 'stacked_shared'), + ); + bool isDropdownField = fieldReader.instanceOf( + const TypeChecker.typeNamed(FormDropdownField, inPackage: 'stacked_shared'), + ); if (isTextField) { return _readTextFieldConfig( - fieldReader: fieldReader, importResolver: importResolver); + fieldReader: fieldReader, + importResolver: importResolver, + ); } else if (isDateField) { return _readDateFieldConfig( - fieldReader: fieldReader, importResolver: importResolver); + fieldReader: fieldReader, + importResolver: importResolver, + ); } else if (isDropdownField) { return _readDropdownFieldConfig( - fieldReader: fieldReader, importResolver: importResolver); + fieldReader: fieldReader, + importResolver: importResolver, + ); } else { throw ArgumentError('Unknown form field $fieldConfig'); } @@ -88,21 +95,24 @@ FieldConfig _readTextFieldConfig({ }) { final String name = (fieldReader.peek('name')?.stringValue) ?? ''; final String? initialValue = (fieldReader.peek('initialValue')?.stringValue); - final ExecutableElement2? validatorFunction = - (fieldReader.peek('validator')?.objectValue)?.toFunctionValue2(); - final ExecutableElement2? customTextEditingController = + final ExecutableElement? validatorFunction = + (fieldReader.peek('validator')?.objectValue)?.toFunctionValue(); + final ExecutableElement? customTextEditingController = (fieldReader.peek('customTextEditingController')?.objectValue) - ?.toFunctionValue2(); + ?.toFunctionValue(); return TextFieldConfig( name: name, initialValue: initialValue, - validatorFunction: validatorFunction == null - ? null - : ExecutableElementData.fromExecutableElement(validatorFunction), - customTextEditingController: customTextEditingController == null - ? null - : ExecutableElementData.fromExecutableElement( - customTextEditingController), + validatorFunction: + validatorFunction == null + ? null + : ExecutableElementData.fromExecutableElement(validatorFunction), + customTextEditingController: + customTextEditingController == null + ? null + : ExecutableElementData.fromExecutableElement( + customTextEditingController, + ), ); } @@ -111,9 +121,7 @@ FieldConfig _readDateFieldConfig({ required ImportResolver importResolver, }) { final String name = (fieldReader.peek('name')?.stringValue) ?? ''; - return DateFieldConfig( - name: name, - ); + return DateFieldConfig(name: name); } FieldConfig _readDropdownFieldConfig({ @@ -123,15 +131,12 @@ FieldConfig _readDropdownFieldConfig({ final String name = (fieldReader.peek('name')?.stringValue) ?? ''; final List items = (fieldReader.peek('items')?.listValue.map((dartObject) { - final itemReader = ConstantReader(dartObject); - final title = itemReader.peek('title')?.stringValue ?? ''; - final value = itemReader.peek('value')?.stringValue ?? ''; + final itemReader = ConstantReader(dartObject); + final title = itemReader.peek('title')?.stringValue ?? ''; + final value = itemReader.peek('value')?.stringValue ?? ''; - return DropdownFieldItem(title: title, value: value); - }).toList()) ?? - []; - return DropdownFieldConfig( - name: name, - items: items, - ); + return DropdownFieldItem(title: title, value: value); + }).toList()) ?? + []; + return DropdownFieldConfig(name: name, items: items); } diff --git a/lib/src/generators/getit/dependency_config_factory.dart b/lib/src/generators/getit/dependency_config_factory.dart index 4f984b2..02cce15 100644 --- a/lib/src/generators/getit/dependency_config_factory.dart +++ b/lib/src/generators/getit/dependency_config_factory.dart @@ -1,5 +1,5 @@ import 'package:analyzer/dart/constant/value.dart'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; @@ -34,49 +34,51 @@ class DependencyConfigFactory { final DartType dependencyClassType = dependencyReader.read('classType').typeValue; - final String? instanceName = dependencyReader.read('instanceName').isNull - ? null - : dependencyReader.read('instanceName').stringValue; + final String? instanceName = + dependencyReader.read('instanceName').isNull + ? null + : dependencyReader.read('instanceName').stringValue; final DartType? dependencyAbstractedClassType = dependencyReader.peek('asType')?.typeValue; - final classElement = dependencyClassType.element3 as ClassElement2?; + final classElement = dependencyClassType.element as ClassElement?; throwIf( classElement == null, '🛑 ${toDisplayString(dependencyClassType)} is not a class element. All services should be classes. We don\'t register individual values for global access through the locator. Make sure the value provided as your service type is a class.', ); - final Set? environments = dependencyReader - .peek('environments') - ?.setValue - .map((e) => e.toStringValue()) - .where((element) => element != null) - .toSet() - .cast(); + final Set? environments = + dependencyReader + .peek('environments') + ?.setValue + .map((e) => e.toStringValue()) + .where((element) => element != null) + .toSet() + .cast(); // Get the import of the class type that's defined for the service final import = importResolver.resolve(classElement!); final abstractedClassElement = - dependencyAbstractedClassType?.element3 as ClassElement2?; + dependencyAbstractedClassType?.element as ClassElement?; final abstractedImport = importResolver.resolve(abstractedClassElement); final className = toDisplayString(dependencyClassType); - final abstractedTypeClassName = dependencyAbstractedClassType != null - ? toDisplayString(dependencyAbstractedClassType) - : null; + final abstractedTypeClassName = + dependencyAbstractedClassType != null + ? toDisplayString(dependencyAbstractedClassType) + : null; // NOTE: This can be used for actual dependency inject. We do service location instead. - final constructor = classElement.unnamedConstructor2; + final constructor = classElement.unnamedConstructor; - if (dependencyReader.instanceOf(const TypeChecker.typeNamed( - Factory, - inPackage: 'stacked_shared', - ))) { + if (dependencyReader.instanceOf( + const TypeChecker.typeNamed(Factory, inPackage: 'stacked_shared'), + )) { return FactoryDependency( instanceName: instanceName, import: import!, @@ -85,53 +87,56 @@ class DependencyConfigFactory { abstractedImport: abstractedImport, environments: environments, ); - } else if (dependencyReader.instanceOf(const TypeChecker.typeNamed( - Singleton, - inPackage: 'stacked_shared', - ))) { - final ConstantReader? resolveUsing = - dependencyReader.peek('resolveUsing'); - final resolveObject = resolveUsing?.objectValue.toFunctionValue2(); + } else if (dependencyReader.instanceOf( + const TypeChecker.typeNamed(Singleton, inPackage: 'stacked_shared'), + )) { + final ConstantReader? resolveUsing = dependencyReader.peek( + 'resolveUsing', + ); + final resolveObject = resolveUsing?.objectValue.toFunctionValue(); return SingletonDependency( - instanceName: instanceName, - import: import!, - className: className, - abstractedTypeClassName: abstractedTypeClassName, - abstractedImport: abstractedImport, - environments: environments, - resolveFunction: resolveObject?.displayName); - } else if (dependencyReader.instanceOf(const TypeChecker.typeNamed( - LazySingleton, - inPackage: 'stacked_shared', - ))) { - final ConstantReader? resolveUsing = - dependencyReader.peek('resolveUsing'); - final resolveObject = resolveUsing?.objectValue.toFunctionValue2(); + instanceName: instanceName, + import: import!, + className: className, + abstractedTypeClassName: abstractedTypeClassName, + abstractedImport: abstractedImport, + environments: environments, + resolveFunction: resolveObject?.displayName, + ); + } else if (dependencyReader.instanceOf( + const TypeChecker.typeNamed(LazySingleton, inPackage: 'stacked_shared'), + )) { + final ConstantReader? resolveUsing = dependencyReader.peek( + 'resolveUsing', + ); + final resolveObject = resolveUsing?.objectValue.toFunctionValue(); return LazySingletonDependency( - instanceName: instanceName, - import: import!, - className: className, - abstractedTypeClassName: abstractedTypeClassName, - abstractedImport: abstractedImport, - environments: environments, - resolveFunction: resolveObject?.displayName); - } else if (dependencyReader.instanceOf(const TypeChecker.typeNamed( - Presolve, - inPackage: 'stacked_shared', - ))) { - final ConstantReader? presolveUsing = - dependencyReader.peek('presolveUsing'); - final presolveObject = presolveUsing?.objectValue.toFunctionValue2(); + instanceName: instanceName, + import: import!, + className: className, + abstractedTypeClassName: abstractedTypeClassName, + abstractedImport: abstractedImport, + environments: environments, + resolveFunction: resolveObject?.displayName, + ); + } else if (dependencyReader.instanceOf( + const TypeChecker.typeNamed(Presolve, inPackage: 'stacked_shared'), + )) { + final ConstantReader? presolveUsing = dependencyReader.peek( + 'presolveUsing', + ); + final presolveObject = presolveUsing?.objectValue.toFunctionValue(); return PresolveSingletonDependency( - instanceName: instanceName, - import: import!, - className: className, - abstractedTypeClassName: abstractedTypeClassName, - abstractedImport: abstractedImport, - environments: environments, - presolveFunction: presolveObject?.displayName); + instanceName: instanceName, + import: import!, + className: className, + abstractedTypeClassName: abstractedTypeClassName, + abstractedImport: abstractedImport, + environments: environments, + presolveFunction: presolveObject?.displayName, + ); } else if (dependencyReader.instanceOf(_initializableSingletonChecker)) { return InitializableSingletonDependency( instanceName: instanceName, @@ -151,13 +156,14 @@ class DependencyConfigFactory { } } return FactoryParamDependency( - instanceName: instanceName, - import: import!, - className: className, - abstractedTypeClassName: abstractedTypeClassName, - abstractedImport: abstractedImport, - environments: environments, - params: clazzParams); + instanceName: instanceName, + import: import!, + className: className, + abstractedTypeClassName: abstractedTypeClassName, + abstractedImport: abstractedImport, + environments: environments, + params: clazzParams, + ); } else { throw UnimplementedError( 'This Dependency ${dependencyReader.typeValue} is not implemented yet upgrading stacked_generator package to the latest version may fix the issue', diff --git a/lib/src/generators/getit/stacked_locator_generator.dart b/lib/src/generators/getit/stacked_locator_generator.dart index f1d5857..c29a92f 100644 --- a/lib/src/generators/getit/stacked_locator_generator.dart +++ b/lib/src/generators/getit/stacked_locator_generator.dart @@ -1,6 +1,6 @@ import 'dart:async'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; @@ -15,7 +15,7 @@ import 'dependency_config_factory.dart'; class StackedLocatorGenerator extends GeneratorForAnnotation { @override FutureOr generateForAnnotatedElement( - Element2 element, + Element element, // ignore: avoid_renaming_method_parameters ConstantReader stackedApplication, BuildStep buildStep, diff --git a/lib/src/generators/getit/stacked_locator_parameter_resolver.dart b/lib/src/generators/getit/stacked_locator_parameter_resolver.dart index 46603e1..4410b7e 100644 --- a/lib/src/generators/getit/stacked_locator_parameter_resolver.dart +++ b/lib/src/generators/getit/stacked_locator_parameter_resolver.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; import 'package:stacked_generator/utils.dart'; @@ -19,8 +19,9 @@ class DependencyParameterResolver { FactoryParameter resolve(FormalParameterElement parameterElement) { final paramType = parameterElement.type; - final isFactoryParam = - _factoryParamChecker.hasAnnotationOfExact(parameterElement); + final isFactoryParam = _factoryParamChecker.hasAnnotationOfExact( + parameterElement, + ); return FactoryParameter( isFactoryParam: isFactoryParam, type: toDisplayString(paramType), diff --git a/lib/src/generators/logging/logger_config_resolver.dart b/lib/src/generators/logging/logger_config_resolver.dart index 9da1018..0f505b4 100644 --- a/lib/src/generators/logging/logger_config_resolver.dart +++ b/lib/src/generators/logging/logger_config_resolver.dart @@ -1,5 +1,5 @@ import 'package:analyzer/dart/constant/value.dart'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; import 'package:stacked_generator/src/generators/logging/logger_config.dart'; @@ -7,7 +7,9 @@ import 'package:stacked_generator/src/generators/logging/logger_config.dart'; /// Reolves the [LoggerConfig] and returns the object if it's supplied class LoggerConfigResolver { Future resolve( - ConstantReader stackedApp, ImportResolver importResolver) async { + ConstantReader stackedApp, + ImportResolver importResolver, + ) async { final loggerReader = stackedApp.peek('logger'); final multiLogger = loggerReader?.peek('loggerOutputs')?.listValue; final logHelperName = @@ -58,8 +60,8 @@ class LoggerConfigResolver { } } - ClassElement2 _dartOjectToElemet(DartObject obj) { + ClassElement _dartOjectToElemet(DartObject obj) { var dependencyReader = ConstantReader(obj).typeValue; - return dependencyReader.element3 as ClassElement2; + return dependencyReader.element as ClassElement; } } diff --git a/lib/src/generators/logging/stacked_logger_generator.dart b/lib/src/generators/logging/stacked_logger_generator.dart index c39504e..bb88ef3 100644 --- a/lib/src/generators/logging/stacked_logger_generator.dart +++ b/lib/src/generators/logging/stacked_logger_generator.dart @@ -1,6 +1,6 @@ import 'dart:async'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/import_resolver.dart'; @@ -12,7 +12,7 @@ import 'logger_config_resolver.dart'; class StackedLoggerGenerator extends GeneratorForAnnotation { @override FutureOr generateForAnnotatedElement( - Element2 element, + Element element, ConstantReader annotation, BuildStep buildStep, ) async { diff --git a/lib/src/generators/router/route_config/route_config_factory.dart b/lib/src/generators/router/route_config/route_config_factory.dart index eae5e4b..cc7466e 100644 --- a/lib/src/generators/router/route_config/route_config_factory.dart +++ b/lib/src/generators/router/route_config/route_config_factory.dart @@ -37,10 +37,9 @@ class RouteConfigFactory { }); RouteConfig fromResolver(ConstantReader stackedRoute) { - if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - CupertinoRoute, - inPackage: 'stacked_shared', - ))) { + if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(CupertinoRoute, inPackage: 'stacked_shared'), + )) { return CupertinoRouteConfig( className: className, classImport: classImport, @@ -55,10 +54,9 @@ class RouteConfigFactory { cupertinoNavTitle: stackedRoute.peek('title')?.stringValue, parentClassName: parentClassName, ); - } else if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - AdaptiveRoute, - inPackage: 'stacked_shared', - ))) { + } else if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(AdaptiveRoute, inPackage: 'stacked_shared'), + )) { return AdaptiveRouteConfig( className: className, classImport: classImport, @@ -73,22 +71,23 @@ class RouteConfigFactory { cupertinoNavTitle: stackedRoute.peek('cupertinoPageTitle')?.stringValue, parentClassName: parentClassName, ); - } else if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - CustomRoute, - inPackage: 'stacked_shared', - ))) { - final function = stackedRoute - .peek('transitionsBuilder') - ?.objectValue - .toFunctionValue2(); + } else if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(CustomRoute, inPackage: 'stacked_shared'), + )) { + final function = + stackedRoute + .peek('transitionsBuilder') + ?.objectValue + .toFunctionValue(); ResolvedType? customTransitionBuilder; if (function != null) { final displayName = function.displayName.replaceFirst(RegExp('^_'), ''); final enclosingDisplayName = function.enclosingElement?.displayName; - final functionName = function.isStatic && enclosingDisplayName != null - ? '$enclosingDisplayName.$displayName' - : displayName; + final functionName = + function.isStatic && enclosingDisplayName != null + ? '$enclosingDisplayName.$displayName' + : displayName; customTransitionBuilder = ResolvedType( name: functionName, diff --git a/lib/src/generators/router/stacked_router_generator.dart b/lib/src/generators/router/stacked_router_generator.dart index f2a229d..6b4a1d0 100644 --- a/lib/src/generators/router/stacked_router_generator.dart +++ b/lib/src/generators/router/stacked_router_generator.dart @@ -1,6 +1,6 @@ import 'dart:async'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_shared/stacked_shared.dart'; @@ -12,15 +12,16 @@ import 'generator/router_generator.dart'; class StackedNavigatorGenerator extends GeneratorForAnnotation { @override FutureOr generateForAnnotatedElement( - Element2 element, + Element element, ConstantReader annotation, BuildStep buildStep, ) async { final libs = await buildStep.resolver.libraries.toList(); final typeResolver = TypeResolver(libs); - final routerConfig = RouterConfigResolver(typeResolver) - .resolve(annotation, element as ClassElement2); + final routerConfig = RouterConfigResolver( + typeResolver, + ).resolve(annotation, element as ClassElement); return RouterGenerator(routerConfig).generate(); } diff --git a/lib/src/generators/router_2/auto_route_generator.dart b/lib/src/generators/router_2/auto_route_generator.dart index b0a7874..2c4ef43 100644 --- a/lib/src/generators/router_2/auto_route_generator.dart +++ b/lib/src/generators/router_2/auto_route_generator.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:source_gen/source_gen.dart'; // ignore: implementation_imports @@ -16,7 +16,10 @@ class StackedRouterGenerator extends Generator { final values = {}; for (var annotatedElement in library.annotatedWith(autoRouteChecker)) { final generatedValue = generateForAnnotatedElement( - annotatedElement.element, annotatedElement.annotation, buildStep); + annotatedElement.element, + annotatedElement.annotation, + buildStep, + ); await for (var value in normalizeGeneratorOutput(generatedValue)) { assert(value.length == value.trim().length); values.add(value); @@ -27,18 +30,18 @@ class StackedRouterGenerator extends Generator { } dynamic generateForAnnotatedElement( - Element2 element, + Element element, ConstantReader annotation, BuildStep buildStep, ) async { // throw if annotation is used for a none class element throwIf( - element is! ClassElement2, - '${element.name3} is not a class element', + element is! ClassElement, + '${element.name} is not a class element', element: element, ); - final clazz = element as ClassElement2; + final clazz = element as ClassElement; final usesPartBuilder = _hasPartDirective(clazz); final TypeResolver typeResolver; @@ -72,10 +75,7 @@ class StackedRouterGenerator extends Generator { bool _hasPartDirective(ClassElement clazz) { final fileName = clazz.firstFragment.libraryFragment.source.uri.pathSegments.last; - final part = fileName.replaceAll( - '.dart', - '.gr.dart', - ); + final part = fileName.replaceAll('.dart', '.gr.dart'); return clazz.library.firstFragment.partIncludes.any((include) { final includedPath = include.includedFragment?.source.uri.pathSegments.last; diff --git a/lib/src/generators/router_2/resolvers/route_config_resolver.dart b/lib/src/generators/router_2/resolvers/route_config_resolver.dart index d1a1430..43b926b 100644 --- a/lib/src/generators/router_2/resolvers/route_config_resolver.dart +++ b/lib/src/generators/router_2/resolvers/route_config_resolver.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/src/generators/extensions/string_utils_extension.dart'; @@ -21,12 +21,7 @@ const TypeChecker stackedRouteChecker = TypeChecker.typeNamed( inPackage: 'stacked_shared', ); -const validMetaValues = [ - 'String', - 'bool', - 'int', - 'double', -]; +const validMetaValues = ['String', 'bool', 'int', 'double']; // extracts route configs from class fields and their meta data class RouteConfigResolver { @@ -49,7 +44,8 @@ class RouteConfigResolver { }) { final page = stackedRoute.peek('page')?.typeValue; var path = stackedRoute.peek('path')?.stringValue; - var isDeferred = stackedRoute.peek('deferredLoading')?.boolValue ?? + var isDeferred = + stackedRoute.peek('deferredLoading')?.boolValue ?? _routerConfig.deferredLoading; if (page == null) { @@ -72,15 +68,16 @@ class RouteConfigResolver { } throwIf( - page.element3 is! ClassElement2, + page.element is! ClassElement, '${page.getDisplayString()} is not a class element', - element: page.element3, + element: page.element, ); - final classElement = page.element3 as ClassElement2; + final classElement = page.element as ClassElement; final import = _typeResolver.resolveImport(classElement); - final hasWrappedRoute = classElement.allSupertypes - .any((e) => e.getDisplayString() == 'AutoRouteWrapper'); + final hasWrappedRoute = classElement.allSupertypes.any( + (e) => e.getDisplayString() == 'AutoRouteWrapper', + ); var pageType = _typeResolver.resolveType(page); var className = page.getDisplayString(); @@ -89,7 +86,7 @@ class RouteConfigResolver { if (stackedRoute.peek('initial')?.boolValue == true) { path = prefix; } else { - path = '$prefix${toKababCase(className)}'; + path = '$prefix${toKebabCase(className)}'; } } throwIf( @@ -108,11 +105,11 @@ class RouteConfigResolver { stackedRoute.peek('usesPathAsKey')?.boolValue ?? false; var guards = []; - stackedRoute.peek('guards')?.listValue.map((g) => g.toTypeValue()).forEach( - (guard) { - guards.add(_typeResolver.resolveType(guard!)); - }, - ); + stackedRoute.peek('guards')?.listValue.map((g) => g.toTypeValue()).forEach(( + guard, + ) { + guards.add(_typeResolver.resolveType(guard!)); + }); var dartType = stackedRoute.objectValue.type; var returnType = ResolvedType(name: dartType.toString()); @@ -130,28 +127,24 @@ class RouteConfigResolver { ResolvedType? customRouteBuilder; ResolvedType? transitionBuilder; int? customRouteBarrierColor; - if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - MaterialRoute, - inPackage: 'stacked_shared', - ))) { + if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(MaterialRoute, inPackage: 'stacked_shared'), + )) { routeType = RouteType.material; - } else if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - CupertinoRoute, - inPackage: 'stacked_shared', - ))) { + } else if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(CupertinoRoute, inPackage: 'stacked_shared'), + )) { routeType = RouteType.cupertino; cupertinoNavTitle = stackedRoute.peek('title')?.stringValue; - } else if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - AdaptiveRoute, - inPackage: 'stacked_shared', - ))) { + } else if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(AdaptiveRoute, inPackage: 'stacked_shared'), + )) { routeType = RouteType.adaptive; cupertinoNavTitle = stackedRoute.peek('cupertinoPageTitle')?.stringValue; customRouteOpaque = stackedRoute.peek('opaque')?.boolValue; - } else if (stackedRoute.instanceOf(const TypeChecker.typeNamed( - CustomRoute, - inPackage: 'stacked_shared', - ))) { + } else if (stackedRoute.instanceOf( + const TypeChecker.typeNamed(CustomRoute, inPackage: 'stacked_shared'), + )) { routeType = RouteType.custom; durationInMilliseconds = stackedRoute.peek('durationInMilliseconds')?.intValue; @@ -161,17 +154,19 @@ class RouteConfigResolver { customRouteBarrierDismissible = stackedRoute.peek('barrierDismissible')?.boolValue; customRouteBarrierLabel = stackedRoute.peek('barrierLabel')?.stringValue; - final function = stackedRoute - .peek('transitionsBuilder') - ?.objectValue - .toFunctionValue2(); + final function = + stackedRoute + .peek('transitionsBuilder') + ?.objectValue + .toFunctionValue(); if (function != null) { transitionBuilder = _typeResolver.resolveFunctionType(function); } - final builderFunction = stackedRoute - .peek('customRouteBuilder') - ?.objectValue - .toFunctionValue2(); + final builderFunction = + stackedRoute + .peek('customRouteBuilder') + ?.objectValue + .toFunctionValue(); if (builderFunction != null) { customRouteBuilder = _typeResolver.resolveFunctionType(builderFunction); } @@ -198,44 +193,54 @@ class RouteConfigResolver { .entries .where((e) => e.value?.type != null)) { final valueType = entry.value!.type!.getDisplayString(); - throwIf(!validMetaValues.contains(valueType), - 'Meta value type $valueType is not supported!\nSupported types are $validMetaValues'); + throwIf( + !validMetaValues.contains(valueType), + 'Meta value type $valueType is not supported!\nSupported types are $validMetaValues', + ); switch (valueType) { case 'bool': { - meta.add(MetaEntry( - key: entry.key!.toStringValue()!, - type: valueType, - value: entry.value!.toBoolValue()!, - )); + meta.add( + MetaEntry( + key: entry.key!.toStringValue()!, + type: valueType, + value: entry.value!.toBoolValue()!, + ), + ); break; } case 'String': { - meta.add(MetaEntry( - key: entry.key!.toStringValue()!, - type: valueType, - value: entry.value!.toStringValue()!, - )); + meta.add( + MetaEntry( + key: entry.key!.toStringValue()!, + type: valueType, + value: entry.value!.toStringValue()!, + ), + ); break; } case 'int': { - meta.add(MetaEntry( - key: entry.key!.toStringValue()!, - type: valueType, - value: entry.value!.toIntValue()!, - )); + meta.add( + MetaEntry( + key: entry.key!.toStringValue()!, + type: valueType, + value: entry.value!.toIntValue()!, + ), + ); break; } case 'double': { - meta.add(MetaEntry( - key: entry.key!.toStringValue()!, - type: valueType, - value: entry.value!.toDoubleValue()!, - )); + meta.add( + MetaEntry( + key: entry.key!.toStringValue()!, + type: valueType, + value: entry.value!.toDoubleValue()!, + ), + ); break; } } @@ -246,7 +251,7 @@ class RouteConfigResolver { var replacementInRouteName = _routerConfig.replaceInRouteName; - final constructor = classElement.unnamedConstructor2; + final constructor = classElement.unnamedConstructor; throwIf( constructor == null, 'Route widgets must have an unnamed constructor', @@ -262,11 +267,13 @@ class RouteConfigResolver { } else { final paramResolver = RouteParameterResolver(_typeResolver); for (FormalParameterElement p in constructor.formalParameters) { - parameters.add(paramResolver.resolve( - p, - pathParams: pathParams, - inheritedPathParams: inheritedPathParams, - )); + parameters.add( + paramResolver.resolve( + p, + pathParams: pathParams, + inheritedPathParams: inheritedPathParams, + ), + ); } } } @@ -274,23 +281,28 @@ class RouteConfigResolver { var pathParameters = parameters.where((element) => element.isPathParam); if (parameters.any((p) => p.isPathParam || p.isQueryParam)) { - var unParsableRequiredArgs = parameters.where((p) => - (p.isRequired || p.isPositional) && - !p.isPathParam && - !p.isQueryParam); + var unParsableRequiredArgs = parameters.where( + (p) => + (p.isRequired || p.isPositional) && + !p.isPathParam && + !p.isQueryParam, + ); if (unParsableRequiredArgs.isNotEmpty) { // ignore: avoid_print print( - '\nWARNING => Because [$className] has required parameters ${unParsableRequiredArgs.map((e) => e.paramName)} ' - 'that can not be parsed from path,\n@PathParam() and @QueryParam() annotations will be ignored.\n'); + '\nWARNING => Because [$className] has required parameters ${unParsableRequiredArgs.map((e) => e.paramName)} ' + 'that can not be parsed from path,\n@PathParam() and @QueryParam() annotations will be ignored.\n', + ); } } if (pathParameters.isNotEmpty) { for (var pParam in pathParameters) { - throwIf(!validPathParamTypes.contains(pParam.type.name), - "Parameter [${pParam.name}] must be of a type that can be parsed from a [String] because it will also obtain it's value from a path\nvalid types: $validPathParamTypes", - element: pParam.element); + throwIf( + !validPathParamTypes.contains(pParam.type.name), + "Parameter [${pParam.name}] must be of a type that can be parsed from a [String] because it will also obtain it's value from a path\nvalid types: $validPathParamTypes", + element: pParam.element, + ); } } diff --git a/lib/src/generators/router_2/resolvers/router_config_resolver.dart b/lib/src/generators/router_2/resolvers/router_config_resolver.dart index 1d51c90..75acb6f 100644 --- a/lib/src/generators/router_2/resolvers/router_config_resolver.dart +++ b/lib/src/generators/router_2/resolvers/router_config_resolver.dart @@ -1,5 +1,5 @@ import 'package:analyzer/dart/constant/value.dart'; -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/src/generators/router_common/models/route_parameter_config.dart'; import 'package:stacked_generator/utils.dart'; @@ -21,7 +21,7 @@ class RouterConfigResolver { RouterConfig resolve( ConstantReader stackedApp, - ClassElement2 clazz, { + ClassElement clazz, { bool usesPartBuilder = false, }) { int routeType = RouteType.material; @@ -31,20 +31,17 @@ class RouterConfigResolver { bool? customRouteBarrierDismissible; ResolvedType? transitionBuilder; ResolvedType? customRouteBuilder; - if (stackedApp.instanceOf(const TypeChecker.typeNamed( - CupertinoRouter, - inPackage: 'stacked_shared', - ))) { + if (stackedApp.instanceOf( + const TypeChecker.typeNamed(CupertinoRouter, inPackage: 'stacked_shared'), + )) { routeType = RouteType.cupertino; - } else if (stackedApp.instanceOf(const TypeChecker.typeNamed( - AdaptiveRouter, - inPackage: 'stacked_shared', - ))) { + } else if (stackedApp.instanceOf( + const TypeChecker.typeNamed(AdaptiveRouter, inPackage: 'stacked_shared'), + )) { routeType = RouteType.adaptive; - } else if (stackedApp.instanceOf(const TypeChecker.typeNamed( - CustomRouter, - inPackage: 'stacked_shared', - ))) { + } else if (stackedApp.instanceOf( + const TypeChecker.typeNamed(CustomRouter, inPackage: 'stacked_shared'), + )) { routeType = RouteType.custom; durationInMilliseconds = @@ -55,15 +52,16 @@ class RouterConfigResolver { customRouteBarrierDismissible = stackedApp.peek('barrierDismissible')?.boolValue; final function = - stackedApp.peek('transitionsBuilder')?.objectValue.toFunctionValue2(); + stackedApp.peek('transitionsBuilder')?.objectValue.toFunctionValue(); if (function != null) { transitionBuilder = _typeResolver.resolveFunctionType(function); } final customRouteBuilderValue = - stackedApp.peek('customRouteBuilder')?.objectValue.toFunctionValue2(); + stackedApp.peek('customRouteBuilder')?.objectValue.toFunctionValue(); if (customRouteBuilderValue != null) { - customRouteBuilder = - _typeResolver.resolveFunctionType(customRouteBuilderValue); + customRouteBuilder = _typeResolver.resolveFunctionType( + customRouteBuilderValue, + ); } } @@ -90,7 +88,7 @@ class RouterConfigResolver { final routesDartObjects = stackedApp.read('routes').listValue; final generateNavigationExt = stackedApp.peek('generateNavigationHelperExtension')?.boolValue ?? - false; + false; final routeNamePrefix = stackedApp.peek('routePrefix')?.stringValue ?? '/'; final routesClassName = @@ -124,8 +122,11 @@ class RouterConfigResolver { List inheritedPathParams = const [], String? routeNamePrefix, }) { - var routeResolver = - RouteConfigResolver(routeNamePrefix, routerConfig, _typeResolver); + var routeResolver = RouteConfigResolver( + routeNamePrefix, + routerConfig, + _typeResolver, + ); final routes = []; for (var entry in routesList) { var routeReader = ConstantReader(entry); @@ -164,16 +165,17 @@ class RouterConfigResolver { var initialRoute = routes.firstOrNull((r) => r.initial); if (initialRoute != null && !routes.any((r) => r.pathName == initialPath)) { routes.insert( - 0, - RouteConfig( - pathName: initialPath, - redirectTo: initialRoute.pathName, - className: '', - classImport: '', - fullMatch: true, - routeType: RouteType.redirect, - deferredLoading: false, - )); + 0, + RouteConfig( + pathName: initialPath, + redirectTo: initialRoute.pathName, + className: '', + classImport: '', + fullMatch: true, + routeType: RouteType.redirect, + deferredLoading: false, + ), + ); } return routes; diff --git a/lib/src/generators/router_common/models/router_config.dart b/lib/src/generators/router_common/models/router_config.dart index beaf739..c48818e 100644 --- a/lib/src/generators/router_common/models/router_config.dart +++ b/lib/src/generators/router_common/models/router_config.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'route_config.dart'; @@ -11,7 +11,7 @@ class RouterConfig { final String routerClassName; final RouterConfig? parent; final String? replaceInRouteName; - final ClassElement2? element; + final ClassElement? element; final bool deferredLoading; RouterConfig({ @@ -36,7 +36,7 @@ class RouterConfig { String? routerClassName, RouterConfig? parent, String? replaceInRouteName, - ClassElement2? element, + ClassElement? element, bool? deferredLoading, }) { return RouterConfig( @@ -85,6 +85,7 @@ class RouterConfig { return routers; } - List get collectAllRoutersIncludingParent => subRouters.fold( - [this], (all, e) => all..addAll(e.collectAllRoutersIncludingParent)); + List get collectAllRoutersIncludingParent => subRouters.fold([ + this, + ], (all, e) => all..addAll(e.collectAllRoutersIncludingParent)); } diff --git a/lib/src/generators/router_common/resolvers/route_parameter_resolver.dart b/lib/src/generators/router_common/resolvers/route_parameter_resolver.dart index 466a241..5457e0a 100644 --- a/lib/src/generators/router_common/resolvers/route_parameter_resolver.dart +++ b/lib/src/generators/router_common/resolvers/route_parameter_resolver.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:source_gen/source_gen.dart'; import 'package:stacked_generator/src/generators/router_common/models/route_parameter_config.dart'; @@ -31,8 +31,9 @@ class RouteParameterResolver { } var type = _typeResolver.resolveType(paramType); final paramName = (parameterElement.name ?? '').replaceFirst("_", ''); - var pathParamAnnotation = - _pathParamChecker.firstAnnotationOfExact(parameterElement); + var pathParamAnnotation = _pathParamChecker.firstAnnotationOfExact( + parameterElement, + ); String? paramAlias; var nameOrAlias = paramName; if (pathParamAnnotation != null) { @@ -46,8 +47,9 @@ class RouteParameterResolver { element: parameterElement, ); } - var queryParamAnnotation = - _queryParamChecker.firstAnnotationOfExact(parameterElement); + var queryParamAnnotation = _queryParamChecker.firstAnnotationOfExact( + parameterElement, + ); if (queryParamAnnotation != null) { paramAlias = queryParamAnnotation.getField('name')?.toStringValue(); @@ -60,7 +62,7 @@ class RouteParameterResolver { throwIf( pathParamAnnotation != null && queryParamAnnotation != null, - '${parameterElement.name3} can not be both a pathParam and a queryParam!', + '${parameterElement.name} can not be both a pathParam and a queryParam!', element: parameterElement, ); @@ -76,7 +78,8 @@ class RouteParameterResolver { isNamed: parameterElement.isNamed, isPathParam: pathParamAnnotation != null, isQueryParam: queryParamAnnotation != null, - isInheritedPathParam: pathParamAnnotation != null && + isInheritedPathParam: + pathParamAnnotation != null && !pathParams.any((e) => e.name == nameOrAlias), defaultValueCode: parameterElement.defaultValueCode, ); @@ -85,17 +88,18 @@ class RouteParameterResolver { ParamConfig _resolveFunctionType(FormalParameterElement paramElement) { var type = paramElement.type as FunctionType; return FunctionParamConfig( - returnType: _typeResolver.resolveType(type.returnType), - type: _typeResolver.resolveType(type), - params: type.formalParameters.map(resolve).toList(), - element: paramElement, - name: paramElement.name ?? '', - defaultValueCode: paramElement.defaultValueCode, - isRequired: paramElement.isRequiredNamed, - isPositional: paramElement.isPositional, - hasRequired: paramElement.isRequired, - isOptional: paramElement.isOptional, - isNamed: paramElement.isNamed); + returnType: _typeResolver.resolveType(type.returnType), + type: _typeResolver.resolveType(type), + params: type.formalParameters.map(resolve).toList(), + element: paramElement, + name: paramElement.name ?? '', + defaultValueCode: paramElement.defaultValueCode, + isRequired: paramElement.isRequiredNamed, + isPositional: paramElement.isPositional, + hasRequired: paramElement.isRequired, + isOptional: paramElement.isOptional, + isNamed: paramElement.isNamed, + ); } static List extractPathParams(String path) { @@ -106,10 +110,7 @@ class RouteParameterResolver { isOptional = true; paramName = paramName.substring(0, paramName.length - 1); } - return PathParamConfig( - name: paramName, - isOptional: isOptional, - ); + return PathParamConfig(name: paramName, isOptional: isOptional); }).toList(); } } diff --git a/lib/src/generators/router_common/resolvers/type_resolver.dart b/lib/src/generators/router_common/resolvers/type_resolver.dart index ae3fbe8..c5e63c3 100644 --- a/lib/src/generators/router_common/resolvers/type_resolver.dart +++ b/lib/src/generators/router_common/resolvers/type_resolver.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/nullability_suffix.dart' show NullabilitySuffix; import 'package:analyzer/dart/element/type.dart' @@ -7,12 +7,12 @@ import 'package:path/path.dart' as p; import 'package:stacked_generator/src/generators/router_common/models/importable_type.dart'; class TypeResolver { - final List libs; + final List libs; final Uri? targetFile; TypeResolver(this.libs, [this.targetFile]); - String? resolveImport(Element2? element) { + String? resolveImport(Element? element) { // return early if source is null or element is a core type if (libs.isEmpty || element == null || _isCoreDartType(element)) { return null; @@ -23,10 +23,7 @@ class TypeResolver { lib.exportNamespace.definedNames2.values.contains(element)) { return targetFile == null ? lib.identifier - : _relative( - lib.firstFragment.source.uri, - targetFile!, - ); + : _relative(lib.firstFragment.source.uri, targetFile!); } } return null; @@ -60,22 +57,24 @@ class TypeResolver { final types = []; if (typeToCheck is ParameterizedType) { for (DartType type in typeToCheck.typeArguments) { - if (type.element3 is TypeParameterElement2) { + if (type.element is TypeParameterElement) { types.add(ResolvedType(name: 'dynamic')); } else { - types.add(ResolvedType( - name: type.element3?.name3 ?? 'void', - import: resolveImport(type.element3), - isNullable: type.nullabilitySuffix == NullabilitySuffix.question, - typeArguments: _resolveTypeArguments(type), - )); + types.add( + ResolvedType( + name: type.element?.name ?? 'void', + import: resolveImport(type.element), + isNullable: type.nullabilitySuffix == NullabilitySuffix.question, + typeArguments: _resolveTypeArguments(type), + ), + ); } } } return types; } - ResolvedType resolveFunctionType(ExecutableElement2 function) { + ResolvedType resolveFunctionType(ExecutableElement function) { final displayName = function.displayName.replaceFirst(RegExp('^_'), ''); var functionName = displayName; Element elementToImport = function; @@ -93,9 +92,9 @@ class TypeResolver { ResolvedType resolveType(DartType type) { return ResolvedType( - name: type.element3?.name3 ?? type.getDisplayString(), + name: type.element?.name ?? type.getDisplayString(), isNullable: type.nullabilitySuffix == NullabilitySuffix.question, - import: resolveImport(type.element3), + import: resolveImport(type.element), typeArguments: _resolveTypeArguments(type), ); } diff --git a/lib/utils.dart b/lib/utils.dart index 88cc211..e9ffe16 100644 --- a/lib/utils.dart +++ b/lib/utils.dart @@ -1,4 +1,4 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:stacked_generator/src/generators/exceptions/invalid_generator_input_exception.dart'; import 'package:stacked_generator/src/generators/router_common/models/route_parameter_config.dart'; @@ -12,13 +12,16 @@ String toDisplayString(DartType e) { String processedReturnType(String? returnType) { final returnTypeContainsBiggerOperatorWithOneOfRouteNames = returnType != null && - returnType.contains('<') && - returnType.contains( - RegExp('CustomRoute|MaterialRoute|CupertinoRoute|AdaptiveRoute')); + returnType.contains('<') && + returnType.contains( + RegExp('CustomRoute|MaterialRoute|CupertinoRoute|AdaptiveRoute'), + ); if (returnTypeContainsBiggerOperatorWithOneOfRouteNames) { final afterRemovingArrowHeads = returnType.substring( - returnType.indexOf('<') + 1, returnType.lastIndexOf('>')); + returnType.indexOf('<') + 1, + returnType.lastIndexOf('>'), + ); return afterRemovingArrowHeads; } else { @@ -26,19 +29,19 @@ String processedReturnType(String? returnType) { } } -void throwIf(bool condition, String message, - {Element2? element, String todo = ''}) { +void throwIf( + bool condition, + String message, { + Element? element, + String todo = '', +}) { if (condition) { throwError(message, todo: todo, element: element); } } -void throwError(String message, {Element2? element, String todo = ''}) { - throw InvalidGeneratorInputException( - message, - todo: todo, - element: element, - ); +void throwError(String message, {Element? element, String todo = ''}) { + throw InvalidGeneratorInputException(message, todo: todo, element: element); } List notQueryNorPath(List parameters) { @@ -57,9 +60,11 @@ String capitalize(String s) { return s[0].toUpperCase() + s.substring(1); } -String toKababCase(String s) { - return s.replaceAllMapped(RegExp('(.+?)([A-Z])'), - (match) => '${match.group(1)}-${match.group(2)}'.toLowerCase()); +String toKebabCase(String s) { + return s.replaceAllMapped( + RegExp('(.+?)([A-Z])'), + (match) => '${match.group(1)}-${match.group(2)}'.toLowerCase(), + ); } String valueOr(String? value, String or) { @@ -74,7 +79,7 @@ Future getStackedAppFileName() async { return stackedAppFilePath.substring(0, stackedAppFilePath.length - 5); } -extension IterableExtenstion on Iterable { +extension IterableExtension on Iterable { E? firstOrNull(bool Function(E element) test) { for (var e in this) { if (test(e)) { diff --git a/pubspec.yaml b/pubspec.yaml index a28edbd..efa55cf 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -16,7 +16,7 @@ dependencies: logger: ^2.6.2 stacked_shared: ^1.4.2 # Removing this will cause issues when publish the package - analyzer: ^8.1.1 + analyzer: ^10.0.0 dart_style: ^3.1.0 code_builder: ^4.10.1 collection: ^1.19.1 diff --git a/test/helpers/ast/logger_ast_validators.dart b/test/helpers/ast/logger_ast_validators.dart index 253d305..f277db9 100644 --- a/test/helpers/ast/logger_ast_validators.dart +++ b/test/helpers/ast/logger_ast_validators.dart @@ -25,12 +25,12 @@ import 'ast_helper.dart'; /// /// // Validate specific components /// LoggerClassGeneratorAstValidator.validateLoggerImports( -/// generatedCode, +/// generatedCode, /// expectedImports /// ); /// LoggerComponentAstValidator.validateSimpleLogPrinter(generatedCode); /// LoggerComponentAstValidator.validateLoggerFactory( -/// generatedCode, +/// generatedCode, /// expectedFunctionName /// ); /// ``` @@ -69,16 +69,16 @@ class LoggerClassGeneratorAstValidator { // Validate required imports validateLoggerImports(generatedCode, expectedConfig.imports); - + // Validate SimpleLogPrinter class LoggerComponentAstValidator.validateSimpleLogPrinter(generatedCode); - + // Validate stack trace utility functions LoggerComponentAstValidator.validateStackTraceUtilities(generatedCode); - + // Validate logger factory function LoggerComponentAstValidator.validateLoggerFactory( - generatedCode, + generatedCode, expectedConfig.logHelperName, expectedConfig.loggerOutputs, expectedConfig.disableReleaseConsoleOutput, @@ -88,19 +88,31 @@ class LoggerClassGeneratorAstValidator { /// Validates that required imports are present. /// /// Ensures Flutter foundation, logger package, and custom imports exist. - static void validateLoggerImports(String generatedCode, Set expectedImports) { + static void validateLoggerImports( + String generatedCode, + Set expectedImports, + ) { final unit = AstHelper.parseCode(generatedCode); - + // Required framework imports - expect(AstHelper.hasImport(unit, 'package:flutter/foundation.dart'), - isTrue, reason: 'Should import Flutter foundation'); - expect(AstHelper.hasImport(unit, 'package:logger/logger.dart'), - isTrue, reason: 'Should import logger package'); - + expect( + AstHelper.hasImport(unit, 'package:flutter/foundation.dart'), + isTrue, + reason: 'Should import Flutter foundation', + ); + expect( + AstHelper.hasImport(unit, 'package:logger/logger.dart'), + isTrue, + reason: 'Should import logger package', + ); + // Custom imports from config for (final importPath in expectedImports) { - expect(AstHelper.hasImport(unit, importPath), - isTrue, reason: 'Should import $importPath'); + expect( + AstHelper.hasImport(unit, importPath), + isTrue, + reason: 'Should import $importPath', + ); } } @@ -109,12 +121,21 @@ class LoggerClassGeneratorAstValidator { /// Checks that proper ignore directives are present. static void validateIgnoreComments(String generatedCode) { // Check for ignore comments at the top of the file - expect(generatedCode, contains('ignore_for_file'), - reason: 'Should contain ignore_for_file directive'); - expect(generatedCode, contains('avoid_print'), - reason: 'Should ignore avoid_print linting rule'); - expect(generatedCode, contains('depend_on_referenced_packages'), - reason: 'Should ignore depend_on_referenced_packages linting rule'); + expect( + generatedCode, + contains('ignore_for_file'), + reason: 'Should contain ignore_for_file directive', + ); + expect( + generatedCode, + contains('avoid_print'), + reason: 'Should ignore avoid_print linting rule', + ); + expect( + generatedCode, + contains('depend_on_referenced_packages'), + reason: 'Should ignore depend_on_referenced_packages linting rule', + ); } } @@ -128,27 +149,33 @@ class LoggerComponentAstValidator { /// Checks class declaration, constructor, fields, and log method. static void validateSimpleLogPrinter(String generatedCode) { final unit = AstHelper.parseCode(generatedCode); - + // Find SimpleLogPrinter class final printerClass = AstHelper.findClass(unit, 'SimpleLogPrinter'); - expect(printerClass, isNotNull, - reason: 'Should contain SimpleLogPrinter class'); - + expect( + printerClass, + isNotNull, + reason: 'Should contain SimpleLogPrinter class', + ); + if (printerClass != null) { // Should extend LogPrinter final extendsClause = printerClass.extendsClause; - expect(extendsClause?.superclass.name2.lexeme, equals('LogPrinter'), - reason: 'SimpleLogPrinter should extend LogPrinter'); - + expect( + extendsClause?.superclass.name.lexeme, + equals('LogPrinter'), + reason: 'SimpleLogPrinter should extend LogPrinter', + ); + // Validate required fields _validatePrinterFields(printerClass); - + // Validate constructor _validatePrinterConstructor(printerClass); - + // Validate log method _validateLogMethod(printerClass); - + // Validate helper methods _validatePrinterHelperMethods(printerClass); } @@ -159,35 +186,51 @@ class LoggerComponentAstValidator { /// Checks for global utility functions and variables. static void validateStackTraceUtilities(String generatedCode) { final unit = AstHelper.parseCode(generatedCode); - + // Should have stackTraceRegex variable final stackTraceRegex = _findTopLevelVariable(unit, 'stackTraceRegex'); - expect(stackTraceRegex, isNotNull, - reason: 'Should have stackTraceRegex variable'); - + expect( + stackTraceRegex, + isNotNull, + reason: 'Should have stackTraceRegex variable', + ); + if (stackTraceRegex != null) { // Should contain RegExp in the initializer final firstVariable = stackTraceRegex.variables.first; final initializer = firstVariable.initializer?.toString() ?? ''; - expect(initializer, contains('RegExp'), - reason: 'stackTraceRegex should be initialized with RegExp'); + expect( + initializer, + contains('RegExp'), + reason: 'stackTraceRegex should be initialized with RegExp', + ); } - + // Should have _formatStackTrace function final formatFunction = _findTopLevelFunction(unit, '_formatStackTrace'); - expect(formatFunction, isNotNull, - reason: 'Should have _formatStackTrace function'); - + expect( + formatFunction, + isNotNull, + reason: 'Should have _formatStackTrace function', + ); + if (formatFunction != null) { // Should return List? final returnType = formatFunction.returnType?.toString(); - expect(returnType, anyOf(contains('List'), contains('String')), - reason: '_formatStackTrace should return List?'); - + expect( + returnType, + anyOf(contains('List'), contains('String')), + reason: '_formatStackTrace should return List?', + ); + // Should have StackTrace and int parameters - final parameters = formatFunction.functionExpression.parameters?.parameters ?? []; - expect(parameters.length, equals(2), - reason: '_formatStackTrace should have 2 parameters'); + final parameters = + formatFunction.functionExpression.parameters?.parameters ?? []; + expect( + parameters.length, + equals(2), + reason: '_formatStackTrace should have 2 parameters', + ); } } @@ -195,29 +238,39 @@ class LoggerComponentAstValidator { /// /// Checks function signature, parameters, and output configuration. static void validateLoggerFactory( - String generatedCode, + String generatedCode, String expectedFunctionName, List expectedOutputs, bool? disableReleaseConsoleOutput, ) { final unit = AstHelper.parseCode(generatedCode); - + // Find the logger factory function final factoryFunction = _findTopLevelFunction(unit, expectedFunctionName); - expect(factoryFunction, isNotNull, - reason: 'Should have $expectedFunctionName factory function'); - + expect( + factoryFunction, + isNotNull, + reason: 'Should have $expectedFunctionName factory function', + ); + if (factoryFunction != null) { // Should return Logger final returnType = factoryFunction.returnType?.toString(); - expect(returnType, contains('Logger'), - reason: '$expectedFunctionName should return Logger'); - + expect( + returnType, + contains('Logger'), + reason: '$expectedFunctionName should return Logger', + ); + // Validate function parameters _validateFactoryParameters(factoryFunction); - + // Validate function body contains expected outputs - _validateFactoryOutputs(factoryFunction, expectedOutputs, disableReleaseConsoleOutput); + _validateFactoryOutputs( + factoryFunction, + expectedOutputs, + disableReleaseConsoleOutput, + ); } } @@ -227,138 +280,201 @@ class LoggerComponentAstValidator { static void _validatePrinterFields(ClassDeclaration printerClass) { final expectedFields = [ 'className', - 'printCallingFunctionName', + 'printCallingFunctionName', 'printCallStack', 'exludeLogsFromClasses', 'showOnlyClass', 'printer', ]; - + for (final fieldName in expectedFields) { final field = AstHelper.findField(printerClass, fieldName); - expect(field, isNotNull, - reason: 'SimpleLogPrinter should have $fieldName field'); - + expect( + field, + isNotNull, + reason: 'SimpleLogPrinter should have $fieldName field', + ); + if (field != null && fieldName != 'printer') { // Most fields should be final - expect(AstHelper.isFieldFinal(field), isTrue, - reason: '$fieldName field should be final'); + expect( + AstHelper.isFieldFinal(field), + isTrue, + reason: '$fieldName field should be final', + ); } } } /// Validates SimpleLogPrinter constructor. static void _validatePrinterConstructor(ClassDeclaration printerClass) { - final constructor = AstHelper.findConstructor(printerClass, 'SimpleLogPrinter'); - expect(constructor, isNotNull, - reason: 'SimpleLogPrinter should have constructor'); - + final constructor = AstHelper.findConstructor( + printerClass, + 'SimpleLogPrinter', + ); + expect( + constructor, + isNotNull, + reason: 'SimpleLogPrinter should have constructor', + ); + if (constructor != null) { // Should have className as required parameter final parameters = constructor.parameters.parameters; - expect(parameters, isNotEmpty, - reason: 'Constructor should have parameters'); - + expect( + parameters, + isNotEmpty, + reason: 'Constructor should have parameters', + ); + // First parameter should be className final firstParam = parameters.first; - expect(firstParam.toString(), contains('className'), - reason: 'First parameter should be className'); + expect( + firstParam.toString(), + contains('className'), + reason: 'First parameter should be className', + ); } } /// Validates log method in SimpleLogPrinter. static void _validateLogMethod(ClassDeclaration printerClass) { final logMethod = AstHelper.findMethod(printerClass, 'log'); - expect(logMethod, isNotNull, - reason: 'SimpleLogPrinter should have log method'); - + expect( + logMethod, + isNotNull, + reason: 'SimpleLogPrinter should have log method', + ); + if (logMethod != null) { // Should have override annotation - expect(AstHelper.hasOverrideAnnotation(logMethod), isTrue, - reason: 'log method should have @override annotation'); - + expect( + AstHelper.hasOverrideAnnotation(logMethod), + isTrue, + reason: 'log method should have @override annotation', + ); + // Should return List final returnType = AstHelper.getMethodReturnType(logMethod); - expect(returnType, anyOf(contains('List'), contains('String')), - reason: 'log method should return List'); + expect( + returnType, + anyOf(contains('List'), contains('String')), + reason: 'log method should return List', + ); } } /// Validates SimpleLogPrinter helper methods. static void _validatePrinterHelperMethods(ClassDeclaration printerClass) { - final helperMethods = ['_getMethodName', '_splitClassNameWords', - '_findMostMatchedTrace', '_doesTraceContainsAllKeywords']; - + final helperMethods = [ + '_getMethodName', + '_splitClassNameWords', + '_findMostMatchedTrace', + '_doesTraceContainsAllKeywords', + ]; + for (final methodName in helperMethods) { final method = AstHelper.findMethod(printerClass, methodName); - expect(method, isNotNull, - reason: 'SimpleLogPrinter should have $methodName method'); + expect( + method, + isNotNull, + reason: 'SimpleLogPrinter should have $methodName method', + ); } } /// Validates factory function parameters. static void _validateFactoryParameters(FunctionDeclaration factoryFunction) { - final parameters = factoryFunction.functionExpression.parameters?.parameters ?? []; + final parameters = + factoryFunction.functionExpression.parameters?.parameters ?? []; final expectedParams = [ 'className', 'printCallingFunctionName', - 'printCallstack', + 'printCallstack', 'exludeLogsFromClasses', - 'showOnlyClass' + 'showOnlyClass', ]; - + // Should have at least the required parameters - expect(parameters.length, greaterThanOrEqualTo(1), - reason: 'Factory function should have parameters'); - + expect( + parameters.length, + greaterThanOrEqualTo(1), + reason: 'Factory function should have parameters', + ); + // Check parameter names are present in function signature final functionSignature = factoryFunction.toString(); for (final paramName in expectedParams) { - expect(functionSignature, contains(paramName), - reason: 'Factory function should have $paramName parameter'); + expect( + functionSignature, + contains(paramName), + reason: 'Factory function should have $paramName parameter', + ); } } /// Validates factory function output configuration. static void _validateFactoryOutputs( - FunctionDeclaration factoryFunction, + FunctionDeclaration factoryFunction, List expectedOutputs, bool? disableReleaseConsoleOutput, ) { final functionBody = factoryFunction.toString(); - + // Should contain MultiOutput - expect(functionBody, contains('MultiOutput'), - reason: 'Factory function should use MultiOutput'); - + expect( + functionBody, + contains('MultiOutput'), + reason: 'Factory function should use MultiOutput', + ); + // Should contain Logger instantiation - expect(functionBody, contains('Logger('), - reason: 'Factory function should instantiate Logger'); - + expect( + functionBody, + contains('Logger('), + reason: 'Factory function should instantiate Logger', + ); + // Should contain SimpleLogPrinter - expect(functionBody, contains('SimpleLogPrinter'), - reason: 'Factory function should use SimpleLogPrinter'); - + expect( + functionBody, + contains('SimpleLogPrinter'), + reason: 'Factory function should use SimpleLogPrinter', + ); + // Check console output conditional logic if (disableReleaseConsoleOutput == false) { - expect(functionBody, contains('ConsoleOutput()'), - reason: 'Should always include ConsoleOutput when not disabled'); + expect( + functionBody, + contains('ConsoleOutput()'), + reason: 'Should always include ConsoleOutput when not disabled', + ); } else { - expect(functionBody, contains('kReleaseMode'), - reason: 'Should have conditional compilation logic'); + expect( + functionBody, + contains('kReleaseMode'), + reason: 'Should have conditional compilation logic', + ); } - + // Check expected outputs are referenced for (final output in expectedOutputs) { - expect(functionBody, contains(output), - reason: 'Should reference output $output'); + expect( + functionBody, + contains(output), + reason: 'Should reference output $output', + ); } } /// Finds a top-level variable by name. - static VariableDeclarationList? _findTopLevelVariable(CompilationUnit unit, String name) { - final variables = unit.declarations.whereType(); - + static VariableDeclarationList? _findTopLevelVariable( + CompilationUnit unit, + String name, + ) { + final variables = + unit.declarations.whereType(); + for (final varDecl in variables) { for (final variable in varDecl.variables.variables) { if (variable.name.lexeme == name) { @@ -370,8 +486,11 @@ class LoggerComponentAstValidator { } /// Finds a top-level function by name. - static FunctionDeclaration? _findTopLevelFunction(CompilationUnit unit, String name) { + static FunctionDeclaration? _findTopLevelFunction( + CompilationUnit unit, + String name, + ) { final functions = unit.declarations.whereType(); return functions.where((f) => f.name.lexeme == name).firstOrNull; } -} \ No newline at end of file +} diff --git a/test/helpers/ast/router_ast_validators.dart b/test/helpers/ast/router_ast_validators.dart index b3d3ff6..f006882 100644 --- a/test/helpers/ast/router_ast_validators.dart +++ b/test/helpers/ast/router_ast_validators.dart @@ -27,20 +27,37 @@ class LibraryBuilderAstValidator { } // Validate router configuration is generated - final routerConfig = AstHelper.findTopLevelVariableDeclaration(unit, 'router'); - expect(routerConfig, isNotNull, reason: 'Should contain router configuration'); + final routerConfig = AstHelper.findTopLevelVariableDeclaration( + unit, + 'router', + ); + expect( + routerConfig, + isNotNull, + reason: 'Should contain router configuration', + ); } /// Validate part directive generation - static void validatePartDirective(String generatedCode, {required String expectedFileName}) { - expect(generatedCode, contains('part of'), reason: 'Should contain part of directive'); + static void validatePartDirective( + String generatedCode, { + required String expectedFileName, + }) { + expect( + generatedCode, + contains('part of'), + reason: 'Should contain part of directive', + ); } } /// Router extension validation for Router 2.0 class RouterExtensionAstValidator { /// Validate router extension generation - static void validateRouterExtension(String generatedCode, {required List expectedRoutes}) { + static void validateRouterExtension( + String generatedCode, { + required List expectedRoutes, + }) { final unit = AstHelper.parseCode(generatedCode); expect(unit, isNotNull, reason: 'Generated code should be valid Dart'); @@ -62,13 +79,19 @@ class RouterAstValidator { // Find the router class final routerClass = AstHelper.findClass(unit, expectedClassName); - expect(routerClass, isNotNull, - reason: 'Should contain class $expectedClassName'); + expect( + routerClass, + isNotNull, + reason: 'Should contain class $expectedClassName', + ); // Validate superclass final superclass = AstHelper.getSuperclassName(routerClass!); - expect(superclass, contains(expectedSuperclass), - reason: 'Class should extend $expectedSuperclass'); + expect( + superclass, + contains(expectedSuperclass), + reason: 'Class should extend $expectedSuperclass', + ); // Validate required fields exist final routesField = AstHelper.findField(routerClass, '_routes'); @@ -80,13 +103,19 @@ class RouterAstValidator { // Validate override methods exist final routesGetter = AstHelper.findMethod(routerClass, 'routes'); expect(routesGetter, isNotNull, reason: 'Should have routes getter'); - expect(AstHelper.hasOverrideAnnotation(routesGetter!), isTrue, - reason: 'routes getter should have @override annotation'); + expect( + AstHelper.hasOverrideAnnotation(routesGetter!), + isTrue, + reason: 'routes getter should have @override annotation', + ); final pagesMapGetter = AstHelper.findMethod(routerClass, 'pagesMap'); expect(pagesMapGetter, isNotNull, reason: 'Should have pagesMap getter'); - expect(AstHelper.hasOverrideAnnotation(pagesMapGetter!), isTrue, - reason: 'pagesMap getter should have @override annotation'); + expect( + AstHelper.hasOverrideAnnotation(pagesMapGetter!), + isTrue, + reason: 'pagesMap getter should have @override annotation', + ); } /// Ensure generated code contains the required imports by URI. @@ -97,8 +126,11 @@ class RouterAstValidator { final unit = AstHelper.parseCode(generatedCode); for (final importUri in requiredImports) { - expect(AstHelper.hasImport(unit, importUri), isTrue, - reason: 'Should import $importUri'); + expect( + AstHelper.hasImport(unit, importUri), + isTrue, + reason: 'Should import $importUri', + ); } } @@ -114,12 +146,18 @@ class RouterAstValidator { expect(routesField, isNotNull); // Validate field is final and has correct type - expect(AstHelper.isFieldFinal(routesField!), isTrue, - reason: '_routes field should be final'); + expect( + AstHelper.isFieldFinal(routesField!), + isTrue, + reason: '_routes field should be final', + ); final fieldType = AstHelper.getFieldType(routesField); - expect(fieldType, contains('RouteDef'), - reason: '_routes should be List'); + expect( + fieldType, + contains('RouteDef'), + reason: '_routes should be List', + ); } /// Ensure _pagesMap field exists, is final, and typed with StackedRouteFactory. @@ -134,12 +172,18 @@ class RouterAstValidator { expect(pagesMapField, isNotNull); // Validate field is final and has correct type - expect(AstHelper.isFieldFinal(pagesMapField!), isTrue, - reason: '_pagesMap field should be final'); + expect( + AstHelper.isFieldFinal(pagesMapField!), + isTrue, + reason: '_pagesMap field should be final', + ); final fieldType = AstHelper.getFieldType(pagesMapField); - expect(fieldType, contains('StackedRouteFactory'), - reason: '_pagesMap should be Map'); + expect( + fieldType, + contains('StackedRouteFactory'), + reason: '_pagesMap should be Map', + ); } /// Ensure routes/pagesMap getters exist and return correct types. @@ -151,15 +195,21 @@ class RouterAstValidator { expect(routesGetter, isNotNull); final routesReturnType = AstHelper.getMethodReturnType(routesGetter!); - expect(routesReturnType, contains('RouteDef'), - reason: 'routes getter should return List'); + expect( + routesReturnType, + contains('RouteDef'), + reason: 'routes getter should return List', + ); final pagesMapGetter = AstHelper.findMethod(routerClass, 'pagesMap'); expect(pagesMapGetter, isNotNull); final pagesMapReturnType = AstHelper.getMethodReturnType(pagesMapGetter!); - expect(pagesMapReturnType, contains('StackedRouteFactory'), - reason: 'pagesMap getter should return Map'); + expect( + pagesMapReturnType, + contains('StackedRouteFactory'), + reason: 'pagesMap getter should return Map', + ); } } @@ -180,17 +230,26 @@ class RouterHelperAstValidator { final routesVar = variables.first; final variableName = AstHelper.getVariableNames(routesVar.variables).first; - expect(variableName, equals('_routes'), - reason: 'Variable should be named _routes'); + expect( + variableName, + equals('_routes'), + reason: 'Variable should be named _routes', + ); // Should be final - expect(AstHelper.isVariableFinal(routesVar.variables), isTrue, - reason: '_routes should be final'); + expect( + AstHelper.isVariableFinal(routesVar.variables), + isTrue, + reason: '_routes should be final', + ); // Should contain RouteDef in type final fieldType = AstHelper.getVariableType(routesVar.variables); - expect(fieldType, contains('RouteDef'), - reason: 'Should be List of RouteDef'); + expect( + fieldType, + contains('RouteDef'), + reason: 'Should be List of RouteDef', + ); } /// Validate a getter method (class or top-level) by name and return type. @@ -218,19 +277,28 @@ class RouterHelperAstValidator { final functions = unit.declarations.whereType(); final function = functions.where((f) => f.name.lexeme == methodName).firstOrNull; - expect(function, isNotNull, - reason: 'Should contain $methodName function'); + expect( + function, + isNotNull, + reason: 'Should contain $methodName function', + ); returnType = function!.returnType?.toString(); // Functions don't have override annotations } if (shouldHaveOverride) { - expect(hasOverride, isTrue, - reason: '$methodName should have @override annotation'); + expect( + hasOverride, + isTrue, + reason: '$methodName should have @override annotation', + ); } - expect(returnType, contains(expectedReturnType), - reason: '$methodName should return $expectedReturnType'); + expect( + returnType, + contains(expectedReturnType), + reason: '$methodName should return $expectedReturnType', + ); } /// Validate a map structure variable: name, final, key/value types. @@ -250,19 +318,31 @@ class RouterHelperAstValidator { final mapVar = variables.first; final variableName = AstHelper.getVariableNames(mapVar.variables).first; - expect(variableName, equals(mapName), - reason: 'Variable should be named $mapName'); + expect( + variableName, + equals(mapName), + reason: 'Variable should be named $mapName', + ); // Should be final - expect(AstHelper.isVariableFinal(mapVar.variables), isTrue, - reason: '$mapName should be final'); + expect( + AstHelper.isVariableFinal(mapVar.variables), + isTrue, + reason: '$mapName should be final', + ); // Check type contains expected key and value types final fieldType = AstHelper.getVariableType(mapVar.variables); - expect(fieldType, contains(keyType), - reason: 'Should contain $keyType in map type'); - expect(fieldType, contains(valueType), - reason: 'Should contain $valueType in map type'); + expect( + fieldType, + contains(keyType), + reason: 'Should contain $keyType in map type', + ); + expect( + fieldType, + contains(valueType), + reason: 'Should contain $valueType in map type', + ); } /// Ensure imports exist and are aliased where expected (e.g., `as _i`). @@ -273,15 +353,21 @@ class RouterHelperAstValidator { final unit = AstHelper.parseCode(generatedCode); for (final importUri in expectedImports) { - expect(AstHelper.hasImport(unit, importUri), isTrue, - reason: 'Should import $importUri'); + expect( + AstHelper.hasImport(unit, importUri), + isTrue, + reason: 'Should import $importUri', + ); } // Validate that imports are aliased (should contain ' as _i') final imports = AstHelper.getImports(unit); final aliasedImports = imports.where((i) => i.prefix != null); - expect(aliasedImports, isNotEmpty, - reason: 'Should have aliased imports for avoiding conflicts'); + expect( + aliasedImports, + isNotEmpty, + reason: 'Should have aliased imports for avoiding conflicts', + ); } } @@ -348,7 +434,10 @@ class RouteClassGeneratorAstValidator { final nestedRoutesClassName = '${_capitalize(parentName)}Routes'; _validateRoutesClassExists( - unit, nestedRoutesClassName, parentRoute.children); + unit, + nestedRoutesClassName, + parentRoute.children, + ); _validateRouterClassExists(unit, nestedRouterClassName); } @@ -378,8 +467,11 @@ class RouteClassGeneratorAstValidator { if (routeWithParameters.parameters.isNotEmpty) { final argumentsClassName = '${routeWithParameters.className}Arguments'; final argumentsClass = AstHelper.findClass(unit, argumentsClassName); - expect(argumentsClass, isNotNull, - reason: 'Arguments class should exist for route with parameters'); + expect( + argumentsClass, + isNotNull, + reason: 'Arguments class should exist for route with parameters', + ); } } @@ -406,8 +498,11 @@ class RouteClassGeneratorAstValidator { expect(routerClass, isNotNull, reason: 'Router class should exist'); final pagesMapField = AstHelper.findField(routerClass!, '_pagesMap'); - expect(pagesMapField, isNotNull, - reason: 'Router should have _pagesMap field'); + expect( + pagesMapField, + isNotNull, + reason: 'Router should have _pagesMap field', + ); } // Private helper methods @@ -419,22 +514,30 @@ class RouteClassGeneratorAstValidator { List expectedRoutes, ) { final routesClass = AstHelper.findClass(unit, routesClassName); - expect(routesClass, isNotNull, - reason: 'Routes class $routesClassName should exist'); + expect( + routesClass, + isNotNull, + reason: 'Routes class $routesClassName should exist', + ); // Validate route constants for (final route in expectedRoutes) { final routeName = route.name ?? 'unknown'; final field = AstHelper.findField(routesClass!, routeName); - expect(field, isNotNull, - reason: - 'Route $routeName should have a constant in $routesClassName'); + expect( + field, + isNotNull, + reason: 'Route $routeName should have a constant in $routesClassName', + ); } // Validate 'all' field final allField = AstHelper.findField(routesClass!, 'all'); - expect(allField, isNotNull, - reason: '$routesClassName should have an "all" field'); + expect( + allField, + isNotNull, + reason: '$routesClassName should have an "all" field', + ); } /// Ensure router class exists, extends RouterBase, has fields/getters. @@ -443,25 +546,42 @@ class RouteClassGeneratorAstValidator { String routerClassName, ) { final routerClass = AstHelper.findClass(unit, routerClassName); - expect(routerClass, isNotNull, - reason: 'Router class $routerClassName should exist'); + expect( + routerClass, + isNotNull, + reason: 'Router class $routerClassName should exist', + ); // Check inheritance - expect(routerClass!.extendsClause?.superclass.name2.lexeme, - contains('RouterBase'), - reason: '$routerClassName should extend RouterBase'); + expect( + routerClass!.extendsClause?.superclass.name.lexeme, + contains('RouterBase'), + reason: '$routerClassName should extend RouterBase', + ); // Check required fields - expect(AstHelper.findField(routerClass, '_routes'), isNotNull, - reason: '$routerClassName should have _routes field'); - expect(AstHelper.findField(routerClass, '_pagesMap'), isNotNull, - reason: '$routerClassName should have _pagesMap field'); + expect( + AstHelper.findField(routerClass, '_routes'), + isNotNull, + reason: '$routerClassName should have _routes field', + ); + expect( + AstHelper.findField(routerClass, '_pagesMap'), + isNotNull, + reason: '$routerClassName should have _pagesMap field', + ); // Check required getters - expect(AstHelper.findMethod(routerClass, 'routes'), isNotNull, - reason: '$routerClassName should have routes getter'); - expect(AstHelper.findMethod(routerClass, 'pagesMap'), isNotNull, - reason: '$routerClassName should have pagesMap getter'); + expect( + AstHelper.findMethod(routerClass, 'routes'), + isNotNull, + reason: '$routerClassName should have routes getter', + ); + expect( + AstHelper.findMethod(routerClass, 'pagesMap'), + isNotNull, + reason: '$routerClassName should have pagesMap getter', + ); } /// Ensure navigation extension exists with navigateTo/replaceWith methods. @@ -482,22 +602,35 @@ class RouteClassGeneratorAstValidator { final navigateName = 'navigateTo${_capitalize(routeName)}'; final replaceName = 'replaceWith${_capitalize(routeName)}'; - final navigateMethod = - AstHelper.findMethodInExtension(declaration, navigateName); - final replaceMethod = - AstHelper.findMethodInExtension(declaration, replaceName); - - expect(navigateMethod, isNotNull, - reason: 'Extension should have $navigateName method'); - expect(replaceMethod, isNotNull, - reason: 'Extension should have $replaceName method'); + final navigateMethod = AstHelper.findMethodInExtension( + declaration, + navigateName, + ); + final replaceMethod = AstHelper.findMethodInExtension( + declaration, + replaceName, + ); + + expect( + navigateMethod, + isNotNull, + reason: 'Extension should have $navigateName method', + ); + expect( + replaceMethod, + isNotNull, + reason: 'Extension should have $replaceName method', + ); } break; } } - expect(extensionFound, isTrue, - reason: 'NavigatorStateExtension should exist'); + expect( + extensionFound, + isTrue, + reason: 'NavigatorStateExtension should exist', + ); } /// Ensure argument classes exist for routes with non-query parameters. @@ -514,28 +647,44 @@ class RouteClassGeneratorAstValidator { final argumentsClassName = '${route.className}Arguments'; final argumentsClass = AstHelper.findClass(unit, argumentsClassName); - expect(argumentsClass, isNotNull, - reason: 'Arguments class $argumentsClassName should exist'); + expect( + argumentsClass, + isNotNull, + reason: 'Arguments class $argumentsClassName should exist', + ); if (argumentsClass != null) { // Validate constructor exists - final constructor = - AstHelper.findConstructor(argumentsClass, argumentsClassName); - expect(constructor, isNotNull, - reason: '$argumentsClassName should have a constructor'); + final constructor = AstHelper.findConstructor( + argumentsClass, + argumentsClassName, + ); + expect( + constructor, + isNotNull, + reason: '$argumentsClassName should have a constructor', + ); // Validate parameter fields exist for non-query params for (final param in nonQueryParams) { final field = AstHelper.findField(argumentsClass, param.name); - expect(field, isNotNull, - reason: '$argumentsClassName should have field ${param.name}'); + expect( + field, + isNotNull, + reason: '$argumentsClassName should have field ${param.name}', + ); } // Validate toString method exists - final toStringMethod = - AstHelper.findMethod(argumentsClass, 'toString'); - expect(toStringMethod, isNotNull, - reason: '$argumentsClassName should have toString method'); + final toStringMethod = AstHelper.findMethod( + argumentsClass, + 'toString', + ); + expect( + toStringMethod, + isNotNull, + reason: '$argumentsClassName should have toString method', + ); } } } @@ -578,8 +727,9 @@ class ArgumentsClassAstValidator { // Validate each route that has parameters for (final route in expectedRoutes) { - final nonQueryParams = route.parameters.where((p) => !p.isQueryParam).toList(); - + final nonQueryParams = + route.parameters.where((p) => !p.isQueryParam).toList(); + if (nonQueryParams.isNotEmpty) { final argumentsClassName = '${route.className}Arguments'; _validateSingleArgumentClass(unit, argumentsClassName, nonQueryParams); @@ -602,7 +752,10 @@ class ArgumentsClassAstValidator { // Private helper methods /// Validates imports for argument classes. - static void _validateArgumentClassImports(CompilationUnit unit, List routes) { + static void _validateArgumentClassImports( + CompilationUnit unit, + List routes, + ) { // Collect all imports needed for parameters final requiredImports = {}; for (final route in routes) { @@ -616,29 +769,39 @@ class ArgumentsClassAstValidator { // Validate each required import exists for (final importUri in requiredImports) { - expect(AstHelper.hasImport(unit, importUri), isTrue, - reason: 'Should import $importUri for parameter types'); + expect( + AstHelper.hasImport(unit, importUri), + isTrue, + reason: 'Should import $importUri for parameter types', + ); } } /// Validates a single argument class structure. static void _validateSingleArgumentClass( - CompilationUnit unit, - String className, - List expectedParameters + CompilationUnit unit, + String className, + List expectedParameters, ) { // Find the argument class final argumentClass = AstHelper.findClass(unit, className); - expect(argumentClass, isNotNull, - reason: 'Argument class $className should exist'); + expect( + argumentClass, + isNotNull, + reason: 'Argument class $className should exist', + ); if (argumentClass != null) { // Validate constructor - _validateArgumentClassConstructor(argumentClass, className, expectedParameters); - + _validateArgumentClassConstructor( + argumentClass, + className, + expectedParameters, + ); + // Validate fields _validateArgumentClassFields(argumentClass, expectedParameters); - + // Validate standard methods _validateArgumentClassMethods(argumentClass); } @@ -646,51 +809,71 @@ class ArgumentsClassAstValidator { /// Validates the constructor of an argument class. static void _validateArgumentClassConstructor( - ClassDeclaration argumentClass, - String className, - List expectedParameters + ClassDeclaration argumentClass, + String className, + List expectedParameters, ) { final constructor = AstHelper.findConstructor(argumentClass, className); - expect(constructor, isNotNull, - reason: '$className should have a constructor'); + expect( + constructor, + isNotNull, + reason: '$className should have a constructor', + ); if (constructor != null) { // Should be const constructor - expect(constructor.constKeyword, isNotNull, - reason: '$className constructor should be const'); + expect( + constructor.constKeyword, + isNotNull, + reason: '$className constructor should be const', + ); // Validate constructor parameters match expected parameters final constructorParams = constructor.parameters.parameters; - + // Count required and optional parameters - final requiredParams = expectedParameters.where((p) => p.isRequired).length; - final optionalParams = expectedParameters.where((p) => !p.isRequired).length; - - expect(constructorParams.length, - equals(requiredParams + optionalParams), - reason: '$className constructor should have ${expectedParameters.length} parameters'); + final requiredParams = + expectedParameters.where((p) => p.isRequired).length; + final optionalParams = + expectedParameters.where((p) => !p.isRequired).length; + + expect( + constructorParams.length, + equals(requiredParams + optionalParams), + reason: + '$className constructor should have ${expectedParameters.length} parameters', + ); } } /// Validates fields of an argument class. static void _validateArgumentClassFields( - ClassDeclaration argumentClass, - List expectedParameters + ClassDeclaration argumentClass, + List expectedParameters, ) { for (final param in expectedParameters) { final field = AstHelper.findField(argumentClass, param.name); - expect(field, isNotNull, - reason: 'Argument class should have field ${param.name}'); + expect( + field, + isNotNull, + reason: 'Argument class should have field ${param.name}', + ); if (field != null) { // Should be final - expect(AstHelper.isFieldFinal(field), isTrue, - reason: 'Field ${param.name} should be final'); + expect( + AstHelper.isFieldFinal(field), + isTrue, + reason: 'Field ${param.name} should be final', + ); // Validate field type contains expected type name final fieldType = AstHelper.getFieldType(field); - expect(fieldType, contains(param.type.name), - reason: 'Field ${param.name} should have type ${param.type.name}'); + expect( + fieldType, + contains(param.type.name), + reason: 'Field ${param.name} should have type ${param.type.name}', + ); } } } @@ -699,32 +882,50 @@ class ArgumentsClassAstValidator { static void _validateArgumentClassMethods(ClassDeclaration argumentClass) { // Validate toString method final toStringMethod = AstHelper.findMethod(argumentClass, 'toString'); - expect(toStringMethod, isNotNull, - reason: 'Argument class should have toString method'); + expect( + toStringMethod, + isNotNull, + reason: 'Argument class should have toString method', + ); if (toStringMethod != null) { - expect(AstHelper.hasOverrideAnnotation(toStringMethod), isTrue, - reason: 'toString method should have @override annotation'); + expect( + AstHelper.hasOverrideAnnotation(toStringMethod), + isTrue, + reason: 'toString method should have @override annotation', + ); } // Validate == operator method final equalsMethod = AstHelper.findMethod(argumentClass, '=='); - expect(equalsMethod, isNotNull, - reason: 'Argument class should have == operator'); + expect( + equalsMethod, + isNotNull, + reason: 'Argument class should have == operator', + ); if (equalsMethod != null) { - expect(AstHelper.hasOverrideAnnotation(equalsMethod), isTrue, - reason: '== operator should have @override annotation'); + expect( + AstHelper.hasOverrideAnnotation(equalsMethod), + isTrue, + reason: '== operator should have @override annotation', + ); } // Validate hashCode getter final hashCodeGetter = AstHelper.findMethod(argumentClass, 'hashCode'); - expect(hashCodeGetter, isNotNull, - reason: 'Argument class should have hashCode getter'); + expect( + hashCodeGetter, + isNotNull, + reason: 'Argument class should have hashCode getter', + ); if (hashCodeGetter != null) { - expect(AstHelper.hasOverrideAnnotation(hashCodeGetter), isTrue, - reason: 'hashCode getter should have @override annotation'); + expect( + AstHelper.hasOverrideAnnotation(hashCodeGetter), + isTrue, + reason: 'hashCode getter should have @override annotation', + ); } } } @@ -758,16 +959,19 @@ class RoutesClassAstValidator { // Find the routes class final routesClass = AstHelper.findClass(unit, expectedClassName); - expect(routesClass, isNotNull, - reason: 'Routes class $expectedClassName should exist'); + expect( + routesClass, + isNotNull, + reason: 'Routes class $expectedClassName should exist', + ); if (routesClass != null) { // Validate static const fields for each route _validateRouteConstants(routesClass, expectedRoutes); - + // Validate 'all' field _validateAllField(routesClass, expectedRoutes); - + // Validate dynamic path methods for parameterized routes _validateDynamicPathMethods(routesClass, expectedRoutes); } @@ -776,90 +980,136 @@ class RoutesClassAstValidator { // Private helper methods /// Validates static const fields for each route. - static void _validateRouteConstants(ClassDeclaration routesClass, List expectedRoutes) { + static void _validateRouteConstants( + ClassDeclaration routesClass, + List expectedRoutes, + ) { for (final route in expectedRoutes) { final routeName = route.name ?? 'unknown'; final field = AstHelper.findField(routesClass, routeName); - - expect(field, isNotNull, - reason: 'Routes class should have constant for $routeName'); + + expect( + field, + isNotNull, + reason: 'Routes class should have constant for $routeName', + ); if (field != null) { // Should be static - expect(field.isStatic, isTrue, - reason: 'Route constant $routeName should be static'); - + expect( + field.isStatic, + isTrue, + reason: 'Route constant $routeName should be static', + ); + // Should be const or final (check for const or final keywords) - final isConstOrFinal = AstHelper.isFieldFinal(field) || - field.fields.variables.first.toString().contains('const') || - field.fields.keyword?.lexeme == 'const'; - expect(isConstOrFinal, isTrue, - reason: 'Route constant $routeName should be const or final'); + final isConstOrFinal = + AstHelper.isFieldFinal(field) || + field.fields.variables.first.toString().contains('const') || + field.fields.keyword?.lexeme == 'const'; + expect( + isConstOrFinal, + isTrue, + reason: 'Route constant $routeName should be const or final', + ); // Should have String type or be inferred (type checking is optional for constants) final fieldType = AstHelper.getFieldType(field); if (fieldType != null) { - expect(fieldType, anyOf(contains('String'), equals('')), - reason: 'Route constant $routeName should be String type when explicitly typed'); + expect( + fieldType, + anyOf(contains('String'), equals('')), + reason: + 'Route constant $routeName should be String type when explicitly typed', + ); } } } } /// Validates the 'all' field that contains all route names. - static void _validateAllField(ClassDeclaration routesClass, List expectedRoutes) { + static void _validateAllField( + ClassDeclaration routesClass, + List expectedRoutes, + ) { final allField = AstHelper.findField(routesClass, 'all'); - expect(allField, isNotNull, - reason: 'Routes class should have an "all" field'); + expect( + allField, + isNotNull, + reason: 'Routes class should have an "all" field', + ); if (allField != null) { // Should be static - expect(allField.isStatic, isTrue, - reason: '"all" field should be static'); - + expect(allField.isStatic, isTrue, reason: '"all" field should be static'); + // Should be const or final (check for const or final keywords) - final isConstOrFinal = AstHelper.isFieldFinal(allField) || - allField.fields.variables.first.toString().contains('const') || - allField.fields.keyword?.lexeme == 'const'; - expect(isConstOrFinal, isTrue, - reason: '"all" field should be const or final'); + final isConstOrFinal = + AstHelper.isFieldFinal(allField) || + allField.fields.variables.first.toString().contains('const') || + allField.fields.keyword?.lexeme == 'const'; + expect( + isConstOrFinal, + isTrue, + reason: '"all" field should be const or final', + ); // Should have Set type or be inferred final fieldType = AstHelper.getFieldType(allField); if (fieldType != null) { - expect(fieldType, anyOf(contains('Set'), contains('String')), - reason: '"all" field should be Set type when explicitly typed'); + expect( + fieldType, + anyOf(contains('Set'), contains('String')), + reason: + '"all" field should be Set type when explicitly typed', + ); } } } /// Validates dynamic path methods for routes with path parameters. - static void _validateDynamicPathMethods(ClassDeclaration routesClass, List expectedRoutes) { + static void _validateDynamicPathMethods( + ClassDeclaration routesClass, + List expectedRoutes, + ) { for (final route in expectedRoutes) { // Check if route has path parameters (contains :param in pathName) final pathName = route.pathName; if (pathName.contains(':')) { final routeName = route.name ?? 'unknown'; final methodName = routeName; - + final method = AstHelper.findMethod(routesClass, methodName); - expect(method, isNotNull, - reason: 'Routes class should have dynamic path method for $routeName'); + expect( + method, + isNotNull, + reason: 'Routes class should have dynamic path method for $routeName', + ); if (method != null) { // Should be static - expect(method.isStatic, isTrue, - reason: 'Dynamic path method $methodName should be static'); - + expect( + method.isStatic, + isTrue, + reason: 'Dynamic path method $methodName should be static', + ); + // Should return String final returnType = AstHelper.getMethodReturnType(method); - expect(returnType, contains('String'), - reason: 'Dynamic path method $methodName should return String'); - + expect( + returnType, + contains('String'), + reason: 'Dynamic path method $methodName should return String', + ); + // Should have parameters for path variables final parameters = method.parameters?.parameters ?? []; - expect(parameters, isNotEmpty, - reason: 'Dynamic path method $methodName should have parameters for path variables'); + expect( + parameters, + isNotEmpty, + reason: + 'Dynamic path method $methodName should have parameters for path variables', + ); } } } @@ -897,8 +1147,11 @@ class NavigationExtensionAstValidator { // Find the extension final extension = _findExtension(unit, extensionName); - expect(extension, isNotNull, - reason: 'Should contain extension $extensionName'); + expect( + extension, + isNotNull, + reason: 'Should contain extension $extensionName', + ); if (extension != null) { // Validate navigation methods for each route @@ -909,7 +1162,10 @@ class NavigationExtensionAstValidator { // Private helper methods /// Finds an extension declaration by name. - static ExtensionDeclaration? _findExtension(CompilationUnit unit, String name) { + static ExtensionDeclaration? _findExtension( + CompilationUnit unit, + String name, + ) { for (final declaration in unit.declarations) { if (declaration is ExtensionDeclaration && declaration.name?.lexeme == name) { @@ -927,10 +1183,13 @@ class NavigationExtensionAstValidator { for (final route in expectedRoutes) { final routeName = route.name ?? 'unknown'; final methodName = 'navigateTo${_capitalize(routeName)}'; - + final method = _findMethodInExtension(extension, methodName); - expect(method, isNotNull, - reason: 'Extension should have method $methodName for route $routeName'); + expect( + method, + isNotNull, + reason: 'Extension should have method $methodName for route $routeName', + ); if (method != null) { // Validate method parameters match route parameters @@ -964,12 +1223,16 @@ class NavigationExtensionAstValidator { if (routeParameters.isNotEmpty) { // Should have some way to handle parameters (either direct params or arguments object) final methodSignature = method.toString(); - final hasParameterHandling = parameters.isNotEmpty || + final hasParameterHandling = + parameters.isNotEmpty || methodSignature.contains('arguments') || methodSignature.contains('Arguments'); - - expect(hasParameterHandling, isTrue, - reason: 'Method $methodName should handle route parameters somehow'); + + expect( + hasParameterHandling, + isTrue, + reason: 'Method $methodName should handle route parameters somehow', + ); } } diff --git a/test/helpers/element2_mock_helper.dart b/test/helpers/element2_mock_helper.dart index 764e175..8e91963 100644 --- a/test/helpers/element2_mock_helper.dart +++ b/test/helpers/element2_mock_helper.dart @@ -1,72 +1,73 @@ -import 'package:analyzer/dart/element/element2.dart'; +import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/source/source.dart'; /// Custom mock source that returns a specific URI class _MockSource implements Source { final Uri _uri; - + _MockSource(this._uri); @override Uri get uri => _uri; - + // Use noSuchMethod to handle all other Source methods we don't need @override - dynamic noSuchMethod(Invocation invocation) => throw UnimplementedError('${invocation.memberName} not implemented'); + dynamic noSuchMethod(Invocation invocation) => + throw UnimplementedError('${invocation.memberName} not implemented'); } /// Custom mock library fragment class _MockLibraryFragment implements LibraryFragment { final Source _source; - + _MockLibraryFragment(this._source); @override Source get source => _source; - + // Implement other required methods (throwing UnimplementedError for unused ones) @override dynamic noSuchMethod(Invocation invocation) => throw UnimplementedError(); } -/// Custom mock class fragment +/// Custom mock class fragment class _MockClassFragment implements ClassFragment { final LibraryFragment _libraryFragment; - + _MockClassFragment(this._libraryFragment); @override LibraryFragment get libraryFragment => _libraryFragment; - + // Implement other required methods @override dynamic noSuchMethod(Invocation invocation) => throw UnimplementedError(); } /// Custom mock ClassElement2 -class _MockClassElement2 implements ClassElement2 { +class _MockClassElement2 implements ClassElement { final ClassFragment _firstFragment; - + _MockClassElement2(this._firstFragment); @override ClassFragment get firstFragment => _firstFragment; - + // Implement other required methods @override dynamic noSuchMethod(Invocation invocation) => throw UnimplementedError(); } /// Creates a mock ClassElement2 for testing Router 2.0 code generation -/// +/// /// [fileName] - The filename to use for the mock element (defaults to 'test_app.dart') -ClassElement2 createMockClassElement2({String fileName = 'test_app.dart'}) { +ClassElement createMockClassElement2({String fileName = 'test_app.dart'}) { // Create the chain from bottom up final uri = Uri.parse('package:test_app/lib/$fileName'); final mockSource = _MockSource(uri); final mockLibraryFragment = _MockLibraryFragment(mockSource); final mockClassFragment = _MockClassFragment(mockLibraryFragment); final mockElement = _MockClassElement2(mockClassFragment); - + return mockElement; -} \ No newline at end of file +}