use YAML for dynamix variable instead of $ prefix

$ prefix still works but is now deprecated

before:

    VAR: $echo var

after:

    VAR:
      sh: echo bar

closes #46

Author: andreynering

command_test.go

@@ -33,7 +33,10 @@ vars:
 		{
 			yamlTaskCall,
 			&task.Cmd{},
-			&task.Cmd{Task: "another-task", Vars: task.Vars{"PARAM1": "VALUE1", "PARAM2": "VALUE2"}},
+			&task.Cmd{Task: "another-task", Vars: task.Vars{
+				"PARAM1": task.Var{Static: "VALUE1"},
+				"PARAM2": task.Var{Static: "VALUE2"},
+			}},
 		},
 		{
 			yamlDep,
@@ -43,7 +46,10 @@ vars:
 		{
 			yamlTaskCall,
 			&task.Dep{},
-			&task.Dep{Task: "another-task", Vars: task.Vars{"PARAM1": "VALUE1", "PARAM2": "VALUE2"}},
+			&task.Dep{Task: "another-task", Vars: task.Vars{
+				"PARAM1": task.Var{Static: "VALUE1"},
+				"PARAM2": task.Var{Static: "VALUE2"},
+			}},
 		},
 	}
 	for _, test := range tests {

task.go

@@ -39,13 +39,10 @@ type Executor struct {
 	taskvars      Vars
 	watchingFiles map[string]struct{}
 
-	dynamicCache   Vars
+	dynamicCache   map[string]string
 	muDynamicCache sync.Mutex
 }
 
-// Vars is a string[string] variables map
-type Vars map[string]string
-
 // Tasks representas a group of tasks
 type Tasks map[string]*Task
 
@@ -78,7 +75,7 @@ func (e *Executor) Run(args ...string) error {
 	}
 
 	if e.dynamicCache == nil {
-		e.dynamicCache = make(Vars, 10)
+		e.dynamicCache = make(map[string]string, 10)
 	}
 
 	// check if given tasks exist
@@ -167,11 +164,15 @@ func (e *Executor) runDeps(ctx context.Context, call Call) error {
 			}
 			depVars := make(Vars, len(d.Vars))
 			for k, v := range d.Vars {
-				v, err := e.ReplaceVariables(v, call)
+				static, err := e.ReplaceVariables(v.Static, call)
+				if err != nil {
+					return err
+				}
+				sh, err := e.ReplaceVariables(v.Sh, call)
 				if err != nil {
 					return err
 				}
-				depVars[k] = v
+				depVars[k] = Var{Static: static, Sh: sh}
 			}
 
 			return e.RunTask(ctx, Call{Task: dep, Vars: depVars})
@@ -260,11 +261,15 @@ func (e *Executor) runCommand(ctx context.Context, call Call, i int) error {
 	if cmd.Cmd == "" {
 		cmdVars := make(Vars, len(cmd.Vars))
 		for k, v := range cmd.Vars {
-			v, err := e.ReplaceVariables(v, call)
+			static, err := e.ReplaceVariables(v.Static, call)
+			if err != nil {
+				return err
+			}
+			sh, err := e.ReplaceVariables(v.Sh, call)
 			if err != nil {
 				return err
 			}
-			cmdVars[k] = v
+			cmdVars[k] = Var{Static: static, Sh: sh}
 		}
 		return e.RunTask(ctx, Call{Task: cmd.Task, Vars: cmdVars})
 	}

task_test.go

@@ -61,8 +61,10 @@ func TestVars(t *testing.T) {
 	}{
 		{"foo.txt", "foo"},
 		{"bar.txt", "bar"},
+		{"baz.txt", "baz"},
 		{"foo2.txt", "foo2"},
 		{"bar2.txt", "bar2"},
+		{"baz2.txt", "baz2"},
 		{"equal.txt", "foo=bar"},
 	}
 

testdata/vars/Taskfile.yml

@@ -6,12 +6,16 @@ hello:
   cmds:
     - echo {{.FOO}} > foo.txt
     - echo {{.BAR}} > bar.txt
+    - echo {{.BAZ}} > baz.txt
     - echo {{.FOO2}} > foo2.txt
     - echo {{.BAR2}} > bar2.txt
+    - echo {{.BAZ2}} > baz2.txt
     - echo {{.EQUAL}} > equal.txt
   vars:
     FOO: foo
     BAR: $echo bar
+    BAZ:
+      sh: echo baz
 
 set-equal:
   set: EQUAL

testdata/vars/Taskvars.yml

@@ -1,2 +1,4 @@
 FOO2: foo2
 BAR2: $echo bar2
+BAZ2:
+  sh: echo baz2

variables.go

@@ -21,6 +21,50 @@ var (
 	ErrMultilineResultCmd = errors.New("Got multiline result from command")
 )
 
+// Vars is a string[string] variables map
+type Vars map[string]Var
+
+// Var represents either a static or dynamic variable
+type Var struct {
+	Static string
+	Sh     string
+}
+
+func (vs Vars) toStringMap() (m map[string]string) {
+	m = make(map[string]string, len(vs))
+	for k, v := range vs {
+		m[k] = v.Static
+	}
+	return
+}
+
+var (
+	// ErrCantUnmarshalVar is returned for invalid var YAML
+	ErrCantUnmarshalVar = errors.New("task: can't unmarshal var value")
+)
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (v *Var) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var str string
+	if err := unmarshal(&str); err == nil {
+		if strings.HasPrefix(str, "$") {
+			v.Sh = strings.TrimPrefix(str, "$")
+		} else {
+			v.Static = str
+		}
+		return nil
+	}
+
+	var sh struct {
+		Sh string
+	}
+	if err := unmarshal(&sh); err == nil {
+		v.Sh = sh.Sh
+		return nil
+	}
+	return ErrCantUnmarshalVar
+}
+
 var (
 	templateFuncs template.FuncMap
 )
@@ -59,7 +103,7 @@ func (e *Executor) ReplaceVariables(initial string, call Call) (string, error) {
 	}
 
 	var b bytes.Buffer
-	if err = templ.Execute(&b, call.Vars); err != nil {
+	if err = templ.Execute(&b, call.Vars.toStringMap()); err != nil {
 		return "", err
 	}
 	return b.String(), nil
@@ -86,7 +130,11 @@ func (e *Executor) getVariables(call Call) (Vars, error) {
 		for k, v := range vars {
 			if runTemplate {
 				var err error
-				v, err = e.ReplaceVariables(v, call)
+				v.Static, err = e.ReplaceVariables(v.Static, call)
+				if err != nil {
+					return err
+				}
+				v.Sh, err = e.ReplaceVariables(v.Sh, call)
 				if err != nil {
 					return err
 				}
@@ -97,7 +145,7 @@ func (e *Executor) getVariables(call Call) (Vars, error) {
 				return err
 			}
 
-			result[k] = v
+			result[k] = Var{Static: v}
 		}
 		return nil
 	}
@@ -128,25 +176,25 @@ func getEnvironmentVariables() Vars {
 	for _, e := range env {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]
-		m[key] = val
+		m[key] = Var{Static: val}
 	}
 	return m
 }
 
-func (e *Executor) handleDynamicVariableContent(value string) (string, error) {
-	if !strings.HasPrefix(value, "$") {
-		return value, nil
+func (e *Executor) handleDynamicVariableContent(v Var) (string, error) {
+	if v.Static != "" {
+		return v.Static, nil
 	}
 
 	e.muDynamicCache.Lock()
 	defer e.muDynamicCache.Unlock()
-	if result, ok := e.dynamicCache[value]; ok {
+	if result, ok := e.dynamicCache[v.Sh]; ok {
 		return result, nil
 	}
 
 	var stdout bytes.Buffer
 	opts := &execext.RunCommandOptions{
-		Command: strings.TrimPrefix(value, "$"),
+		Command: v.Sh,
 		Dir:     e.Dir,
 		Stdout:  &stdout,
 		Stderr:  e.Stderr,
@@ -161,7 +209,7 @@ func (e *Executor) handleDynamicVariableContent(value string) (string, error) {
 	}
 
 	result = strings.TrimSpace(result)
-	e.verbosePrintfln(`task: dynamic variable: "%s", result: "%s"`, value, result)
-	e.dynamicCache[value] = result
+	e.verbosePrintfln(`task: dynamic variable: "%s", result: "%s"`, v.Sh, result)
+	e.dynamicCache[v.Sh] = result
 	return result, nil
 }