508 lines
19 KiB
Go
508 lines
19 KiB
Go
package provider
|
||
|
||
import (
|
||
"fmt"
|
||
"go/ast"
|
||
"go/parser"
|
||
"go/token"
|
||
"path/filepath"
|
||
"strings"
|
||
|
||
log "github.com/sirupsen/logrus"
|
||
"go.ipao.vip/atomctl/v2/pkg/utils/gomod"
|
||
)
|
||
|
||
// MainParser 重构后的主解析器，采用组合模式协调各个子组件完成 Provider 解析
|
||
//
|
||
// 架构设计：
|
||
// ┌─────────────────────────────────────────────────────────────┐
|
||
// │ MainParser (协调器) │
|
||
// ├─────────────────────────────────────────────────────────────┤
|
||
// │ commentParser │ importResolver │ astWalker │
|
||
// │ (注释解析器) │ (导入解析器) │ (AST遍历器) │
|
||
// ├─────────────────────────────────────────────────────────────┤
|
||
// │ builder │ validator │ config │
|
||
// │ (构建器) │ (验证器) │ (配置管理) │
|
||
// └─────────────────────────────────────────────────────────────┘
|
||
//
|
||
// 执行流程：
|
||
// 1. 文件过滤 → 2. AST解析 → 3. 导入处理 → 4. 注解发现 → 5. Provider构建 → 6. 验证
|
||
type MainParser struct {
|
||
commentParser *CommentParser // 负责解析 @provider 注解
|
||
importResolver *ImportResolver // 负责处理 Go 文件的导入信息
|
||
astWalker *ASTWalker // 负责遍历 AST 发现 Provider 注解
|
||
builder *ProviderBuilder // 负责从 AST 节点构建 Provider 对象
|
||
validator *GoValidator // 负责验证 Provider 配置的正确性
|
||
config *ParserConfig // 负责解析器配置管理
|
||
}
|
||
|
||
// NewParser 创建一个使用默认配置的 MainParser 实例
|
||
//
|
||
// 初始化流程：
|
||
// ┌─────────────────────────────────────────────────────────────┐
|
||
// │ NewParser() │
|
||
// ├─────────────────────────────────────────────────────────────┤
|
||
// │ 创建各个子组件实例： │
|
||
// │ - CommentParser: 解析 @provider 注释 │
|
||
// │ - ImportResolver: 处理导入依赖 │
|
||
// │ - ASTWalker: 遍历 AST 发现结构体 │
|
||
// │ - ProviderBuilder: 构建 Provider 对象 │
|
||
// │ - GoValidator: 验证 Provider 配置 │
|
||
// │ - ParserConfig: 默认配置 │
|
||
// └─────────────────────────────────────────────────────────────┘
|
||
//
|
||
// 返回值：配置好的 MainParser 实例，可直接调用 ParseFile() 或 ParseDir()
|
||
func NewParser() *MainParser {
|
||
return &MainParser{
|
||
commentParser: NewCommentParser(), // 初始化注释解析器
|
||
importResolver: NewImportResolver(), // 初始化导入解析器
|
||
astWalker: NewASTWalker(), // 初始化 AST 遍历器
|
||
builder: NewProviderBuilder(), // 初始化 Provider 构建器
|
||
validator: NewGoValidator(), // 初始化验证器
|
||
config: NewParserConfig(), // 初始化默认配置
|
||
}
|
||
}
|
||
|
||
// NewParserWithConfig creates a new MainParser with custom configuration
|
||
func NewParserWithConfig(config *ParserConfig) *MainParser {
|
||
if config == nil {
|
||
return NewParser()
|
||
}
|
||
|
||
return &MainParser{
|
||
commentParser: NewCommentParser(),
|
||
importResolver: NewImportResolver(),
|
||
astWalker: NewASTWalkerWithConfig(&WalkerConfig{
|
||
StrictMode: config.StrictMode,
|
||
}),
|
||
builder: NewProviderBuilderWithConfig(&BuilderConfig{
|
||
EnableValidation: config.StrictMode,
|
||
StrictMode: config.StrictMode,
|
||
DefaultProviderMode: ProviderModeBasic,
|
||
DefaultInjectionMode: InjectionModeAuto,
|
||
AutoGenerateReturnTypes: true,
|
||
ResolveImportDependencies: true,
|
||
}),
|
||
validator: NewGoValidator(),
|
||
config: config,
|
||
}
|
||
}
|
||
|
||
// ParseRefactored 重构后的单文件解析函数 - 替代原有的 Parse 函数
|
||
//
|
||
// 执行流程：
|
||
// ┌─────────────────────────────────────────────────────────────┐
|
||
// │ ParseRefactored(source) │
|
||
// ├─────────────────────────────────────────────────────────────┤
|
||
// │ 1. 创建解析器实例：NewParser() │
|
||
// │ 2. 调用文件解析：parser.ParseFile(source) │
|
||
// │ 3. 错误处理：如果解析失败，记录错误并返回空切片 │
|
||
// │ 4. 返回结果：返回发现的 Provider 切片 │
|
||
// └─────────────────────────────────────────────────────────────┘
|
||
//
|
||
// 参数：
|
||
// - source: Go 源文件路径
|
||
//
|
||
// 返回值：
|
||
// - []Provider: 解析到的 Provider 列表（如果失败则为空）
|
||
//
|
||
// 设计原则：
|
||
// - 简化接口：提供便捷的单函数调用方式
|
||
// - 错误处理：内部处理错误，避免调用者需要处理复杂错误
|
||
// - 兼容性：保持与原有 Parse 函数相同的签名，方便迁移
|
||
func ParseRefactored(source string) []Provider {
|
||
// 创建解析器实例
|
||
parser := NewParser()
|
||
|
||
// 调用详细的文件解析方法
|
||
providers, err := parser.ParseFile(source)
|
||
// 错误处理：记录错误并返回空结果
|
||
if err != nil {
|
||
log.Error("Parse error: ", err)
|
||
return []Provider{}
|
||
}
|
||
|
||
// 返回解析结果
|
||
return providers
|
||
}
|
||
|
||
// ParseFile 单文件解析的核心方法 - 详细解析 Go 源文件中的 Provider 注解
|
||
//
|
||
// 执行流程图：
|
||
// ┌─────────────────────────────────────────────────────────────┐
|
||
// │ ParseFile(source) │
|
||
// ├─────────────────────────────────────────────────────────────┤
|
||
// │ 1. 文件过滤：shouldProcessFile() │
|
||
// │ 2. AST解析：parser.ParseFile() │
|
||
// │ 3. 创建上下文：NewParserContext() │
|
||
// │ 4. 导入解析：ResolveFileImports() │
|
||
// │ 5. 构建上下文：BuilderContext{...} │
|
||
// │ 6. 注解发现：ProviderDiscoveryVisitor │
|
||
// │ 7. AST遍历：astWalker.WalkFile() │
|
||
// │ 8. Provider构建：buildProviderFromDiscovery() │
|
||
// │ 9. 验证检查：validator.Validate() │
|
||
// │ 10. 日志记录：记录警告和错误 │
|
||
// └─────────────────────────────────────────────────────────────┘
|
||
//
|
||
// 详细步骤说明：
|
||
// 步骤 1-2：文件预处理
|
||
// - 检查文件是否应该被处理（跳过测试文件和生成文件）
|
||
// - 使用 Go 标准库解析文件为 AST
|
||
//
|
||
// 步骤 3-5：上下文准备
|
||
// - 创建解析器上下文，包含工作目录和模块名
|
||
// - 解析文件的所有导入信息，建立包名映射
|
||
// - 创建构建器上下文，包含解析所需的所有信息
|
||
//
|
||
// 步骤 6-7：注解发现
|
||
// - 创建专门的访问器来发现 @provider 注解
|
||
// - 遍历 AST，收集所有带有 @provider 注解的结构体
|
||
//
|
||
// 步骤 8-9：Provider 构建
|
||
// - 对每个发现的注解，构建完整的 Provider 对象
|
||
// - 如果启用严格模式，验证 Provider 配置的正确性
|
||
//
|
||
// 步骤 10：结果处理
|
||
// - 记录解析过程中的所有警告和错误
|
||
// - 返回构建成功的 Provider 列表
|
||
func (p *MainParser) ParseFile(source string) ([]Provider, error) {
|
||
// === 步骤 1：文件过滤 ===
|
||
// 检查文件是否应该被处理，跳过测试文件和生成文件
|
||
if !p.shouldProcessFile(source) {
|
||
return []Provider{}, nil
|
||
}
|
||
|
||
// === 步骤 2：AST 解析 ===
|
||
// 使用 Go 标准库将源文件解析为抽象语法树
|
||
fset := token.NewFileSet()
|
||
node, err := parser.ParseFile(fset, source, nil, parser.ParseComments)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to parse file %s: %w", source, err)
|
||
}
|
||
|
||
// === 步骤 3：创建解析器上下文 ===
|
||
// 创建包含工作目录和模块信息的上下文
|
||
context := NewParserContext(p.config)
|
||
context.WorkingDir = filepath.Dir(source)
|
||
context.ModuleName = gomod.GetModuleName()
|
||
|
||
// === 步骤 4：导入解析 ===
|
||
// 解析文件的所有导入信息，建立包名到路径的映射
|
||
importContext, err := p.importResolver.ResolveFileImports(node, source)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to resolve imports: %w", err)
|
||
}
|
||
|
||
// === 步骤 5：创建构建器上下文 ===
|
||
// 创建包含解析所需所有信息的构建器上下文
|
||
builderContext := &BuilderContext{
|
||
FilePath: source, // 当前文件路径
|
||
PackageName: node.Name.Name, // 包名
|
||
ImportContext: importContext, // 导入信息上下文
|
||
ASTFile: node, // AST 节点
|
||
ProcessedTypes: make(map[string]bool), // 已处理的类型，避免重复
|
||
Errors: make([]error, 0), // 错误列表
|
||
Warnings: make([]string, 0), // 警告列表
|
||
}
|
||
|
||
// === 步骤 6：创建注解发现访问器 ===
|
||
// 创建专门的访问器来发现 @provider 注解
|
||
visitor := NewProviderDiscoveryVisitor(p.commentParser)
|
||
p.astWalker.AddVisitor(visitor)
|
||
|
||
// === 步骤 7：AST 遍历 ===
|
||
// 遍历 AST，发现所有带有 @provider 注解的结构体
|
||
if err := p.astWalker.WalkFile(source); err != nil {
|
||
return nil, fmt.Errorf("failed to walk AST: %w", err)
|
||
}
|
||
|
||
// === 步骤 8：Provider 构建和验证 ===
|
||
// 初始化结果列表
|
||
providers := make([]Provider, 0)
|
||
discoveredProviders := visitor.GetProviders()
|
||
|
||
// 对每个发现的注解构建 Provider 对象
|
||
for _, discoveredProvider := range discoveredProviders {
|
||
// 查找对应的 AST 节点
|
||
provider, err := p.buildProviderFromDiscovery(discoveredProvider, node, builderContext)
|
||
if err != nil {
|
||
context.AddError(source, 0, 0, fmt.Sprintf("failed to build provider %s: %v", discoveredProvider.StructName, err), "error")
|
||
continue
|
||
}
|
||
|
||
// 如果启用严格模式，验证 Provider 配置
|
||
if p.config.StrictMode {
|
||
if err := p.validator.Validate(&provider); err != nil {
|
||
context.AddError(source, 0, 0, fmt.Sprintf("validation failed for provider %s: %v", provider.StructName, err), "error")
|
||
continue
|
||
}
|
||
}
|
||
|
||
// 添加到结果列表
|
||
providers = append(providers, provider)
|
||
}
|
||
|
||
// === 步骤 9：日志记录 ===
|
||
// 记录解析过程中的所有警告和错误
|
||
for _, parseErr := range context.GetErrors("warning") {
|
||
log.Warnf("Warning while parsing %s: %s", source, parseErr.Message)
|
||
}
|
||
for _, parseErr := range context.GetErrors("error") {
|
||
log.Errorf("Error while parsing %s: %s", source, parseErr.Message)
|
||
}
|
||
|
||
// 返回构建成功的 Provider 列表
|
||
return providers, nil
|
||
}
|
||
|
||
// ParseDir parses all Go files in a directory and returns discovered providers
|
||
func (p *MainParser) ParseDir(dir string) ([]Provider, error) {
|
||
var allProviders []Provider
|
||
|
||
// Use AST walker to traverse the directory
|
||
if err := p.astWalker.WalkDir(dir); err != nil {
|
||
return nil, fmt.Errorf("failed to walk directory: %w", err)
|
||
}
|
||
|
||
// Note: This would need to be enhanced to collect providers from all files
|
||
// For now, we'll return an empty slice and log a warning
|
||
log.Warn("ParseDir not fully implemented yet")
|
||
return allProviders, nil
|
||
}
|
||
|
||
// shouldProcessFile determines if a file should be processed
|
||
func (p *MainParser) shouldProcessFile(source string) bool {
|
||
// Skip test files
|
||
if strings.HasSuffix(source, "_test.go") {
|
||
return false
|
||
}
|
||
|
||
// Skip generated provider files
|
||
if strings.HasSuffix(source, "provider.gen.go") {
|
||
return false
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
// buildProviderFromDiscovery builds a complete Provider from a discovered provider annotation
|
||
func (p *MainParser) buildProviderFromDiscovery(discoveredProvider Provider, node *ast.File, context *BuilderContext) (Provider, error) {
|
||
// Find the corresponding type specification in the AST
|
||
var typeSpec *ast.TypeSpec
|
||
var genDecl *ast.GenDecl
|
||
|
||
for _, decl := range node.Decls {
|
||
gd, ok := decl.(*ast.GenDecl)
|
||
if !ok {
|
||
continue
|
||
}
|
||
|
||
if len(gd.Specs) == 0 {
|
||
continue
|
||
}
|
||
|
||
ts, ok := gd.Specs[0].(*ast.TypeSpec)
|
||
if !ok {
|
||
continue
|
||
}
|
||
|
||
if ts.Name.Name == discoveredProvider.StructName {
|
||
typeSpec = ts
|
||
genDecl = gd
|
||
break
|
||
}
|
||
}
|
||
|
||
if typeSpec == nil {
|
||
return Provider{}, fmt.Errorf("type specification not found for %s", discoveredProvider.StructName)
|
||
}
|
||
|
||
// Use the builder to construct the complete provider
|
||
provider, err := p.builder.BuildFromTypeSpec(typeSpec, genDecl, context)
|
||
if err != nil {
|
||
return Provider{}, fmt.Errorf("failed to build provider: %w", err)
|
||
}
|
||
|
||
// Apply legacy compatibility transformations
|
||
result, err := p.applyLegacyCompatibility(&provider)
|
||
if err != nil {
|
||
return Provider{}, fmt.Errorf("failed to apply legacy compatibility: %w", err)
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// applyLegacyCompatibility applies transformations to maintain backward compatibility
|
||
func (p *MainParser) applyLegacyCompatibility(provider *Provider) (Provider, error) {
|
||
// Set provider file path
|
||
provider.ProviderFile = filepath.Join(filepath.Dir(provider.ProviderFile), "provider.gen.go")
|
||
|
||
// Apply mode-specific transformations based on the original logic
|
||
switch provider.Mode {
|
||
case ProviderModeGrpc:
|
||
p.applyGrpcCompatibility(provider)
|
||
case ProviderModeEvent:
|
||
p.applyEventCompatibility(provider)
|
||
case ProviderModeJob, ProviderModeCronJob:
|
||
p.applyJobCompatibility(provider)
|
||
case ProviderModeModel:
|
||
p.applyModelCompatibility(provider)
|
||
}
|
||
|
||
return *provider, nil
|
||
}
|
||
|
||
// applyGrpcCompatibility applies gRPC-specific compatibility transformations
|
||
func (p *MainParser) applyGrpcCompatibility(provider *Provider) {
|
||
modePkg := gomod.GetModuleName() + "/providers/grpc"
|
||
|
||
// Add required imports
|
||
provider.Imports[createAtomPackage("")] = ""
|
||
provider.Imports[createAtomPackage("contracts")] = ""
|
||
provider.Imports[modePkg] = ""
|
||
|
||
// Set provider group
|
||
if provider.ProviderGroup == "" {
|
||
provider.ProviderGroup = "atom.GroupInitial"
|
||
}
|
||
|
||
// Set return type and register function
|
||
// Important: Save the original return type before setting it to contracts.Initial
|
||
originalReturnType := provider.ReturnType
|
||
provider.ReturnType = "contracts.Initial"
|
||
|
||
// Set gRPC register function name if not already set
|
||
if provider.GrpcRegisterFunc == "" {
|
||
if originalReturnType != "" && strings.Contains(originalReturnType, ".") {
|
||
// User specified a complete register function name, like userv1.RegisterUserServiceServer
|
||
provider.GrpcRegisterFunc = originalReturnType
|
||
} else {
|
||
// Generate default gRPC register function name
|
||
// Example: UserService -> RegisterUserServiceServer
|
||
provider.GrpcRegisterFunc = "Register" + strings.TrimPrefix(originalReturnType, "*") + "Server"
|
||
}
|
||
}
|
||
|
||
// Note: Package import handling for gRPC register functions is now done
|
||
// in resolveImportDependencies to ensure access to original file imports
|
||
|
||
// Add gRPC injection parameter
|
||
provider.InjectParams["__grpc"] = InjectParam{
|
||
Star: "*",
|
||
Type: "Grpc",
|
||
Package: modePkg,
|
||
PackageAlias: "grpc",
|
||
}
|
||
}
|
||
|
||
// applyEventCompatibility applies event-specific compatibility transformations
|
||
func (p *MainParser) applyEventCompatibility(provider *Provider) {
|
||
modePkg := gomod.GetModuleName() + "/providers/event"
|
||
|
||
// Add required imports
|
||
provider.Imports[createAtomPackage("")] = ""
|
||
provider.Imports[createAtomPackage("contracts")] = ""
|
||
provider.Imports[modePkg] = ""
|
||
|
||
// Set provider group
|
||
if provider.ProviderGroup == "" {
|
||
provider.ProviderGroup = "atom.GroupInitial"
|
||
}
|
||
|
||
// Set return type
|
||
provider.ReturnType = "contracts.Initial"
|
||
|
||
// Add event injection parameter
|
||
provider.InjectParams["__event"] = InjectParam{
|
||
Star: "*",
|
||
Type: "PubSub",
|
||
Package: modePkg,
|
||
PackageAlias: "event",
|
||
}
|
||
}
|
||
|
||
// applyJobCompatibility applies job-specific compatibility transformations
|
||
func (p *MainParser) applyJobCompatibility(provider *Provider) {
|
||
modePkg := gomod.GetModuleName() + "/providers/job"
|
||
|
||
// Add required imports
|
||
provider.Imports[createAtomPackage("")] = ""
|
||
provider.Imports[createAtomPackage("contracts")] = ""
|
||
provider.Imports["github.com/riverqueue/river"] = ""
|
||
provider.Imports[modePkg] = ""
|
||
|
||
// Set provider group
|
||
if provider.ProviderGroup == "" {
|
||
provider.ProviderGroup = "atom.GroupInitial"
|
||
}
|
||
|
||
// Set return type
|
||
provider.ReturnType = "contracts.Initial"
|
||
|
||
// Add job injection parameter
|
||
provider.InjectParams["__job"] = InjectParam{
|
||
Star: "*",
|
||
Type: "Job",
|
||
Package: modePkg,
|
||
PackageAlias: "job",
|
||
}
|
||
}
|
||
|
||
// applyModelCompatibility applies model-specific compatibility transformations
|
||
func (p *MainParser) applyModelCompatibility(provider *Provider) {
|
||
// Set provider group
|
||
if provider.ProviderGroup == "" {
|
||
provider.ProviderGroup = "atom.GroupInitial"
|
||
}
|
||
|
||
// Set return type
|
||
provider.ReturnType = "contracts.Initial"
|
||
|
||
// Ensure prepare function is needed
|
||
provider.NeedPrepareFunc = true
|
||
}
|
||
|
||
// GetCommentParser returns the comment parser used by this parser
|
||
func (p *MainParser) GetCommentParser() *CommentParser {
|
||
return p.commentParser
|
||
}
|
||
|
||
// GetImportResolver returns the import resolver used by this parser
|
||
func (p *MainParser) GetImportResolver() *ImportResolver {
|
||
return p.importResolver
|
||
}
|
||
|
||
// GetASTWalker returns the AST walker used by this parser
|
||
func (p *MainParser) GetASTWalker() *ASTWalker {
|
||
return p.astWalker
|
||
}
|
||
|
||
// GetBuilder returns the provider builder used by this parser
|
||
func (p *MainParser) GetBuilder() *ProviderBuilder {
|
||
return p.builder
|
||
}
|
||
|
||
// GetValidator returns the validator used by this parser
|
||
func (p *MainParser) GetValidator() *GoValidator {
|
||
return p.validator
|
||
}
|
||
|
||
// GetConfig returns the parser configuration
|
||
func (p *MainParser) GetConfig() *ParserConfig {
|
||
return p.config
|
||
}
|
||
|
||
// SetConfig updates the parser configuration
|
||
func (p *MainParser) SetConfig(config *ParserConfig) {
|
||
p.config = config
|
||
}
|
||
|
||
// Helper function to create atom package paths
|
||
func createAtomPackage(suffix string) string {
|
||
root := "go.ipao.vip/atom"
|
||
if suffix != "" {
|
||
return fmt.Sprintf("%s/%s", root, suffix)
|
||
}
|
||
return root
|
||
}
|