103 lines
2.7 KiB
Go
103 lines
2.7 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
)
|
|
|
|
type NormalizerConstructor func() (contracts.Normalizer, error)
|
|
|
|
type NormalizerRegistry struct {
|
|
constructors map[string]NormalizerConstructor
|
|
specs map[string]ModuleSpec
|
|
}
|
|
|
|
func NewNormalizerRegistry() *NormalizerRegistry {
|
|
return &NormalizerRegistry{
|
|
constructors: make(map[string]NormalizerConstructor),
|
|
specs: make(map[string]ModuleSpec),
|
|
}
|
|
}
|
|
|
|
func (r *NormalizerRegistry) Register(key string, constructor NormalizerConstructor) error {
|
|
return r.RegisterWithSpec(defaultModuleSpec(key, StageNormalize), constructor)
|
|
}
|
|
|
|
func (r *NormalizerRegistry) RegisterWithSpec(spec ModuleSpec, constructor NormalizerConstructor) error {
|
|
if r == nil {
|
|
return fmt.Errorf("normalizer registry must not be nil")
|
|
}
|
|
|
|
normalizedSpec := normalizeModuleSpec(spec)
|
|
if err := validateModuleSpec("normalizer", StageNormalize, normalizedSpec); err != nil {
|
|
return err
|
|
}
|
|
if constructor == nil {
|
|
return fmt.Errorf("normalizer constructor for %q must not be nil", normalizedSpec.Key)
|
|
}
|
|
if _, ok := r.constructors[normalizedSpec.Key]; ok {
|
|
return fmt.Errorf("normalizer %q is already registered", normalizedSpec.Key)
|
|
}
|
|
|
|
if r.constructors == nil {
|
|
r.constructors = make(map[string]NormalizerConstructor)
|
|
}
|
|
if r.specs == nil {
|
|
r.specs = make(map[string]ModuleSpec)
|
|
}
|
|
r.constructors[normalizedSpec.Key] = constructor
|
|
r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
|
|
return nil
|
|
}
|
|
|
|
func (r *NormalizerRegistry) Build(key string) (contracts.Normalizer, error) {
|
|
if r == nil {
|
|
return nil, fmt.Errorf("normalizer registry must not be nil")
|
|
}
|
|
|
|
normalizedKey := strings.TrimSpace(key)
|
|
if normalizedKey == "" {
|
|
return nil, fmt.Errorf("normalizer key must not be empty")
|
|
}
|
|
|
|
constructor, ok := r.constructors[normalizedKey]
|
|
if !ok {
|
|
return nil, fmt.Errorf("normalizer %q is not registered", normalizedKey)
|
|
}
|
|
|
|
normalizer, err := constructor()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("build normalizer %q: %w", normalizedKey, err)
|
|
}
|
|
if normalizer == nil {
|
|
return nil, fmt.Errorf("normalizer %q constructor returned nil", normalizedKey)
|
|
}
|
|
if normalizer.Key() != normalizedKey {
|
|
return nil, fmt.Errorf("normalizer %q returned key %q", normalizedKey, normalizer.Key())
|
|
}
|
|
|
|
return normalizer, nil
|
|
}
|
|
|
|
func (r *NormalizerRegistry) Spec(key string) (ModuleSpec, bool) {
|
|
if r == nil {
|
|
return ModuleSpec{}, false
|
|
}
|
|
|
|
spec, ok := r.specs[strings.TrimSpace(key)]
|
|
if !ok {
|
|
return ModuleSpec{}, false
|
|
}
|
|
return cloneModuleSpec(spec), true
|
|
}
|
|
|
|
func (r *NormalizerRegistry) RegisteredKeys() []string {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
return sortedRegistryKeys(r.constructors)
|
|
}
|