mirror of
https://github.com/pese-git/cherrypick.git
synced 2026-01-24 13:47:24 +00:00
edc2a14ad7
- Removed all unused imports and variables across generator sources and tests - Applied Dart 3 super parameters to all custom exceptions - Project now passes 'dart analyze' with zero warnings or infos - All tests (164/164) are green This commit improves code clarity and ensures full compliance with modern Dart best practices.
268 lines
10 KiB
Dart
268 lines
10 KiB
Dart
//
|
||
// Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
// http://www.apache.org/licenses/LICENSE-2.0
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
//
|
||
|
||
import 'dart:async';
|
||
import 'package:analyzer/dart/constant/value.dart';
|
||
|
||
|
||
import 'package:build/build.dart';
|
||
import 'package:source_gen/source_gen.dart';
|
||
import 'package:analyzer/dart/element/element.dart';
|
||
import 'package:cherrypick_annotations/cherrypick_annotations.dart' as ann;
|
||
import 'cherrypick_custom_builders.dart' as custom;
|
||
import 'src/exceptions.dart';
|
||
import 'src/type_parser.dart';
|
||
import 'src/annotation_validator.dart';
|
||
|
||
/// InjectGenerator generates a mixin for a class marked with @injectable()
|
||
/// and injects all fields annotated with @inject(), using CherryPick DI.
|
||
///
|
||
/// For Future<T> fields it calls .resolveAsync<T>(),
|
||
/// otherwise .resolve<T>() is used. Scope and named qualifiers are supported.
|
||
///
|
||
/// ---
|
||
///
|
||
/// InjectGenerator генерирует миксин для класса с аннотацией @injectable()
|
||
/// и внедряет все поля, помеченные @inject(), используя DI-фреймворк CherryPick.
|
||
///
|
||
/// Для Future<T> полей вызывается .resolveAsync<T>(),
|
||
/// для остальных — .resolve<T>(). Поддерживаются scope и named qualifier.
|
||
///
|
||
class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
|
||
const InjectGenerator();
|
||
|
||
/// The main entry point for code generation.
|
||
///
|
||
/// Checks class validity, collects injectable fields, and produces injection code.
|
||
///
|
||
/// Основная точка входа генератора. Проверяет класс, собирает инъектируемые поля и создает код внедрения зависимостей.
|
||
@override
|
||
FutureOr<String> generateForAnnotatedElement(
|
||
Element element,
|
||
ConstantReader annotation,
|
||
BuildStep buildStep,
|
||
) {
|
||
if (element is! ClassElement) {
|
||
throw CherryPickGeneratorException(
|
||
'@injectable() can only be applied to classes',
|
||
element: element,
|
||
category: 'INVALID_TARGET',
|
||
suggestion: 'Apply @injectable() to a class instead of ${element.runtimeType}',
|
||
);
|
||
}
|
||
|
||
final classElement = element;
|
||
|
||
try {
|
||
// Validate class annotations
|
||
AnnotationValidator.validateClassAnnotations(classElement);
|
||
|
||
return _generateInjectionCode(classElement);
|
||
} catch (e) {
|
||
if (e is CherryPickGeneratorException) {
|
||
rethrow;
|
||
}
|
||
throw CodeGenerationException(
|
||
'Failed to generate injection code: $e',
|
||
element: classElement,
|
||
suggestion: 'Check that all @inject fields have valid types and annotations',
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Generates the injection code for a class
|
||
String _generateInjectionCode(ClassElement classElement) {
|
||
final className = classElement.name;
|
||
final mixinName = '_\$$className';
|
||
|
||
// Collect and process all @inject fields.
|
||
final injectFields = classElement.fields
|
||
.where(_isInjectField)
|
||
.map((field) => _parseInjectField(field, classElement))
|
||
.toList();
|
||
|
||
final buffer = StringBuffer()
|
||
..writeln('// dart format width=80')
|
||
..writeln('// GENERATED CODE - DO NOT MODIFY BY HAND')
|
||
..writeln()
|
||
..writeln('// **************************************************************************')
|
||
..writeln('// InjectGenerator')
|
||
..writeln('// **************************************************************************')
|
||
..writeln()
|
||
..writeln('mixin $mixinName {');
|
||
|
||
if (injectFields.isEmpty) {
|
||
// For empty classes, generate a method with empty body
|
||
buffer.writeln(' void _inject($className instance) {}');
|
||
} else {
|
||
buffer.writeln(' void _inject($className instance) {');
|
||
for (final parsedField in injectFields) {
|
||
buffer.writeln(_generateInjectionLine(parsedField));
|
||
}
|
||
buffer.writeln(' }');
|
||
}
|
||
|
||
buffer.writeln('}');
|
||
|
||
return '${buffer.toString()}\n';
|
||
}
|
||
|
||
/// Checks if a field has the @inject annotation.
|
||
///
|
||
/// Проверяет, отмечено ли поле аннотацией @inject.
|
||
static bool _isInjectField(FieldElement field) {
|
||
return field.metadata.any(
|
||
(m) => m.computeConstantValue()?.type?.getDisplayString() == 'inject',
|
||
);
|
||
}
|
||
|
||
/// Parses the field for scope/named qualifiers and determines its type.
|
||
/// Returns a [_ParsedInjectField] describing injection information.
|
||
///
|
||
/// Разбирает поле на наличие модификаторов scope/named и выясняет его тип.
|
||
/// Возвращает [_ParsedInjectField] с информацией о внедрении.
|
||
static _ParsedInjectField _parseInjectField(FieldElement field, ClassElement classElement) {
|
||
try {
|
||
// Validate field annotations
|
||
AnnotationValidator.validateFieldAnnotations(field);
|
||
|
||
// Parse type using improved type parser
|
||
final parsedType = TypeParser.parseType(field.type, field);
|
||
TypeParser.validateInjectableType(parsedType, field);
|
||
|
||
// Extract metadata
|
||
String? scopeName;
|
||
String? namedValue;
|
||
|
||
for (final meta in field.metadata) {
|
||
final DartObject? obj = meta.computeConstantValue();
|
||
final type = obj?.type?.getDisplayString();
|
||
if (type == 'scope') {
|
||
scopeName = obj?.getField('name')?.toStringValue();
|
||
} else if (type == 'named') {
|
||
namedValue = obj?.getField('value')?.toStringValue();
|
||
}
|
||
}
|
||
|
||
return _ParsedInjectField(
|
||
fieldName: field.name,
|
||
parsedType: parsedType,
|
||
scopeName: scopeName,
|
||
namedValue: namedValue,
|
||
);
|
||
} catch (e) {
|
||
if (e is CherryPickGeneratorException) {
|
||
rethrow;
|
||
}
|
||
throw DependencyResolutionException(
|
||
'Failed to parse inject field "${field.name}"',
|
||
element: field,
|
||
suggestion: 'Check that the field type is valid and properly imported',
|
||
context: {
|
||
'field_name': field.name,
|
||
'field_type': field.type.getDisplayString(),
|
||
'class_name': classElement.name,
|
||
'error': e.toString(),
|
||
},
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Generates a line of code that performs the dependency injection for a field.
|
||
/// Handles resolve/resolveAsync, scoping, and named qualifiers.
|
||
///
|
||
/// Генерирует строку кода, которая внедряет зависимость для поля.
|
||
/// Учитывает resolve/resolveAsync, scoping и named qualifier.
|
||
String _generateInjectionLine(_ParsedInjectField field) {
|
||
final resolveMethod = '${field.parsedType.resolveMethodName}<${field.parsedType.codeGenType}>';
|
||
final fieldName = field.fieldName;
|
||
|
||
// Build the scope call
|
||
final openCall = (field.scopeName != null && field.scopeName!.isNotEmpty)
|
||
? "CherryPick.openScope(scopeName: '${field.scopeName}')"
|
||
: "CherryPick.openRootScope()";
|
||
|
||
// Build the parameters
|
||
final hasNamedParam = field.namedValue != null && field.namedValue!.isNotEmpty;
|
||
final params = hasNamedParam ? "(named: '${field.namedValue}')" : '()';
|
||
|
||
// Create the full line
|
||
final fullLine = " instance.$fieldName = $openCall.$resolveMethod$params;";
|
||
|
||
// Check if line is too long (dart format width=80, accounting for indentation)
|
||
if (fullLine.length <= 80) {
|
||
return fullLine;
|
||
}
|
||
|
||
// Format long lines with proper line breaks
|
||
if (hasNamedParam && field.scopeName != null && field.scopeName!.isNotEmpty) {
|
||
// For scoped calls with named parameters, break after openScope
|
||
return " instance.$fieldName = CherryPick.openScope(\n"
|
||
" scopeName: '${field.scopeName}',\n"
|
||
" ).$resolveMethod(named: '${field.namedValue}');";
|
||
} else if (hasNamedParam) {
|
||
// For named parameters without scope, break after the method call
|
||
return " instance.$fieldName = $openCall.$resolveMethod(\n"
|
||
" named: '${field.namedValue}',\n"
|
||
" );";
|
||
} else if (field.scopeName != null && field.scopeName!.isNotEmpty) {
|
||
// For scoped calls without named params, break after openScope with proper parameter formatting
|
||
return " instance.$fieldName = CherryPick.openScope(\n"
|
||
" scopeName: '${field.scopeName}',\n"
|
||
" ).$resolveMethod();";
|
||
} else {
|
||
// For simple long calls, break after openRootScope
|
||
return " instance.$fieldName = $openCall\n"
|
||
" .$resolveMethod();";
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Data structure representing all information required to generate
|
||
/// injection code for a field.
|
||
///
|
||
/// Структура данных, содержащая всю информацию,
|
||
/// необходимую для генерации кода внедрения для поля.
|
||
class _ParsedInjectField {
|
||
/// The name of the field / Имя поля.
|
||
final String fieldName;
|
||
|
||
/// Parsed type information / Информация о типе поля.
|
||
final ParsedType parsedType;
|
||
|
||
/// Optional scope annotation argument / Опциональное имя scope.
|
||
final String? scopeName;
|
||
|
||
/// Optional named annotation argument / Опциональное имя named.
|
||
final String? namedValue;
|
||
|
||
_ParsedInjectField({
|
||
required this.fieldName,
|
||
required this.parsedType,
|
||
this.scopeName,
|
||
this.namedValue,
|
||
});
|
||
|
||
@override
|
||
String toString() {
|
||
return '_ParsedInjectField(fieldName: $fieldName, parsedType: $parsedType, '
|
||
'scopeName: $scopeName, namedValue: $namedValue)';
|
||
}
|
||
}
|
||
|
||
/// Builder factory. Used by build_runner.
|
||
///
|
||
/// Фабрика билдера. Используется build_runner.
|
||
Builder injectBuilder(BuilderOptions options) =>
|
||
custom.injectCustomBuilder(options);
|