mirror of
https://github.com/pese-git/cherrypick.git
synced 2026-01-23 21:13:35 +00:00
365 lines
15 KiB
Dart
365 lines
15 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 'package:analyzer/dart/element/element.dart';
|
||
import 'package:build/build.dart';
|
||
import 'package:source_gen/source_gen.dart';
|
||
import 'package:cherrypick_annotations/cherrypick_annotations.dart' as ann;
|
||
|
||
///
|
||
/// Генератор зависимостей для DI-контейнера на основе аннотаций.
|
||
///
|
||
/// Данный генератор автоматически создаёт код для внедрения зависимостей (DI)
|
||
/// на основе аннотаций в вашем исходном коде. Когда вы отмечаете класс
|
||
/// аннотацией `@module()`, этот генератор обработает все его публичные методы
|
||
/// и автоматически сгенерирует класс с биндингами (регистрациями зависимостей)
|
||
/// для DI-контейнера. Это избавляет от написания однообразного шаблонного кода.
|
||
///
|
||
class ModuleGenerator extends GeneratorForAnnotation<ann.module> {
|
||
/// Генерирует исходный код для класса-модуля с аннотацией `@module()`.
|
||
///
|
||
/// [element] — исходный класс, помеченный аннотацией.
|
||
/// [annotation] — значения параметров аннотации.
|
||
/// [buildStep] — информация о текущем шаге генерации.
|
||
@override
|
||
String generateForAnnotatedElement(
|
||
Element element,
|
||
ConstantReader annotation,
|
||
BuildStep buildStep,
|
||
) {
|
||
// Генератор обрабатывает только классы (остальное — ошибка)
|
||
if (element is! ClassElement) {
|
||
throw InvalidGenerationSourceError(
|
||
'@module() может быть применён только к классам.',
|
||
element: element,
|
||
);
|
||
}
|
||
|
||
final classElement = element;
|
||
|
||
// Создаёт объект, описывающий, какие биндинги нужно сгенерировать на основании методов класса
|
||
final generatedClass = _GeneratedClass.fromClassElement(classElement);
|
||
|
||
// Генерирует итоговый Dart-код
|
||
return generatedClass.generate();
|
||
}
|
||
}
|
||
|
||
///
|
||
/// Описывает параметры для создания одного биндинга зависимости (binding spec).
|
||
///
|
||
/// Каждый биндинг соответствует одному публичному методу класса-модуля.
|
||
///
|
||
class BindSpec {
|
||
/// Тип, который предоставляет биндинг (например, SomeService)
|
||
final String returnType;
|
||
|
||
/// Имя метода, который реализует биндинг
|
||
final String methodName;
|
||
|
||
/// Необязательное имя, для именованной зависимости (используется с @named)
|
||
final String? named;
|
||
|
||
/// Является ли зависимость синглтоном (имеется ли аннотация @singleton)
|
||
final bool isSingleton;
|
||
|
||
/// Список параметров, которые требуются методу для внедрения зависимостей
|
||
final List<BindParameterSpec> parameters;
|
||
|
||
final String bindingType; // 'instance' | 'provide'
|
||
|
||
final bool isAsyncInstance;
|
||
|
||
final bool isAsyncProvide;
|
||
|
||
final bool hasParams;
|
||
|
||
BindSpec({
|
||
required this.returnType,
|
||
required this.methodName,
|
||
required this.isSingleton,
|
||
required this.parameters,
|
||
this.named,
|
||
required this.bindingType,
|
||
required this.isAsyncInstance,
|
||
required this.isAsyncProvide,
|
||
required this.hasParams,
|
||
});
|
||
|
||
/// Формирует dart-код для биндинга, например:
|
||
/// bind<Type>().toProvide(() => method(args)).withName('name').singleton();
|
||
///
|
||
/// Параметр [indent] задаёт отступ для красивого форматирования кода.
|
||
String generateBind(int indent) {
|
||
final indentStr = ' ' * indent;
|
||
|
||
// Если есть @params()
|
||
const paramVar = 'args'; // <= новое имя для безопасности
|
||
|
||
if (hasParams) {
|
||
final fnArgs = parameters
|
||
.map((p) => p.isParams ? paramVar : p.generateArg(paramVar))
|
||
.join(', ');
|
||
String provide;
|
||
if (bindingType == 'instance') {
|
||
provide = isAsyncInstance
|
||
? '.toInstanceAsync(($fnArgs) => $methodName($fnArgs))'
|
||
: '.toInstance(($fnArgs) => $methodName($fnArgs))';
|
||
} else if (isAsyncProvide) {
|
||
provide = (fnArgs.length > 60 || fnArgs.contains('\n'))
|
||
? '.toProvideAsyncWithParams(\n${' ' * (indent + 2)}($paramVar) => $methodName($fnArgs))'
|
||
: '.toProvideAsyncWithParams(($paramVar) => $methodName($fnArgs))';
|
||
} else {
|
||
provide = (fnArgs.length > 60 || fnArgs.contains('\n'))
|
||
? '.toProvideWithParams(\n${' ' * (indent + 2)}($paramVar) => $methodName($fnArgs))'
|
||
: '.toProvideWithParams(($paramVar) => $methodName($fnArgs))';
|
||
}
|
||
final namePart = named != null ? ".withName('$named')" : '';
|
||
final singletonPart = isSingleton ? '.singleton()' : '';
|
||
return '$indentStr'
|
||
'bind<$returnType>()'
|
||
'$provide'
|
||
'$namePart'
|
||
'$singletonPart;';
|
||
}
|
||
|
||
// Собираем строку аргументов для вызова метода
|
||
final argsStr = parameters.map((p) => p.generateArg()).join(', ');
|
||
|
||
// Если аргументов много или они длинные — разбиваем вызов на несколько строк
|
||
//final needMultiline = argsStr.length > 60 || argsStr.contains('\n');
|
||
|
||
String provide;
|
||
if (bindingType == 'instance') {
|
||
// Добавляем async вариант для Future<T>
|
||
if (isAsyncInstance) {
|
||
provide = '.toInstanceAsync($methodName($argsStr))';
|
||
} else {
|
||
provide = '.toInstance($methodName($argsStr))';
|
||
}
|
||
} else {
|
||
// provide
|
||
if (isAsyncProvide) {
|
||
// Асинхронная фабрика
|
||
provide = (argsStr.length > 60 || argsStr.contains('\n'))
|
||
? '.toProvideAsync(\n${' ' * (indent + 2)}() => $methodName($argsStr))'
|
||
: '.toProvideAsync(() => $methodName($argsStr))';
|
||
} else {
|
||
provide = (argsStr.length > 60 || argsStr.contains('\n'))
|
||
? '.toProvide(\n${' ' * (indent + 2)}() => $methodName($argsStr))'
|
||
: '.toProvide(() => $methodName($argsStr))';
|
||
}
|
||
}
|
||
|
||
final namePart = named != null ? ".withName('$named')" : '';
|
||
final singletonPart = isSingleton ? '.singleton()' : '';
|
||
|
||
// Итоговый bind: bind<Type>().toProvide(...).withName(...).singleton();
|
||
return '$indentStr'
|
||
'bind<$returnType>()'
|
||
'$provide'
|
||
'$namePart'
|
||
'$singletonPart;';
|
||
// Всегда заканчиваем точкой с запятой!
|
||
}
|
||
|
||
/// Создаёт спецификацию биндинга (BindSpec) из метода класса-модуля
|
||
static BindSpec fromMethod(MethodElement method) {
|
||
var returnType = method.returnType.getDisplayString();
|
||
|
||
final methodName = method.displayName;
|
||
// Проверим, помечен ли метод аннотацией @singleton
|
||
final isSingleton = _MetadataUtils.anyMeta(method.metadata, 'singleton');
|
||
|
||
// Получаем имя из @named(), если есть
|
||
final named = _MetadataUtils.getNamedValue(method.metadata);
|
||
|
||
// Для каждого параметра метода
|
||
final params = <BindParameterSpec>[];
|
||
bool hasParams = false;
|
||
for (final p in method.parameters) {
|
||
final typeStr = p.type.getDisplayString();
|
||
final paramNamed = _MetadataUtils.getNamedValue(p.metadata);
|
||
final isParams = _MetadataUtils.anyMeta(p.metadata, 'params');
|
||
if (isParams) hasParams = true;
|
||
params.add(BindParameterSpec(typeStr, paramNamed, isParams: isParams));
|
||
}
|
||
|
||
// определяем bindingType
|
||
final hasInstance = _MetadataUtils.anyMeta(method.metadata, 'instance');
|
||
final hasProvide = _MetadataUtils.anyMeta(method.metadata, 'provide');
|
||
if (!hasInstance && !hasProvide) {
|
||
throw InvalidGenerationSourceError(
|
||
'Метод $methodName класса-модуля должен быть помечен либо @instance(), либо @provide().',
|
||
element: method,
|
||
);
|
||
}
|
||
final bindingType = hasInstance ? 'instance' : 'provide';
|
||
|
||
// --- Новый участок: извлекаем внутренний тип из Future<> и выставляем флаги
|
||
bool isAsyncInstance = false;
|
||
bool isAsyncProvide = false;
|
||
|
||
if (returnType.startsWith('Future<')) {
|
||
final futureMatch = RegExp(r'^Future<(.+)>$').firstMatch(returnType);
|
||
if (futureMatch != null) {
|
||
returnType = futureMatch.group(1)!.trim();
|
||
if (bindingType == 'instance') isAsyncInstance = true;
|
||
if (bindingType == 'provide') isAsyncProvide = true;
|
||
}
|
||
}
|
||
|
||
return BindSpec(
|
||
returnType: returnType,
|
||
methodName: methodName,
|
||
isSingleton: isSingleton,
|
||
named: named,
|
||
parameters: params,
|
||
bindingType: bindingType,
|
||
isAsyncInstance: isAsyncInstance,
|
||
isAsyncProvide: isAsyncProvide,
|
||
hasParams: hasParams,
|
||
);
|
||
}
|
||
}
|
||
|
||
///
|
||
/// Описывает один параметр метода и возможность его разрешения из контейнера.
|
||
///
|
||
/// Например, если метод принимает SomeDep dep, то
|
||
/// BindParameterSpec хранит тип SomeDep, а generateArg отдаст строку
|
||
/// currentScope.resolve<SomeDep>()
|
||
///
|
||
class BindParameterSpec {
|
||
/// Имя типа параметра (например, SomeService)
|
||
final String typeName;
|
||
|
||
/// Необязательное имя для разрешения по имени (если аннотировано через @named)
|
||
final String? named;
|
||
|
||
final bool isParams;
|
||
|
||
BindParameterSpec(this.typeName, this.named, {this.isParams = false});
|
||
|
||
/// Генерирует строку для получения зависимости из DI scope (с учётом имени)
|
||
String generateArg([String paramsVar = 'args']) {
|
||
if (isParams) {
|
||
return paramsVar;
|
||
}
|
||
if (named != null) {
|
||
return "currentScope.resolve<$typeName>(named: '$named')";
|
||
}
|
||
return "currentScope.resolve<$typeName>()";
|
||
}
|
||
}
|
||
|
||
///
|
||
/// Результат обработки одного класса-модуля: имя класса, его биндинги,
|
||
/// имя генерируемого класса и т.д.
|
||
///
|
||
class _GeneratedClass {
|
||
/// Имя исходного класса-модуля
|
||
final String className;
|
||
|
||
/// Имя генерируемого класса (например, $SomeModule)
|
||
final String generatedClassName;
|
||
|
||
/// Список всех обнаруженных биндингов
|
||
final List<BindSpec> binds;
|
||
|
||
_GeneratedClass(
|
||
this.className,
|
||
this.generatedClassName,
|
||
this.binds,
|
||
);
|
||
|
||
/// Обрабатывает объект ClassElement (отображение класса в AST)
|
||
/// и строит структуру _GeneratedClass для генерации кода.
|
||
static _GeneratedClass fromClassElement(ClassElement element) {
|
||
final className = element.displayName;
|
||
// Имя с префиксом $ (стандартная практика для ген-кода)
|
||
final generatedClassName = r'$' + className;
|
||
// Собираем биндинги по всем методам класса, игнорируем абстрактные (без реализации)
|
||
final binds = element.methods
|
||
.where((m) => !m.isAbstract)
|
||
.map(BindSpec.fromMethod)
|
||
.toList();
|
||
|
||
return _GeneratedClass(className, generatedClassName, binds);
|
||
}
|
||
|
||
/// Генерирует исходный Dart-код для созданного класса DI-модуля.
|
||
///
|
||
/// Внутри builder(Scope currentScope) регистрируются все bind-методы.
|
||
String generate() {
|
||
final buffer = StringBuffer();
|
||
|
||
buffer.writeln('final class $generatedClassName extends $className {');
|
||
buffer.writeln(' @override');
|
||
buffer.writeln(' void builder(Scope currentScope) {');
|
||
|
||
// Для каждого биндинга — генерируем строку bind<Type>()...
|
||
for (final bind in binds) {
|
||
buffer.writeln(bind.generateBind(4));
|
||
}
|
||
|
||
buffer.writeln(' }');
|
||
buffer.writeln('}');
|
||
|
||
return buffer.toString();
|
||
}
|
||
}
|
||
|
||
///
|
||
/// Утилиты для разбора аннотаций методов и параметров.
|
||
/// Позволяют найти @named() и @singleton() у метода/параметра.
|
||
///
|
||
class _MetadataUtils {
|
||
/// Проверяет: есть ли среди аннотаций метка, имя которой содержит [typeName]
|
||
/// (регистр не учитывается)
|
||
static bool anyMeta(List<ElementAnnotation> meta, String typeName) {
|
||
return meta.any((m) =>
|
||
m
|
||
.computeConstantValue()
|
||
?.type
|
||
?.getDisplayString()
|
||
.toLowerCase()
|
||
.contains(typeName.toLowerCase()) ??
|
||
false);
|
||
}
|
||
|
||
/// Находит значение из аннотации @named('значение').
|
||
/// Возвращает строку значения, если аннотация присутствует; иначе null.
|
||
static String? getNamedValue(List<ElementAnnotation> meta) {
|
||
for (final m in meta) {
|
||
final cv = m.computeConstantValue();
|
||
|
||
final typeStr = cv?.type?.getDisplayString().toLowerCase();
|
||
|
||
if (typeStr?.contains('named') ?? false) {
|
||
return cv?.getField('value')?.toStringValue();
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
}
|
||
|
||
///
|
||
/// Точка входа для генератора build_runner.
|
||
/// Возвращает Builder, используемый build_runner для генерации кода для всех
|
||
/// файлов, где встречается @module().
|
||
///
|
||
Builder moduleBuilder(BuilderOptions options) =>
|
||
PartBuilder([ModuleGenerator()], '.cherrypick.g.dart');
|