Naming things is hard.

config/config.go

@@ -16,62 +16,59 @@ import (
 
 var k = koanf.New(".")
 
-func Load(path string) (all All, err error) {
+func Load(filePath string) (r Root, err error) {
 	err = k.Load(structs.Provider(Default, "koanf"), nil)
 	if err != nil {
 		return
 	}
-	if path != "" {
-		err = k.Load(file.Provider(path), yaml.Parser())
+	if filePath != "" {
+		err = k.Load(file.Provider(filePath), yaml.Parser())
 		if err != nil {
 			return
 		}
 	}
-	err = k.Unmarshal("", &all)
-	if err != nil {
-		return
-	}
+	err = k.Unmarshal("", &r)
 
 	return
 }
 
-var Default All
+var Default Root
 
-type All struct {
-	Defaults Data                    `koanf:"defaults"`
-	Assets   map[coindesk.Asset]Data `koanf:"assets"`
+type Root struct {
+	Defaults Asset                    `koanf:"defaults"`
+	Assets   map[coindesk.Asset]Asset `koanf:"assets"`
 }
 
-type Data struct {
+type Asset struct {
 	Asset         coindesk.Asset      `koanf:"asset"`
 	Goals         []moon.Goal         `koanf:"goals"`
 	ConstantBases []moon.ConstantBase `koanf:"constantBases"`
 	RelativeBases []moon.RelativeBase `koanf:"relativeBases"`
 }
 
-func (all All) GetData(asset coindesk.Asset) (data Data) {
-	data, ok := all.Assets[asset]
+func (r Root) ForAsset(asset coindesk.Asset) (data Asset) {
+	data, ok := r.Assets[asset]
 	if !ok {
-		data = all.Defaults
+		data = r.Defaults
 	}
 	if data.Asset == "" {
 		data.Asset = asset
 	}
 	if data.Goals == nil || len(data.Goals) == 0 {
-		data.Goals = all.Defaults.Goals
+		data.Goals = r.Defaults.Goals
 	}
 	if data.ConstantBases == nil || len(data.ConstantBases) == 0 {
-		data.ConstantBases = all.Defaults.ConstantBases
+		data.ConstantBases = r.Defaults.ConstantBases
 	}
 	if data.RelativeBases == nil || len(data.RelativeBases) == 0 {
-		data.RelativeBases = all.Defaults.RelativeBases
+		data.RelativeBases = r.Defaults.RelativeBases
 	}
 	return
 }
 
 // GetBases returns the concatenation of the constant and relative bases, sorted
 // from most recent to least recent in time.
-func GetBases(d *Data) (bases []moon.Base) {
+func GetBases(d *Asset) (bases []moon.Base) {
 	for _, b := range d.ConstantBases {
 		bases = append(bases, b)
 	}