Files
narratio/internal/config/artifact_catalog.go

178 lines
5.2 KiB
Go

package config
import (
"fmt"
"sort"
"strings"
"gitea.maximumdirect.net/eric/narratio/internal/artifactpolicy"
configkit "go.maximumdirect.net/configkit"
)
// EffectiveArtifactRecord describes one concrete artifact after configuration
// resolution and family expansion.
type EffectiveArtifactRecord struct {
Key string
SourceID string
DefinitionSources []string
Enabled bool
OutputPath string
Dependencies []string
FamilyKey string
CharacterID string
FamilySources []string
PartySource string
}
// EffectiveArtifactCatalog returns the deterministic concrete artifact catalog
// consumed by runtime planning.
func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]EffectiveArtifactRecord, error) {
if cfg == nil {
return nil, fmt.Errorf("pipeline config is required")
}
if cfg.Scriptorium == nil || len(cfg.Scriptorium.Artifacts) == 0 {
return []EffectiveArtifactRecord{}, nil
}
keys := make([]string, 0, len(cfg.Scriptorium.Artifacts))
for key := range cfg.Scriptorium.Artifacts {
keys = append(keys, key)
}
sort.Strings(keys)
records := make([]EffectiveArtifactRecord, 0, len(keys))
for _, key := range keys {
artifact := cfg.Scriptorium.Artifacts[key]
record := EffectiveArtifactRecord{
Key: key,
SourceID: artifactpolicy.ConfiguredSourceID(key),
Enabled: artifact.Enabled,
OutputPath: artifact.OutputPath,
Dependencies: append([]string(nil), artifact.DependsOn...),
}
if member, ok := cfg.familyCatalog.Members[key]; ok {
record.DefinitionSources = artifactFamilyDefinitionSources(cfg, member.Family)
record.FamilyKey = member.Family
record.CharacterID = member.CharacterID
record.FamilySources = append([]string(nil), cfg.familyCatalog.Families[member.Family].Sources...)
record.PartySource = strings.Join(partyCharacterSources(party, member.CharacterID), ",")
} else {
record.DefinitionSources = artifactDefinitionSources(cfg, key)
}
record.Dependencies = nonEmptySortedStrings(record.Dependencies)
records = append(records, record)
}
return records, nil
}
func partyCharacterSources(party ResolvedParty, id string) []string {
if party.Canonical == nil || party.Canonical.authoring == nil {
return nonEmptySortedStrings([]string{party.Source.Path})
}
result := party.Canonical.authoring
path := configkit.Keys("characters", id)
var ids []string
add := func(origin configkit.Origin) {
for _, location := range origin.Locations {
ids = append(ids, location.SourceID)
}
for _, step := range origin.Inheritance {
for _, location := range step.Locations {
ids = append(ids, location.SourceID)
}
}
}
if info, ok := result.Metadata().Lookup(path); ok {
add(info.Origin)
}
for _, change := range result.Metadata().History(path) {
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
add(change.Origin)
}
}
var sources []string
for _, id := range nonEmptySortedStrings(ids) {
if source, ok := result.Source(id); ok {
name := source.Path
if name == "" {
name = source.Label
}
sources = append(sources, name)
}
}
if len(sources) == 0 {
sources = append(sources, party.Source.Path)
}
return nonEmptySortedStrings(sources)
}
func artifactDefinitionSources(cfg *PipelineConfig, key string) []string {
return declarationDefinitionSources(cfg,
configkit.Keys("scriptorium", "artifacts", key),
)
}
func artifactFamilyDefinitionSources(cfg *PipelineConfig, key string) []string {
return declarationDefinitionSources(cfg,
configkit.Keys("scriptorium", "artifact_families", key),
)
}
func declarationDefinitionSources(cfg *PipelineConfig, declaration configkit.Path) []string {
if cfg == nil || cfg.resolution == nil {
return nil
}
pathsByID := pipelineSourcePaths(cfg)
seen := map[string]struct{}{}
for _, change := range cfg.resolution.configkitMetadata.History(declaration) {
if change.Origin.Layer != configkit.LayerMain && change.Origin.Layer != configkit.LayerOverlay {
continue
}
for _, location := range change.Origin.Locations {
seen[location.SourceID] = struct{}{}
}
for _, inheritance := range change.Origin.Inheritance {
for _, location := range inheritance.Locations {
seen[location.SourceID] = struct{}{}
}
}
}
if len(seen) == 0 {
if info, ok := cfg.resolution.configkitMetadata.Lookup(declaration); ok {
for _, location := range info.Origin.Locations {
seen[location.SourceID] = struct{}{}
}
for _, inheritance := range info.Origin.Inheritance {
for _, location := range inheritance.Locations {
seen[location.SourceID] = struct{}{}
}
}
}
}
result := make([]string, 0, len(seen))
for sourceID := range seen {
source := pathsByID[sourceID]
if source == "" {
source = sourceID
}
result = append(result, source)
}
sort.Strings(result)
return result
}
func nonEmptySortedStrings(values []string) []string {
seen := map[string]struct{}{}
for _, value := range values {
value = strings.TrimSpace(value)
if value != "" {
seen[value] = struct{}{}
}
}
result := make([]string, 0, len(seen))
for value := range seen {
result = append(result, value)
}
sort.Strings(result)
return result
}