chore(config): Deprecate --value flag in favor of --var

docs/yampl.md

@@ -26,7 +26,7 @@ yampl [files | dirs] [-v key=value...] [flags]
   -p, --prefix string            Template comments must begin with this prefix. The beginning '#' is implied. (default "#yampl")
       --right-delim string       Override template right delimiter (default "}}")
   -s, --strip                    Strip template comments from output
-  -v, --value stringToString     Define a template variable. Can be used more than once. (default [])
+  -v, --var stringToString       Define a template variable. Can be used more than once. (default [])
       --version                  version for yampl
 ```
 

internal/config/config.go

@@ -7,7 +7,7 @@ import (
 
 type Config struct {
 	valuesStringToString *flag.StringToString
-	Values               Values
+	Vars                 Vars
 
 	Inplace    bool
 	Prefix     string
@@ -28,7 +28,7 @@ type Config struct {
 func New() *Config {
 	return &Config{
 		valuesStringToString: &flag.StringToString{},
-		Values:               make(Values),
+		Vars:                 make(Vars),
 
 		Prefix:     "#yampl",
 		LeftDelim:  "{{",

internal/config/flags.go

@@ -6,8 +6,8 @@ import (
 
 const (
 	InplaceFlag    = "inplace"
+	VarFlag        = "var"
 	ValueFlag      = "value"
-	ValueFlagShort = "v"
 	RecursiveFlag  = "recursive"
 	PrefixFlag     = "prefix"
 	LeftDelimFlag  = "left-delim"
@@ -27,7 +27,11 @@ const (
 
 func (c *Config) RegisterFlags(cmd *cobra.Command) {
 	cmd.Flags().BoolVarP(&c.Inplace, InplaceFlag, "i", c.Inplace, "Edit files in place")
-	cmd.Flags().VarP(c.valuesStringToString, ValueFlag, ValueFlagShort, "Define a template variable. Can be used more than once.")
+	cmd.Flags().Var(c.valuesStringToString, ValueFlag, "Define a template variable. Can be used more than once.")
+	cmd.Flags().VarP(c.valuesStringToString, VarFlag, "v", "Define a template variable. Can be used more than once.")
+	if err := cmd.Flags().MarkDeprecated(ValueFlag, "use --"+VarFlag+" instead"); err != nil {
+		panic(err)
+	}
 	cmd.Flags().BoolP(RecursiveFlag, "r", true, "Recursively update yaml files in the given directory")
 	if err := cmd.Flags().MarkDeprecated(RecursiveFlag, cmd.Name()+" will always recurse if a given path is a directory"); err != nil {
 		panic(err)

internal/config/load.go

@@ -39,7 +39,7 @@ func (c *Config) Load(cmd *cobra.Command) error {
 		c.Prefix = "#" + c.Prefix
 	}
 
-	c.Values.Fill(c.valuesStringToString.Values())
+	c.Vars.Fill(c.valuesStringToString.Values())
 
 	if f := cmd.Flags().Lookup(FailFlag); f.Changed {
 		val, err := cmd.Flags().GetBool(FailFlag)

internal/config/vars.go

@@ -0,0 +1,42 @@
+package config
+
+import (
+	"strings"
+)
+
+type Vars map[string]any
+
+func (vars Vars) Fill(src map[string]string) {
+	for key, val := range src {
+		split := strings.Split(key, ".")
+		if len(split) == 1 {
+			vars[key] = val
+		} else {
+			vars.SetNested(val, split...)
+		}
+	}
+}
+
+func (vars Vars) SetNested(v any, k ...string) {
+	setNested(vars, v, k...)
+}
+
+func setNested(vars Vars, val any, keys ...string) {
+	key := keys[0]
+	if len(keys) == 1 {
+		vars[key] = val
+	} else {
+		if _, ok := vars[key]; !ok {
+			vars[key] = Vars{}
+		}
+		setNested(vars[key].(Vars), val, keys[1:]...)
+	}
+}
+
+func (vars Vars) Val() any {
+	return vars["Value"]
+}
+
+func (vars Vars) V() any {
+	return vars["Value"]
+}

internal/config/vars_test.go

@@ -0,0 +1,104 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestVars_Fill(t *testing.T) {
+	type args struct {
+		rawValues map[string]string
+	}
+	tests := []struct {
+		name string
+		vars Vars
+		args args
+		want Vars
+	}{
+		{"simple", make(Vars), args{map[string]string{"a": "a"}}, Vars{"a": "a"}},
+		{"nested", make(Vars), args{map[string]string{"a.b": "a"}}, Vars{"a": Vars{"b": "a"}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.vars.Fill(tt.args.rawValues)
+			assert.Equal(t, tt.want, tt.vars)
+		})
+	}
+}
+
+func TestVars_SetNested(t *testing.T) {
+	type args struct {
+		v any
+		k []string
+	}
+	tests := []struct {
+		name string
+		vars Vars
+		args args
+		want Vars
+	}{
+		{"simple", make(Vars), args{"a", []string{"a"}}, Vars{"a": "a"}},
+		{"nested", make(Vars), args{"a", []string{"a", "b"}}, Vars{"a": Vars{"b": "a"}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.vars.SetNested(tt.args.v, tt.args.k...)
+			assert.Equal(t, tt.want, tt.vars)
+		})
+	}
+}
+
+func TestVars_V(t *testing.T) {
+	tests := []struct {
+		name string
+		vars Vars
+		want any
+	}{
+		{"simple", Vars{"Value": "a"}, "a"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.vars.V()
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestVars_Val(t *testing.T) {
+	tests := []struct {
+		name string
+		vars Vars
+		want any
+	}{
+		{"simple", Vars{"Value": "a"}, "a"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.vars.Val()
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_setNested(t *testing.T) {
+	type args struct {
+		input Vars
+		value any
+		keys  []string
+	}
+	tests := []struct {
+		name string
+		args args
+		want Vars
+	}{
+		{"simple", args{make(Vars), "a", []string{"a"}}, Vars{"a": "a"}},
+		{"nested", args{make(Vars), "a", []string{"a", "b"}}, Vars{"a": Vars{"b": "a"}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			setNested(tt.args.input, tt.args.value, tt.args.keys...)
+			assert.Equal(t, tt.want, tt.args.input)
+		})
+	}
+}

internal/visitor/find_args.go

@@ -146,7 +146,7 @@ func (f FindArgs) Values() []string {
 	result := make([]string, 0, len(f.matches))
 outer:
 	for key, val := range f.matches {
-		for kconf := range f.conf.Values {
+		for kconf := range f.conf.Vars {
 			if key == kconf {
 				continue outer
 			}

internal/visitor/find_args_completion.go

@@ -15,7 +15,10 @@ import (
 )
 
 func RegisterCompletion(cmd *cobra.Command, conf *config.Config) {
-	if err := cmd.RegisterFlagCompletionFunc(config.ValueFlag, valueCompletion(conf)); err != nil {
+	if err := errors.Join(
+		cmd.RegisterFlagCompletionFunc(config.VarFlag, valueCompletion(conf)),
+		cmd.RegisterFlagCompletionFunc(config.ValueFlag, valueCompletion(conf)),
+	); err != nil {
 		panic(err)
 	}
 }

internal/visitor/template_comments.go

@@ -105,12 +105,12 @@ func (t TemplateComments) Template(name string, n *yaml.Node, tmplSrc string, tm
 		return NewNodeError(err, name, n)
 	}
 
-	if t.conf.Values != nil {
-		t.conf.Values["Value"] = n.Value
+	if t.conf.Vars != nil {
+		t.conf.Vars["Value"] = n.Value
 	}
 
 	var buf bytes.Buffer
-	if err = tmpl.Execute(&buf, t.conf.Values); err != nil {
+	if err = tmpl.Execute(&buf, t.conf.Vars); err != nil {
 		return NewNodeError(err, name, n)
 	}