refactor: make variable resolver easier to reuse

Author: FabianKramm

pkg/devspace/config/loader/expression/expression.go

@@ -20,15 +20,22 @@ func expressionMatchFn(key, value string) bool {
 	return ExpressionMatchRegex.MatchString(value)
 }
 
-func ResolveAllExpressions(preparedConfig map[interface{}]interface{}, dir string) error {
-	err := walk.Walk(preparedConfig, expressionMatchFn, func(value string) (interface{}, error) {
-		return ResolveExpressions(value, dir)
-	})
-	if err != nil {
-		return err
+func ResolveAllExpressions(preparedConfig interface{}, dir string) (interface{}, error) {
+	switch t := preparedConfig.(type) {
+	case string:
+		return ResolveExpressions(t, dir)
+	case map[interface{}]interface{}:
+		err := walk.Walk(t, expressionMatchFn, func(value string) (interface{}, error) {
+			return ResolveExpressions(value, dir)
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		return t, nil
 	}
 
-	return nil
+	return nil, fmt.Errorf("unrecognized haystack type: %#v", preparedConfig)
 }
 
 func ResolveExpressions(value, dir string) (interface{}, error) {

pkg/devspace/config/loader/loader.go

@@ -280,6 +280,12 @@ func (l *configLoader) parseConfig(absPath string, rawConfig map[interface{}]int
 		return nil, nil, nil, err
 	}
 
+	// parse cli --var's, the resolver will cache them for us
+	_, err = resolver.ConvertFlags(options.Vars)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
 	// apply the profiles
 	copiedRawConfig, err = l.applyProfiles(copiedRawConfig, options, log)
 	if err != nil {

pkg/devspace/config/loader/parser.go

@@ -1,16 +1,14 @@
 package loader
 
 import (
-	"path/filepath"
-	"strings"
-
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader/expression"
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader/variable"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
+	"path/filepath"
 )
 
 type Parser interface {
@@ -100,82 +98,28 @@ func (p *profilesParser) Parse(configPath string, originalRawConfig map[interfac
 
 func fillVariablesAndParse(configPath string, preparedConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, options *ConfigOptions, log log.Logger) (*latest.Config, error) {
 	// fill in variables
-	err := fillVariables(resolver, preparedConfig, vars, options)
+	preparedConfigInterface, err := resolver.FindAndFillVariables(preparedConfig, vars)
 	if err != nil {
 		return nil, err
 	}
 
 	// execute expressions
-	err = expression.ResolveAllExpressions(preparedConfig, filepath.Dir(configPath))
+	preparedConfigInterface, err = expression.ResolveAllExpressions(preparedConfigInterface, filepath.Dir(configPath))
 	if err != nil {
 		return nil, err
 	}
 
 	// fill in variables again
-	err = fillVariables(resolver, preparedConfig, vars, options)
+	preparedConfigInterface, err = resolver.FindAndFillVariables(preparedConfigInterface, vars)
 	if err != nil {
 		return nil, err
 	}
 
 	// Now convert the whole config to latest
-	latestConfig, err := versions.Parse(preparedConfig, log)
+	latestConfig, err := versions.Parse(preparedConfigInterface.(map[interface{}]interface{}), log)
 	if err != nil {
 		return nil, errors.Wrap(err, "convert config")
 	}
 
 	return latestConfig, nil
 }
-
-// fillVariables fills in the given vars into the prepared config
-func fillVariables(resolver variable.Resolver, preparedConfig map[interface{}]interface{}, vars []*latest.Variable, options *ConfigOptions) error {
-	// Find out what vars are really used
-	varsUsed, err := resolver.FindVariables(preparedConfig, vars)
-	if err != nil {
-		return err
-	}
-
-	// parse cli --var's, the resolver will cache them for us
-	_, err = resolver.ConvertFlags(options.Vars)
-	if err != nil {
-		return err
-	}
-
-	// Fill used defined variables
-	if len(vars) > 0 {
-		newVars := []*latest.Variable{}
-		for _, v := range vars {
-			if varsUsed[strings.TrimSpace(v.Name)] {
-				newVars = append(newVars, v)
-			}
-		}
-
-		if len(newVars) > 0 {
-			err = askQuestions(resolver, newVars)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	// Walk over data and fill in variables
-	err = resolver.FillVariables(preparedConfig)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func askQuestions(resolver variable.Resolver, vars []*latest.Variable) error {
-	for _, definition := range vars {
-		name := strings.TrimSpace(definition.Name)
-
-		// fill the variable with definition
-		_, err := resolver.Resolve(name, definition)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

pkg/devspace/config/loader/variable/resolver.go

@@ -32,15 +32,18 @@ func varMatchFn(key, value string) bool {
 	return varspkg.VarMatchRegex.MatchString(value)
 }
 
-func (r *resolver) FillVariables(haystack map[interface{}]interface{}) error {
-	err := walk.Walk(haystack, varMatchFn, func(value string) (interface{}, error) {
-		return r.ReplaceString(value)
-	})
-	if err != nil {
-		return err
+func (r *resolver) FillVariables(haystack interface{}) (interface{}, error) {
+	switch t := haystack.(type) {
+	case string:
+		return r.ReplaceString(t)
+	case map[interface{}]interface{}:
+		err := walk.Walk(t, varMatchFn, func(value string) (interface{}, error) {
+			return r.ReplaceString(value)
+		})
+		return t, err
 	}
 
-	return nil
+	return nil, fmt.Errorf("unrecognized haystack type: %#v", haystack)
 }
 
 func (r *resolver) ResolvedVariables() map[string]interface{} {
@@ -58,19 +61,28 @@ func (r *resolver) ReplaceString(str string) (interface{}, error) {
 	})
 }
 
-func (r *resolver) FindVariables(haystack map[interface{}]interface{}, vars []*latest.Variable) (map[string]bool, error) {
+func (r *resolver) FindVariables(haystack interface{}, vars []*latest.Variable) (map[string]bool, error) {
 	// find out what vars are really used
 	varsUsed := map[string]bool{}
-	err := walk.Walk(haystack, varMatchFn, func(value string) (interface{}, error) {
-		_, _ = varspkg.ParseString(value, func(v string) (interface{}, error) {
+
+	switch t := haystack.(type) {
+	case string:
+		_, _ = varspkg.ParseString(t, func(v string) (interface{}, error) {
 			varsUsed[v] = true
 			return "", nil
 		})
+	case map[interface{}]interface{}:
+		err := walk.Walk(t, varMatchFn, func(value string) (interface{}, error) {
+			_, _ = varspkg.ParseString(value, func(v string) (interface{}, error) {
+				varsUsed[v] = true
+				return "", nil
+			})
 
-		return value, nil
-	})
-	if err != nil {
-		return nil, err
+			return value, nil
+		})
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// find out what vars are used within other vars definition
@@ -84,6 +96,37 @@ func (r *resolver) FindVariables(haystack map[interface{}]interface{}, vars []*l
 	return varsUsed, nil
 }
 
+func (r *resolver) FindAndFillVariables(haystack interface{}, vars []*latest.Variable) (interface{}, error) {
+	varsUsed, err := r.FindVariables(haystack, vars)
+	if err != nil {
+		return nil, err
+	}
+
+	// resolve used defined variables
+	if len(vars) > 0 {
+		newVars := []*latest.Variable{}
+		for _, v := range vars {
+			if varsUsed[strings.TrimSpace(v.Name)] {
+				newVars = append(newVars, v)
+			}
+		}
+
+		if len(newVars) > 0 {
+			for _, definition := range newVars {
+				name := strings.TrimSpace(definition.Name)
+
+				// resolve the variable with definition
+				_, err := r.Resolve(name, definition)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	return r.FillVariables(haystack)
+}
+
 func (r *resolver) ConvertFlags(flags []string) (map[string]interface{}, error) {
 	retVariables := map[string]interface{}{}
 	for _, cmdVar := range flags {

pkg/devspace/config/loader/variable/types.go

@@ -16,10 +16,10 @@ type Resolver interface {
 	ConvertFlags(flags []string) (map[string]interface{}, error)
 
 	// FindVariables returns all variable names that were found in the given map
-	FindVariables(haystack map[interface{}]interface{}, vars []*latest.Variable) (map[string]bool, error)
+	FindVariables(haystack interface{}, vars []*latest.Variable) (map[string]bool, error)
 
-	// FillVariables walks over the haystack and replaces all encountered variables
-	FillVariables(haystack map[interface{}]interface{}) error
+	// FindAndFillVariables finds the used variables first and then fills in those in the haystack
+	FindAndFillVariables(haystack interface{}, vars []*latest.Variable) (interface{}, error)
 
 	// Replaces all variables in a string and returns either a string, integer or boolean
 	ReplaceString(str string) (interface{}, error)