105 lines
2.6 KiB
Go
105 lines
2.6 KiB
Go
package mcfg
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
func fuzzyParse(p Param, v string) json.RawMessage {
|
|
if p.IsBool {
|
|
if v == "" || v == "0" || v == "false" {
|
|
return json.RawMessage("false")
|
|
}
|
|
return json.RawMessage("true")
|
|
|
|
} else if p.IsString && (v == "" || v[0] != '"') {
|
|
return json.RawMessage(`"` + v + `"`)
|
|
}
|
|
|
|
return json.RawMessage(v)
|
|
}
|
|
|
|
// TODO moving Path into Param would make a lot more sense
|
|
|
|
// ParamValue describes a value for a parameter which has been parsed by a
|
|
// Source
|
|
type ParamValue struct {
|
|
Param
|
|
Path []string // nil if root
|
|
Value json.RawMessage
|
|
}
|
|
|
|
func (pv ParamValue) displayName() string {
|
|
return strings.Join(append(pv.Path, pv.Param.Name), "-")
|
|
}
|
|
|
|
func (pv ParamValue) hash() string {
|
|
h := md5.New()
|
|
for _, path := range pv.Path {
|
|
fmt.Fprintf(h, "pathEl:%q\n", path)
|
|
}
|
|
fmt.Fprintf(h, "name:%q\n", pv.Param.Name)
|
|
hStr := hex.EncodeToString(h.Sum(nil))
|
|
// we add the displayName to it to make debugging easier
|
|
return pv.displayName() + "/" + hStr
|
|
}
|
|
|
|
func (cfg *Cfg) allParamValues() []ParamValue {
|
|
pvs := make([]ParamValue, 0, len(cfg.Params))
|
|
for _, param := range cfg.Params {
|
|
pvs = append(pvs, ParamValue{
|
|
Param: param,
|
|
Path: cfg.Path,
|
|
})
|
|
}
|
|
|
|
for _, child := range cfg.Children {
|
|
pvs = append(pvs, child.allParamValues()...)
|
|
}
|
|
return pvs
|
|
}
|
|
|
|
// Source parses ParamValues out of a particular configuration source. The
|
|
// returned []ParamValue may contain duplicates of the same Param's value.
|
|
type Source interface {
|
|
Parse(*Cfg) ([]ParamValue, error)
|
|
}
|
|
|
|
// Sources combines together multiple Source instances into one. It will call
|
|
// Parse on each element individually. Later Sources take precedence over
|
|
// previous ones in the slice.
|
|
type Sources []Source
|
|
|
|
// Parse implements the method for the Source interface.
|
|
func (ss Sources) Parse(c *Cfg) ([]ParamValue, error) {
|
|
var pvs []ParamValue
|
|
for _, s := range ss {
|
|
innerPVs, err := s.Parse(c)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pvs = append(pvs, innerPVs...)
|
|
}
|
|
return pvs, nil
|
|
}
|
|
|
|
// SourceMap implements the Source interface by mapping parameter names to
|
|
// values for them. The names are comprised of the path and name of a Param
|
|
// joined by "-" characters, i.e. `strings.Join(append(p.Path, p.Name), "-")`.
|
|
// Values will be parsed in the same way that SourceEnv parses its variables.
|
|
type SourceMap map[string]string
|
|
|
|
func (m SourceMap) Parse(c *Cfg) ([]ParamValue, error) {
|
|
pvs := make([]ParamValue, 0, len(m))
|
|
for _, pv := range c.allParamValues() {
|
|
if v, ok := m[pv.displayName()]; ok {
|
|
pv.Value = fuzzyParse(pv.Param, v)
|
|
pvs = append(pvs, pv)
|
|
}
|
|
}
|
|
return pvs, nil
|
|
}
|