refactor: new exclude variable functionality

Author: FabianKramm

cmd/set/var.go

@@ -124,14 +124,14 @@ type variableParser struct {
 	Used        map[string]bool
 }
 
-func (v *variableParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
+func (v *variableParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
 	// Find out what vars are really used
-	varsUsed, err := resolver.FindVariables(rawConfig, vars)
+	varsUsed, err := resolver.FindVariables(rawConfig)
 	if err != nil {
 		return nil, err
 	}
 
-	v.Definitions = vars
+	v.Definitions = resolver.DefinedVars()
 	v.Used = varsUsed
 	return latest.NewRaw(), nil
 }

pkg/devspace/config/loader/loader.go

@@ -12,8 +12,8 @@ import (
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"
 	"github.com/loft-sh/devspace/pkg/devspace/upgrade"
 
-	"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/loader/variable/expression"
 	"github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
@@ -273,15 +273,6 @@ func (l *configLoader) parseConfig(absPath string, rawConfig map[interface{}]int
 		options.Profiles = []string{generatedConfig.ActiveProfile}
 	}
 
-	// create a new variable resolver
-	resolver := l.newVariableResolver(generatedConfig, absPath, options, log)
-
-	// parse cli --var's, the resolver will cache them for us
-	_, err = resolver.ConvertFlags(options.Vars)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
 	// copy raw config
 	copiedRawConfig, err := copyRaw(rawConfig)
 	if err != nil {
@@ -300,14 +291,23 @@ func (l *configLoader) parseConfig(absPath string, rawConfig map[interface{}]int
 		return nil, nil, nil, err
 	}
 
+	// create a new variable resolver
+	resolver := l.newVariableResolver(generatedConfig, absPath, options, vars, log)
+
+	// parse cli --var's, the resolver will cache them for us
+	_, err = resolver.ConvertFlags(options.Vars)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
 	// prepare profiles
-	copiedRawConfig, err = prepareProfiles(copiedRawConfig, resolver, filepath.Dir(absPath), vars)
+	copiedRawConfig, err = prepareProfiles(copiedRawConfig, resolver)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	// apply the profiles
-	copiedRawConfig, err = l.applyProfiles(copiedRawConfig, options, resolver, vars, log)
+	copiedRawConfig, err = l.applyProfiles(copiedRawConfig, options, resolver, log)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -318,6 +318,9 @@ func (l *configLoader) parseConfig(absPath string, rawConfig map[interface{}]int
 		return nil, nil, nil, err
 	}
 
+	// update the used vars in the resolver
+	resolver.UpdateVars(vars)
+
 	// validate variables
 	err = validateVars(vars)
 	if err != nil {
@@ -328,7 +331,7 @@ func (l *configLoader) parseConfig(absPath string, rawConfig map[interface{}]int
 	delete(copiedRawConfig, "vars")
 
 	// parse the config
-	latestConfig, err := parser.Parse(rawConfig, copiedRawConfig, vars, resolver, log)
+	latestConfig, err := parser.Parse(rawConfig, copiedRawConfig, resolver, log)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -440,13 +443,13 @@ func validateProfile(profile interface{}) error {
 	return nil
 }
 
-func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resolver, dir string, vars []*latest.Variable) (map[interface{}]interface{}, error) {
+func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resolver) (map[interface{}]interface{}, error) {
 	rawProfiles := config["profiles"]
 	if rawProfiles == nil {
 		return config, nil
 	}
 
-	resolved, err := resolve(rawProfiles, resolver, vars)
+	resolved, err := resolve(rawProfiles, resolver)
 	if err != nil {
 		return nil, err
 	}
@@ -457,7 +460,7 @@ func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resol
 	}
 
 	for idx, profile := range profiles {
-		resolvedProfile, err := resolve(profile, resolver, vars)
+		resolvedProfile, err := resolve(profile, resolver)
 		if err != nil {
 			return nil, err
 		}
@@ -469,7 +472,7 @@ func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resol
 
 		// Resolve merge field
 		if profileMap["merge"] != nil {
-			merge, err := resolve(profileMap["merge"], resolver, vars)
+			merge, err := resolve(profileMap["merge"], resolver)
 			if err != nil {
 				return nil, err
 			}
@@ -478,7 +481,7 @@ func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resol
 
 		// Resolve patches field
 		if profileMap["patches"] != nil {
-			patches, err := resolve(profileMap["patches"], resolver, vars)
+			patches, err := resolve(profileMap["patches"], resolver)
 			if err != nil {
 				return nil, err
 			}
@@ -487,7 +490,7 @@ func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resol
 
 		// Resolve replace field
 		if profileMap["replace"] != nil {
-			replace, err := resolve(profileMap["replace"], resolver, vars)
+			replace, err := resolve(profileMap["replace"], resolver)
 			if err != nil {
 				return nil, err
 			}
@@ -496,7 +499,7 @@ func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resol
 
 		// Resolve strategicMerge field
 		if profileMap["strategicMerge"] != nil {
-			strategicMerge, err := resolve(profileMap["strategicMerge"], resolver, vars)
+			strategicMerge, err := resolve(profileMap["strategicMerge"], resolver)
 			if err != nil {
 				return nil, err
 			}
@@ -517,19 +520,19 @@ func prepareProfiles(config map[interface{}]interface{}, resolver variable.Resol
 	return config, nil
 }
 
-func resolve(data interface{}, resolver variable.Resolver, vars []*latest.Variable) (interface{}, error) {
+func resolve(data interface{}, resolver variable.Resolver) (interface{}, error) {
 	_, ok := data.(string)
 	if !ok {
 		return data, nil
 	}
 
 	// find and fill variables
-	return resolver.FillVariables(data, vars)
+	return resolver.FillVariables(data)
 }
 
-func (l *configLoader) applyProfiles(data map[interface{}]interface{}, options *ConfigOptions, resolver variable.Resolver, vars []*latest.Variable, log log.Logger) (map[interface{}]interface{}, error) {
+func (l *configLoader) applyProfiles(data map[interface{}]interface{}, options *ConfigOptions, resolver variable.Resolver, log log.Logger) (map[interface{}]interface{}, error) {
 	// Get profile
-	profiles, err := versions.ParseProfile(filepath.Dir(l.configPath), data, options.Profiles, options.ProfileRefresh, options.DisableProfileActivation, resolver, vars, log)
+	profiles, err := versions.ParseProfile(filepath.Dir(l.configPath), data, options.Profiles, options.ProfileRefresh, options.DisableProfileActivation, resolver, log)
 	if err != nil {
 		return nil, err
 	}
@@ -567,15 +570,15 @@ func (l *configLoader) applyProfiles(data map[interface{}]interface{}, options *
 	return data, nil
 }
 
-func (l *configLoader) newVariableResolver(generatedConfig *generated.Config, absPath string, options *ConfigOptions, log log.Logger) variable.Resolver {
+func (l *configLoader) newVariableResolver(generatedConfig *generated.Config, absPath string, options *ConfigOptions, vars []*latest.Variable, log log.Logger) variable.Resolver {
 	return variable.NewResolver(generatedConfig.Vars, &variable.PredefinedVariableOptions{
 		BasePath:         options.BasePath,
 		ConfigPath:       absPath,
 		KubeContextFlag:  options.KubeContext,
 		NamespaceFlag:    options.Namespace,
 		KubeConfigLoader: l.kubeConfigLoader,
 		Profile:          GetLastProfile(options.Profiles),
-	}, log)
+	}, vars, log)
 }
 
 func GetLastProfile(profiles []string) string {

pkg/devspace/config/loader/parser.go

@@ -10,7 +10,7 @@ import (
 )
 
 type Parser interface {
-	Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, log log.Logger) (*latest.Config, error)
+	Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error)
 }
 
 func NewDefaultParser() Parser {
@@ -19,11 +19,11 @@ func NewDefaultParser() Parser {
 
 type defaultParser struct{}
 
-func (d *defaultParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
+func (d *defaultParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
 	// delete the commands, since we don't need it in a normal scenario
 	delete(rawConfig, "commands")
 
-	return fillVariablesAndParse(resolver, rawConfig, vars, log)
+	return fillVariablesAndParse(resolver, rawConfig, log)
 }
 
 func NewWithCommandsParser() Parser {
@@ -32,8 +32,8 @@ func NewWithCommandsParser() Parser {
 
 type withCommandsParser struct{}
 
-func (d *withCommandsParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
-	return fillVariablesAndParse(resolver, rawConfig, vars, log)
+func (d *withCommandsParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
+	return fillVariablesAndParse(resolver, rawConfig, log)
 }
 
 func NewCommandsParser() Parser {
@@ -42,14 +42,14 @@ func NewCommandsParser() Parser {
 
 type commandsParser struct{}
 
-func (c *commandsParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
+func (c *commandsParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
 	// modify the config
 	preparedConfig, err := versions.ParseCommands(rawConfig)
 	if err != nil {
 		return nil, err
 	}
 
-	return fillVariablesAndParse(resolver, preparedConfig, vars, log)
+	return fillVariablesAndParse(resolver, preparedConfig, log)
 }
 
 func NewProfilesParser() Parser {
@@ -58,7 +58,7 @@ func NewProfilesParser() Parser {
 
 type profilesParser struct{}
 
-func (p *profilesParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, vars []*latest.Variable, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
+func (p *profilesParser) Parse(originalRawConfig map[interface{}]interface{}, rawConfig map[interface{}]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
 	rawMap, err := copyRaw(originalRawConfig)
 	if err != nil {
 		return nil, err
@@ -94,9 +94,11 @@ func (p *profilesParser) Parse(originalRawConfig map[interface{}]interface{}, ra
 	return retConfig, nil
 }
 
-func fillVariablesAndParse(resolver variable.Resolver, preparedConfig map[interface{}]interface{}, vars []*latest.Variable, log log.Logger) (*latest.Config, error) {
-	// fill in variables again
-	preparedConfigInterface, err := resolver.FillVariables(preparedConfig, vars)
+func fillVariablesAndParse(resolver variable.Resolver, preparedConfig map[interface{}]interface{}, log log.Logger) (*latest.Config, error) {
+	// fill in variables and expressions (leave out
+	preparedConfigInterface, err := resolver.FillVariablesExclude(preparedConfig, []string{
+		//"/deployments/*/helm/values",
+	})
 	if err != nil {
 		return nil, err
 	}

…e/config/loader/expression/expression.go …loader/variable/expression/expression.gopkg/devspace/config/loader/expression/expression.go renamed to pkg/devspace/config/loader/variable/expression/expression.go pkg/devspace/config/loader/expression/expression.go renamed to pkg/devspace/config/loader/variable/expression/expression.go

@@ -20,12 +20,26 @@ func expressionMatchFn(key, value string) bool {
 	return ExpressionMatchRegex.MatchString(value)
 }
 
-func ResolveAllExpressions(preparedConfig interface{}, dir string) (interface{}, error) {
+func ExcludedPath(path string, excluded []*regexp.Regexp) bool {
+	for _, expr := range excluded {
+		if expr.MatchString(path) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func ResolveAllExpressions(preparedConfig interface{}, dir string, exclude []*regexp.Regexp) (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) {
+		err := walk.Walk(t, expressionMatchFn, func(path, value string) (interface{}, error) {
+			if ExcludedPath(path, exclude) {
+				return value, nil
+			}
+
 			return ResolveExpressions(value, dir)
 		})
 		if err != nil {