137 lines
2.8 KiB
Go
137 lines
2.8 KiB
Go
package cnf
|
|
|
|
import (
|
|
lib "github.com/lytics/confl"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
type confl struct {
|
|
data interface{}
|
|
parsed bool
|
|
}
|
|
|
|
// ReadFrom implements io.ReaderFrom
|
|
func (d *confl) ReadFrom(_reader io.Reader) (int64, error) {
|
|
|
|
// 1. get confl decoder
|
|
decoder := lib.NewDecoder(_reader)
|
|
err := decoder.Decode(&d.data)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
d.parsed = true
|
|
return 0, nil
|
|
|
|
}
|
|
|
|
// WriteTo implements io.WriterTo
|
|
func (d *confl) WriteTo(_writer io.Writer) (int64, error) {
|
|
encoder := lib.NewEncoder(_writer)
|
|
return 0, encoder.Encode(&d.data)
|
|
}
|
|
|
|
// browse returns the target of a dot-separated path (as an interface{} chain where the last is the target if found)
|
|
func (d *confl) browse(_path string) ([]interface{}, bool) {
|
|
|
|
// 1. extract path
|
|
path := strings.Split(_path, ".")
|
|
|
|
// 2. init output chain
|
|
current := d.data
|
|
chain := make([]interface{}, 0, len(path)+1)
|
|
chain = append(chain, current)
|
|
|
|
// 3. iterate over path / nested fields
|
|
for _, field := range path {
|
|
fmap, ok := current.(map[string]interface{})
|
|
if !ok { // incomplete path
|
|
return chain, false
|
|
}
|
|
|
|
child, ok := fmap[field]
|
|
if !ok { // incomplete path
|
|
return chain, false
|
|
}
|
|
|
|
current = child
|
|
chain = append(chain, current)
|
|
}
|
|
|
|
return chain, true
|
|
}
|
|
|
|
// Get returns the value of a dot-separated path, and if it exists
|
|
func (d *confl) Get(_path string) (string, bool) {
|
|
|
|
// 1. browse path
|
|
chain, found := d.browse(_path)
|
|
if !found {
|
|
return "", false
|
|
}
|
|
|
|
// 2. return if string value
|
|
value, ok := chain[len(chain)-1].(string)
|
|
return value, ok
|
|
|
|
}
|
|
|
|
// Set the value of a dot-separated path, and creates it if not found
|
|
func (d *confl) Set(_path, _value string) bool {
|
|
|
|
// 1. browse path + create it if does not exist
|
|
path := strings.Split(_path, ".")
|
|
lp := len(path)
|
|
chain, found := d.browse(_path)
|
|
|
|
// 2. if found -> set value
|
|
if found {
|
|
mapWrapper, ok := chain[len(chain)-2].(map[string]interface{})
|
|
if !ok { // impossible
|
|
return false
|
|
}
|
|
key := path[lp-1]
|
|
mapWrapper[key] = _value
|
|
return true
|
|
}
|
|
|
|
// 3. create path until the end to set value
|
|
root := make(map[string]interface{})
|
|
current := root
|
|
|
|
// create children until second to last
|
|
for i, l := len(chain)-1, lp-1; i < l; i++ {
|
|
child := make(map[string]interface{})
|
|
current[path[i]] = child
|
|
current = child
|
|
}
|
|
|
|
// set value
|
|
current[path[lp-1]] = _value
|
|
|
|
// replace whole object if empty
|
|
if len(chain) < 2 {
|
|
wrapper, ok := d.data.(map[string]interface{})
|
|
if !ok { // impossible
|
|
return false
|
|
}
|
|
key := path[0]
|
|
wrapper[key] = root[key] // store with key ; eitherway it will erase all brother keys
|
|
return true
|
|
}
|
|
|
|
// update last found object to add the value
|
|
wrapper, ok := chain[len(chain)-1].(map[string]interface{})
|
|
if !ok { // impossible
|
|
return false
|
|
}
|
|
|
|
// add each subkey
|
|
for subkey, subvalue := range root {
|
|
wrapper[subkey] = subvalue
|
|
}
|
|
return true
|
|
|
|
}
|