fillin.go

package main

import (
	"regexp"
	"strings"
)

var fillinPattern = regexp.MustCompile(
	`{{[A-Za-z][-0-9A-Za-z_]*(:[A-Za-z][-0-9A-Za-z_]*)?}}|\[\[[A-Za-z][-0-9A-Za-z_]*(:[A-Za-z][-0-9A-Za-z_]*)?\]\]`,
)

func collectIdentifiers(args []string) []*Identifier {
	var identifiers []*Identifier
	for _, arg := range args {
		matches := fillinPattern.FindAllString(arg, -1)
		for _, match := range matches {
			identifiers = append(identifiers, identifierFromMatch(match))
		}
	}
	return identifiers
}

// Fillin fills in the command arguments
func Fillin(args []string, config *Config, p prompt) ([]string, error) {
	ret := make([]string, len(args))
	if config.Scopes == nil {
		config.Scopes = make(map[string]*Scope)
	}
	values, err := Resolve(collectIdentifiers(args), config, p)
	if err != nil {
		return nil, err
	}
	if !empty(values) {
		insertValues(config.Scopes, values)
	}
	for i, arg := range args {
		ret[i] = fillinPattern.ReplaceAllStringFunc(arg, func(match string) string {
			return lookup(values, identifierFromMatch(match))
		})
	}
	return ret, nil
}

func identifierFromMatch(match string) *Identifier {
	match = match[2 : len(match)-2]
	var scope, key string
	if strings.ContainsRune(match, ':') {
		xs := strings.Split(match, ":")
		scope = strings.TrimSpace(xs[0])
		key = strings.TrimSpace(xs[1])
	} else {
		key = strings.TrimSpace(match)
	}
	return &Identifier{scope, key}
}

func insertValues(scopes map[string]*Scope, values map[string]map[string]string) {
	for scope := range values {
		if _, ok := scopes[scope]; !ok {
			scopes[scope] = &Scope{}
		}
		newValues := make([]map[string]string, 1, len(scopes[scope].Values)+1)
		newValues[0] = values[scope]
		for _, v := range scopes[scope].Values {
			var skip bool
		L:
			for i, w := range newValues {
				switch mapCompare(w, v) {
				case mapCompareSubset:
					newValues[i] = v
					fallthrough
				case mapCompareEqual, mapCompareSuperset:
					skip = true
					break L
				}
			}
			if !skip {
				newValues = append(newValues, v)
			}
		}
		scopes[scope].Values = newValues
	}
}

const (
	mapCompareEqual = iota
	mapCompareSuperset
	mapCompareSubset
	mapCompareDiff
)

func mapCompare(m1, m2 map[string]string) int {
	ret := mapCompareEqual
	for v, k := range m1 {
		if l, ok := m2[v]; ok {
			if k != l {
				return mapCompareDiff
			}
		} else {
			ret = mapCompareSuperset
		}
	}
	for v, k := range m2 {
		if l, ok := m1[v]; ok {
			if k != l {
				return mapCompareDiff
			}
		} else {
			if ret == mapCompareSuperset {
				return mapCompareDiff
			}
			ret = mapCompareSubset
		}
	}
	return ret
}