119 lines
2.6 KiB
Go
119 lines
2.6 KiB
Go
package staert
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/BurntSushi/toml"
|
|
"github.com/containous/flaeg"
|
|
)
|
|
|
|
var _ Source = (*TomlSource)(nil)
|
|
|
|
// TomlSource implement staert.Source
|
|
type TomlSource struct {
|
|
filename string
|
|
dirNFullPath []string
|
|
fullPath string
|
|
}
|
|
|
|
// NewTomlSource creates and return a pointer on Source.
|
|
// Parameter filename is the file name (without extension type, ".toml" will be added)
|
|
// dirNFullPath may contain directories or fullPath to the file.
|
|
func NewTomlSource(filename string, dirNFullPath []string) *TomlSource {
|
|
return &TomlSource{filename, dirNFullPath, ""}
|
|
}
|
|
|
|
// ConfigFileUsed return config file used
|
|
func (ts *TomlSource) ConfigFileUsed() string {
|
|
return ts.fullPath
|
|
}
|
|
|
|
// Parse calls toml.DecodeFile() func
|
|
func (ts *TomlSource) Parse(cmd *flaeg.Command) (*flaeg.Command, error) {
|
|
ts.fullPath = findFile(ts.filename, ts.dirNFullPath)
|
|
if len(ts.fullPath) < 2 {
|
|
return cmd, nil
|
|
}
|
|
|
|
metadata, err := toml.DecodeFile(ts.fullPath, cmd.Config)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
boolFlags, err := flaeg.GetBoolFlags(cmd.Config)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
flgArgs, hasUnderField := generateArgs(metadata, boolFlags)
|
|
|
|
err = flaeg.Load(cmd.Config, cmd.DefaultPointersConfig, flgArgs)
|
|
if err != nil && err != flaeg.ErrParserNotFound {
|
|
return nil, err
|
|
}
|
|
|
|
if hasUnderField {
|
|
_, err := toml.DecodeFile(ts.fullPath, cmd.Config)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return cmd, nil
|
|
}
|
|
|
|
func preProcessDir(dirIn string) (string, error) {
|
|
expanded := os.ExpandEnv(dirIn)
|
|
return filepath.Abs(expanded)
|
|
}
|
|
|
|
func findFile(filename string, dirNFile []string) string {
|
|
for _, df := range dirNFile {
|
|
if df != "" {
|
|
fullPath, _ := preProcessDir(df)
|
|
if fileInfo, err := os.Stat(fullPath); err == nil && !fileInfo.IsDir() {
|
|
return fullPath
|
|
}
|
|
|
|
fullPath = filepath.Join(fullPath, filename+".toml")
|
|
if fileInfo, err := os.Stat(fullPath); err == nil && !fileInfo.IsDir() {
|
|
return fullPath
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func generateArgs(metadata toml.MetaData, flags []string) ([]string, bool) {
|
|
var flgArgs []string
|
|
keys := metadata.Keys()
|
|
hasUnderField := false
|
|
|
|
for i, key := range keys {
|
|
if metadata.Type(key.String()) == "Hash" {
|
|
// TOML hashes correspond to Go structs or maps.
|
|
for j := i; j < len(keys); j++ {
|
|
if strings.Contains(keys[j].String(), key.String()+".") {
|
|
hasUnderField = true
|
|
break
|
|
}
|
|
}
|
|
|
|
match := false
|
|
for _, flag := range flags {
|
|
if flag == strings.ToLower(key.String()) {
|
|
match = true
|
|
break
|
|
}
|
|
}
|
|
if match {
|
|
flgArgs = append(flgArgs, "--"+strings.ToLower(key.String()))
|
|
}
|
|
}
|
|
}
|
|
|
|
return flgArgs, hasUnderField
|
|
}
|