Compile effective flag aliases during installation
This commit is contained in:
263
flag_aliases.go
Normal file
263
flag_aliases.go
Normal file
@@ -0,0 +1,263 @@
|
||||
package commandkit
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"gitea.maximumdirect.net/eric/CommandKit/internal/commandpath"
|
||||
)
|
||||
|
||||
type resolvedFlagAlias struct {
|
||||
source capturedFlagSpelling
|
||||
target capturedFlagSpelling
|
||||
}
|
||||
|
||||
type resolvedFlagAliases struct {
|
||||
bySpelling map[string]resolvedFlagAlias
|
||||
}
|
||||
|
||||
type flagAliasMapping struct {
|
||||
target capturedFlagSpelling
|
||||
scoped bool
|
||||
}
|
||||
|
||||
type flagAliasContext struct {
|
||||
path commandpath.Path
|
||||
canonical map[string]capturedFlagSpelling
|
||||
discovery bool
|
||||
}
|
||||
|
||||
func (spelling capturedFlagSpelling) token() string {
|
||||
if spelling.short {
|
||||
return "-" + spelling.name
|
||||
}
|
||||
return "--" + spelling.name
|
||||
}
|
||||
|
||||
func compileFlagAliases(rules []RoutingRule, roots map[string]*canonicalNode, aliases interface {
|
||||
Resolve(commandpath.Path) commandpath.Path
|
||||
}) (map[string]resolvedFlagAliases, map[string]resolvedFlagAliases, error) {
|
||||
canonicalNodes := indexCanonicalNodes(roots)
|
||||
global := make(map[string]flagAliasMapping)
|
||||
scoped := make(map[string]map[string]flagAliasMapping)
|
||||
for _, rule := range rules {
|
||||
record := rule.record
|
||||
switch record.kind {
|
||||
case globalFlagAliasRule:
|
||||
source := flagSpellingKey(record.sourceFlag)
|
||||
global[source] = flagAliasMapping{target: record.targetFlag}
|
||||
case scopedFlagAliasRule:
|
||||
scope := record.scopePath.Key()
|
||||
if canonicalNodes[scope] == nil {
|
||||
return nil, nil, fmt.Errorf("flag alias scope %q is not a canonical command path", record.scopePath.String())
|
||||
}
|
||||
if scoped[scope] == nil {
|
||||
scoped[scope] = make(map[string]flagAliasMapping)
|
||||
}
|
||||
source := flagSpellingKey(record.sourceFlag)
|
||||
scoped[scope][source] = flagAliasMapping{target: record.targetFlag, scoped: true}
|
||||
}
|
||||
}
|
||||
|
||||
canonicalContexts := make(map[string]flagAliasContext, len(canonicalNodes)+1)
|
||||
rootPath := commandpath.Path(nil)
|
||||
canonicalContexts[rootPath.Key()] = flagAliasContext{path: rootPath, canonical: helpFlagSpellings()}
|
||||
for key, node := range canonicalNodes {
|
||||
canonicalContexts[key] = flagAliasContext{path: node.path.Clone(), canonical: canonicalFlagSpellings(node.command)}
|
||||
}
|
||||
discoveryContexts := discoverFlagContexts(rules, roots, aliases, canonicalNodes)
|
||||
|
||||
canonicalKeys := sortedContextKeys(canonicalContexts)
|
||||
resolvedCanonical := make(map[string]resolvedFlagAliases, len(canonicalContexts))
|
||||
for _, key := range canonicalKeys {
|
||||
context := canonicalContexts[key]
|
||||
mappings := cloneFlagMappings(global)
|
||||
for source, mapping := range scoped[key] {
|
||||
mappings[source] = mapping
|
||||
}
|
||||
resolved, err := resolveFlagAliases(context, mappings)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
resolvedCanonical[key] = resolved
|
||||
}
|
||||
|
||||
discoveryKeys := sortedContextKeys(discoveryContexts)
|
||||
resolvedDiscovery := make(map[string]resolvedFlagAliases, len(discoveryContexts))
|
||||
for _, key := range discoveryKeys {
|
||||
context := discoveryContexts[key]
|
||||
resolved, err := resolveFlagAliases(context, cloneFlagMappings(global))
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
resolvedDiscovery[key] = resolved
|
||||
}
|
||||
return resolvedCanonical, resolvedDiscovery, nil
|
||||
}
|
||||
|
||||
func indexCanonicalNodes(roots map[string]*canonicalNode) map[string]*canonicalNode {
|
||||
indexed := make(map[string]*canonicalNode)
|
||||
var add func(*canonicalNode)
|
||||
add = func(node *canonicalNode) {
|
||||
indexed[node.path.Key()] = node
|
||||
for _, child := range node.children {
|
||||
add(child)
|
||||
}
|
||||
}
|
||||
for _, root := range roots {
|
||||
add(root)
|
||||
}
|
||||
return indexed
|
||||
}
|
||||
|
||||
func helpFlagSpellings() map[string]capturedFlagSpelling {
|
||||
flags := make(map[string]capturedFlagSpelling, 2)
|
||||
for _, spelling := range []capturedFlagSpelling{{name: "help"}, {name: "h", short: true}} {
|
||||
flags[flagSpellingKey(spelling)] = spelling
|
||||
}
|
||||
return flags
|
||||
}
|
||||
|
||||
func canonicalFlagSpellings(command Command) map[string]capturedFlagSpelling {
|
||||
flags := helpFlagSpellings()
|
||||
if command.record.payload == nil {
|
||||
return flags
|
||||
}
|
||||
for _, metadata := range command.record.payload.bridgeFlags() {
|
||||
long := capturedFlagSpelling{name: metadata.Name}
|
||||
flags[flagSpellingKey(long)] = long
|
||||
if metadata.Short != "" {
|
||||
short := capturedFlagSpelling{name: metadata.Short, short: true}
|
||||
flags[flagSpellingKey(short)] = short
|
||||
}
|
||||
}
|
||||
return flags
|
||||
}
|
||||
|
||||
func discoverFlagContexts(rules []RoutingRule, roots map[string]*canonicalNode, aliases interface {
|
||||
Resolve(commandpath.Path) commandpath.Path
|
||||
}, canonicalNodes map[string]*canonicalNode) map[string]flagAliasContext {
|
||||
commandSources := make(map[string]struct{})
|
||||
prefixes := make(map[string]commandpath.Path)
|
||||
for _, rule := range rules {
|
||||
if rule.record.kind == commandAliasRule {
|
||||
commandSources[rule.record.sourcePath.Key()] = struct{}{}
|
||||
}
|
||||
}
|
||||
for _, rule := range rules {
|
||||
if rule.record.kind != commandAliasRule {
|
||||
continue
|
||||
}
|
||||
for length := 1; length < len(rule.record.sourcePath); length++ {
|
||||
prefix := rule.record.sourcePath[:length].Clone()
|
||||
key := prefix.Key()
|
||||
if canonicalNodes[key] != nil {
|
||||
continue
|
||||
}
|
||||
if _, exactAlias := commandSources[key]; exactAlias {
|
||||
continue
|
||||
}
|
||||
resolved := aliases.Resolve(prefix)
|
||||
trace := traceCanonicalPath(roots, resolved)
|
||||
if trace.exact != nil || trace.operandOwner != nil {
|
||||
continue
|
||||
}
|
||||
prefixes[key] = prefix
|
||||
}
|
||||
}
|
||||
contexts := make(map[string]flagAliasContext, len(prefixes))
|
||||
for key, path := range prefixes {
|
||||
contexts[key] = flagAliasContext{path: path, canonical: helpFlagSpellings(), discovery: true}
|
||||
}
|
||||
return contexts
|
||||
}
|
||||
|
||||
func cloneFlagMappings(mappings map[string]flagAliasMapping) map[string]flagAliasMapping {
|
||||
cloned := make(map[string]flagAliasMapping, len(mappings))
|
||||
for source, mapping := range mappings {
|
||||
cloned[source] = mapping
|
||||
}
|
||||
return cloned
|
||||
}
|
||||
|
||||
func sortedContextKeys(contexts map[string]flagAliasContext) []string {
|
||||
keys := make([]string, 0, len(contexts))
|
||||
for key := range contexts {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
return keys
|
||||
}
|
||||
|
||||
func resolveFlagAliases(context flagAliasContext, mappings map[string]flagAliasMapping) (resolvedFlagAliases, error) {
|
||||
result := resolvedFlagAliases{bySpelling: make(map[string]resolvedFlagAlias)}
|
||||
sources := make([]string, 0, len(mappings))
|
||||
for source := range mappings {
|
||||
sources = append(sources, source)
|
||||
}
|
||||
sort.Strings(sources)
|
||||
for _, sourceKey := range sources {
|
||||
mapping := mappings[sourceKey]
|
||||
source := spellingFromKey(sourceKey)
|
||||
target, active, err := resolveFlagTarget(source, mapping.target, mappings, context.canonical)
|
||||
if err != nil {
|
||||
return resolvedFlagAliases{}, fmt.Errorf("%s: %w", flagContextDescription(context), err)
|
||||
}
|
||||
if !active {
|
||||
if mapping.scoped {
|
||||
return resolvedFlagAliases{}, fmt.Errorf("scoped flag alias %s has no canonical destination in %s", source.token(), flagContextDescription(context))
|
||||
}
|
||||
continue
|
||||
}
|
||||
if _, collision := context.canonical[sourceKey]; collision {
|
||||
return resolvedFlagAliases{}, fmt.Errorf("flag alias %s conflicts with a canonical spelling in %s", source.token(), flagContextDescription(context))
|
||||
}
|
||||
result.bySpelling[sourceKey] = resolvedFlagAlias{source: source, target: target}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func resolveFlagTarget(source, target capturedFlagSpelling, mappings map[string]flagAliasMapping, canonical map[string]capturedFlagSpelling) (capturedFlagSpelling, bool, error) {
|
||||
visited := map[string]int{flagSpellingKey(source): 0}
|
||||
chain := []capturedFlagSpelling{source}
|
||||
current := target
|
||||
for {
|
||||
key := flagSpellingKey(current)
|
||||
if endpoint, exists := canonical[key]; exists {
|
||||
return endpoint, true, nil
|
||||
}
|
||||
if start, exists := visited[key]; exists {
|
||||
cycle := append(append([]capturedFlagSpelling(nil), chain[start:]...), current)
|
||||
spellings := make([]string, 0, len(cycle))
|
||||
for _, spelling := range cycle {
|
||||
spellings = append(spellings, spelling.token())
|
||||
}
|
||||
return capturedFlagSpelling{}, false, fmt.Errorf("flag alias cycle: %s", strings.Join(spellings, " → "))
|
||||
}
|
||||
visited[key] = len(chain)
|
||||
chain = append(chain, current)
|
||||
next, exists := mappings[key]
|
||||
if !exists {
|
||||
return capturedFlagSpelling{}, false, nil
|
||||
}
|
||||
current = next.target
|
||||
}
|
||||
}
|
||||
|
||||
func spellingFromKey(key string) capturedFlagSpelling {
|
||||
if strings.HasPrefix(key, "short:") {
|
||||
return capturedFlagSpelling{name: strings.TrimPrefix(key, "short:"), short: true}
|
||||
}
|
||||
return capturedFlagSpelling{name: strings.TrimPrefix(key, "long:")}
|
||||
}
|
||||
|
||||
func flagContextDescription(context flagAliasContext) string {
|
||||
if context.discovery {
|
||||
return fmt.Sprintf("alias prefix %q", context.path.String())
|
||||
}
|
||||
if len(context.path) == 0 {
|
||||
return "application root"
|
||||
}
|
||||
return fmt.Sprintf("command %q", context.path.String())
|
||||
}
|
||||
Reference in New Issue
Block a user