Support any variables

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Added
+  [Any Variables experiment](https://taskfile.dev/experiments/any_variables)
+  (#1415, #1421 by @pd93).
 - Added `aliases` to `--json` flag output (#1430, #1431 by @pd93)
 
 ## v3.32.0 - 2023-11-29

args/args.go

@@ -18,7 +18,7 @@ func ParseV3(args ...string) ([]taskfile.Call, *taskfile.Vars) {
 		}
 
 		name, value := splitVar(arg)
-		globals.Set(name, taskfile.Var{Static: value})
+		globals.Set(name, taskfile.Var{Value: value})
 	}
 
 	return calls, globals
@@ -37,13 +37,13 @@ func ParseV2(args ...string) ([]taskfile.Call, *taskfile.Vars) {
 
 		if len(calls) < 1 {
 			name, value := splitVar(arg)
-			globals.Set(name, taskfile.Var{Static: value})
+			globals.Set(name, taskfile.Var{Value: value})
 		} else {
 			if calls[len(calls)-1].Vars == nil {
 				calls[len(calls)-1].Vars = &taskfile.Vars{}
 			}
 			name, value := splitVar(arg)
-			calls[len(calls)-1].Vars.Set(name, taskfile.Var{Static: value})
+			calls[len(calls)-1].Vars.Set(name, taskfile.Var{Value: value})
 		}
 	}
 

args/args_test.go

@@ -35,9 +35,9 @@ func TestArgsV3(t *testing.T) {
 			ExpectedGlobals: &taskfile.Vars{
 				OrderedMap: orderedmap.FromMapWithOrder(
 					map[string]taskfile.Var{
-						"FOO": {Static: "bar"},
-						"BAR": {Static: "baz"},
-						"BAZ": {Static: "foo"},
+						"FOO": {Value: "bar"},
+						"BAR": {Value: "baz"},
+						"BAZ": {Value: "foo"},
 					},
 					[]string{"FOO", "BAR", "BAZ"},
 				),
@@ -51,7 +51,7 @@ func TestArgsV3(t *testing.T) {
 			ExpectedGlobals: &taskfile.Vars{
 				OrderedMap: orderedmap.FromMapWithOrder(
 					map[string]taskfile.Var{
-						"CONTENT": {Static: "with some spaces"},
+						"CONTENT": {Value: "with some spaces"},
 					},
 					[]string{"CONTENT"},
 				),
@@ -66,7 +66,7 @@ func TestArgsV3(t *testing.T) {
 			ExpectedGlobals: &taskfile.Vars{
 				OrderedMap: orderedmap.FromMapWithOrder(
 					map[string]taskfile.Var{
-						"FOO": {Static: "bar"},
+						"FOO": {Value: "bar"},
 					},
 					[]string{"FOO"},
 				),
@@ -86,8 +86,8 @@ func TestArgsV3(t *testing.T) {
 			ExpectedGlobals: &taskfile.Vars{
 				OrderedMap: orderedmap.FromMapWithOrder(
 					map[string]taskfile.Var{
-						"FOO": {Static: "bar"},
-						"BAR": {Static: "baz"},
+						"FOO": {Value: "bar"},
+						"BAR": {Value: "baz"},
 					},
 					[]string{"FOO", "BAR"},
 				),
@@ -130,7 +130,7 @@ func TestArgsV2(t *testing.T) {
 					Vars: &taskfile.Vars{
 						OrderedMap: orderedmap.FromMapWithOrder(
 							map[string]taskfile.Var{
-								"FOO": {Static: "bar"},
+								"FOO": {Value: "bar"},
 							},
 							[]string{"FOO"},
 						),
@@ -143,8 +143,8 @@ func TestArgsV2(t *testing.T) {
 					Vars: &taskfile.Vars{
 						OrderedMap: orderedmap.FromMapWithOrder(
 							map[string]taskfile.Var{
-								"BAR": {Static: "baz"},
-								"BAZ": {Static: "foo"},
+								"BAR": {Value: "baz"},
+								"BAZ": {Value: "foo"},
 							},
 							[]string{"BAR", "BAZ"},
 						),
@@ -161,7 +161,7 @@ func TestArgsV2(t *testing.T) {
 					Vars: &taskfile.Vars{
 						OrderedMap: orderedmap.FromMapWithOrder(
 							map[string]taskfile.Var{
-								"CONTENT": {Static: "with some spaces"},
+								"CONTENT": {Value: "with some spaces"},
 							},
 							[]string{"CONTENT"},
 						),
@@ -178,7 +178,7 @@ func TestArgsV2(t *testing.T) {
 			ExpectedGlobals: &taskfile.Vars{
 				OrderedMap: orderedmap.FromMapWithOrder(
 					map[string]taskfile.Var{
-						"FOO": {Static: "bar"},
+						"FOO": {Value: "bar"},
 					},
 					[]string{"FOO"},
 				),
@@ -198,8 +198,8 @@ func TestArgsV2(t *testing.T) {
 			ExpectedGlobals: &taskfile.Vars{
 				OrderedMap: orderedmap.FromMapWithOrder(
 					map[string]taskfile.Var{
-						"FOO": {Static: "bar"},
-						"BAR": {Static: "baz"},
+						"FOO": {Value: "bar"},
+						"BAR": {Value: "baz"},
 					},
 					[]string{"FOO", "BAR"},
 				),

cmd/task/task.go

@@ -311,7 +311,7 @@ func run() error {
 		calls = append(calls, taskfile.Call{Task: "default", Direct: true})
 	}
 
-	globals.Set("CLI_ARGS", taskfile.Var{Static: cliArgs})
+	globals.Set("CLI_ARGS", taskfile.Var{Value: cliArgs})
 	e.Taskfile.Vars.Merge(globals)
 
 	if !flags.watch {

docs/docs/experiments/any_variables.md

@@ -0,0 +1,105 @@
+---
+slug: /experiments/any-variables/
+---
+
+# Any Variables
+
+- Issue: [#1415](https://github.com/go-task/task/issues/1415)
+- Environment variable: `TASK_X_ANY_VARIABLES=1`
+- Breaks:
+  - Dynamically defined variables (using the `sh` keyword)
+
+Currently, Task only supports string variables. This experiment allows you to
+specify and use the following variable types:
+
+- `string`
+- `bool`
+- `int`
+- `float`
+- `array`
+- `map`
+
+This allows you to have a lot more flexibility in how you use variables in
+Task's templating engine. For example:
+
+Evaluating booleans:
+
+```yaml
+version: 3
+
+tasks:
+  foo:
+    vars:
+      BOOL: false
+    cmds:
+      - '{{ if .BOOL }}echo foo{{ end}}'
+```
+
+Arithmetic:
+
+```yaml
+version: 3
+
+tasks:
+  foo:
+    vars:
+      INT: 10
+      FLOAT: 3.14159
+    cmds:
+      - 'echo {{ add .INT .FLOAT }}'
+```
+
+Loops:
+
+```yaml
+version: 3
+
+tasks:
+  foo:
+    vars:
+      ARRAY: [1, 2, 3]
+    cmds:
+      - 'echo {{ range .ARRAY }}{{ . }}{{ end }}'
+```
+
+etc.
+
+## Migration
+
+Taskfiles with dynamically defined variables via the `sh` subkey will no longer
+work with this experiment enabled. In order to keep using dynamically defined
+variables, you will need to migrate your Taskfile to use the new syntax.
+
+Previously, you might have defined a dynamic variable like this:
+
+```yaml
+version: 3
+
+task:
+  foo:
+    vars:
+      CALCULATED_VAR:
+        sh: 'echo hello'
+    cmds:
+      - 'echo {{ .CALCULATED_VAR }}'
+```
+
+With this experiment enabled, you will need to remove the `sh` subkey and define
+your command as a string that begins with a `$`. This will instruct Task to
+interpret the string as a command instead of a literal value and the variable
+will be populated with the output of the command. For example:
+
+```yaml
+version: 3
+
+task:
+  foo:
+    vars:
+      CALCULATED_VAR: '$echo hello'
+    cmds:
+      - 'echo {{ .CALCULATED_VAR }}'
+```
+
+If your current Taskfile contains a string variable that begins with a `$`, you
+will now need to escape the `$` with a backslash (`\`) to stop Task from
+executing it as a command.

docs/static/schema.json

@@ -249,7 +249,7 @@
           "^.*$": {
             "anyOf": [
               {
-                "type": ["boolean", "integer", "null", "number", "string"]
+                "type": ["boolean", "integer", "null", "number", "string", "object", "array"]
               },
               {
                 "$ref": "#/definitions/3/dynamic_var"

internal/compiler/env.go

@@ -14,7 +14,7 @@ func GetEnviron() *taskfile.Vars {
 	for _, e := range os.Environ() {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]
-		m.Set(key, taskfile.Var{Static: val})
+		m.Set(key, taskfile.Var{Value: val})
 	}
 	return m
 }

internal/compiler/v2/compiler_v2.go

@@ -50,7 +50,7 @@ func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfi
 		c:    c,
 		vars: compiler.GetEnviron(),
 	}
-	vr.vars.Set("TASK", taskfile.Var{Static: t.Task})
+	vr.vars.Set("TASK", taskfile.Var{Value: t.Task})
 
 	for _, vars := range []*taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
 		for i := 0; i < c.Expansions; i++ {
@@ -72,26 +72,33 @@ func (vr *varResolver) merge(vars *taskfile.Vars) {
 	}
 	tr := templater.Templater{Vars: vr.vars}
 	_ = vars.Range(func(k string, v taskfile.Var) error {
-		v = taskfile.Var{
-			Static: tr.Replace(v.Static),
-			Sh:     tr.Replace(v.Sh),
+		// Replace values
+		newVar := taskfile.Var{}
+		switch value := v.Value.(type) {
+		case string:
+			newVar.Value = tr.Replace(value)
+		default:
+			newVar.Value = value
 		}
-		static, err := vr.c.HandleDynamicVar(v, "")
+		newVar.Sh = tr.Replace(v.Sh)
+		// If the variable is not dynamic, we can set it and return
+		if newVar.Value != nil || newVar.Sh == "" {
+			vr.vars.Set(k, taskfile.Var{Value: newVar.Value})
+			return nil
+		}
+		// If the variable is dynamic, we need to resolve it first
+		static, err := vr.c.HandleDynamicVar(newVar, "")
 		if err != nil {
 			vr.err = err
 			return err
 		}
-		vr.vars.Set(k, taskfile.Var{Static: static})
+		vr.vars.Set(k, taskfile.Var{Value: static})
 		return nil
 	})
 	vr.err = tr.Err()
 }
 
 func (c *CompilerV2) HandleDynamicVar(v taskfile.Var, _ string) (string, error) {
-	if v.Static != "" || v.Sh == "" {
-		return v.Static, nil
-	}
-
 	c.muDynamicCache.Lock()
 	defer c.muDynamicCache.Unlock()
 

internal/compiler/v3/compiler_v3.go

@@ -51,32 +51,43 @@ func (c *CompilerV3) getVariables(t *taskfile.Task, call *taskfile.Call, evaluat
 			return nil, err
 		}
 		for k, v := range specialVars {
-			result.Set(k, taskfile.Var{Static: v})
+			result.Set(k, taskfile.Var{Value: v})
 		}
 	}
 
 	getRangeFunc := func(dir string) func(k string, v taskfile.Var) error {
 		return func(k string, v taskfile.Var) error {
 			tr := templater.Templater{Vars: result, RemoveNoValue: true}
-
-			if !evaluateShVars {
-				result.Set(k, taskfile.Var{Static: tr.Replace(v.Static)})
-				return nil
-			}
-
-			v = taskfile.Var{
-				Static: tr.Replace(v.Static),
-				Sh:     tr.Replace(v.Sh),
-				Dir:    v.Dir,
+			// Replace values
+			newVar := taskfile.Var{}
+			switch value := v.Value.(type) {
+			case string:
+				newVar.Value = tr.Replace(value)
+			default:
+				newVar.Value = value
 			}
+			newVar.Sh = tr.Replace(v.Sh)
+			newVar.Dir = v.Dir
 			if err := tr.Err(); err != nil {
 				return err
 			}
-			static, err := c.HandleDynamicVar(v, dir)
+			// If the variable should not be evaluated, but is nil, set it to an empty string
+			// This stops empty interface errors when using the templater to replace values later
+			if !evaluateShVars && newVar.Value == nil {
+				result.Set(k, taskfile.Var{Value: ""})
+				return nil
+			}
+			// If the variable is not dynamic, we can set it and return
+			if !evaluateShVars || newVar.Value != nil || newVar.Sh == "" {
+				result.Set(k, taskfile.Var{Value: newVar.Value})
+				return nil
+			}
+			// If the variable is dynamic, we need to resolve it first
+			static, err := c.HandleDynamicVar(newVar, dir)
 			if err != nil {
 				return err
 			}
-			result.Set(k, taskfile.Var{Static: static})
+			result.Set(k, taskfile.Var{Value: static})
 			return nil
 		}
 	}
@@ -125,10 +136,6 @@ func (c *CompilerV3) getVariables(t *taskfile.Task, call *taskfile.Call, evaluat
 }
 
 func (c *CompilerV3) HandleDynamicVar(v taskfile.Var, dir string) (string, error) {
-	if v.Static != "" || v.Sh == "" {
-		return v.Static, nil
-	}
-
 	c.muDynamicCache.Lock()
 	defer c.muDynamicCache.Unlock()