Merge pull request #311 from go-task/vars-refactor-for-v3

v3: Variables refactoring

Author: andreynering

cmd/task/task.go

@@ -148,9 +148,7 @@ func main() {
 	}
 
 	calls, globals := args.Parse(pflag.Args()...)
-	for name, value := range globals {
-		e.Taskfile.Vars[name] = value
-	}
+	e.Taskfile.Vars.Merge(globals)
 
 	ctx := context.Background()
 	if !watch {

go.mod

@@ -9,7 +9,7 @@ require (
 	github.com/spf13/pflag v1.0.3
 	github.com/stretchr/testify v1.5.1
 	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
-	gopkg.in/yaml.v2 v2.2.2
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
 	mvdan.cc/sh/v3 v3.1.0
 )
 

go.sum

@@ -59,6 +59,8 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 mvdan.cc/editorconfig v0.1.1-0.20200121172147-e40951bde157/go.mod h1:Ge4atmRUYqueGppvJ7JNrtqpqokoJEFxYbP0Z+WeKS8=
 mvdan.cc/sh/v3 v3.1.0 h1:bFxsEzIubuABloc8G1Ko78rbZZ0JspNN9e9+R/w3z5k=
 mvdan.cc/sh/v3 v3.1.0/go.mod h1:F+Vm4ZxPJxDKExMLhvjuI50oPnedVXpfjNSrusiTOno=

internal/args/args.go

@@ -7,9 +7,9 @@ import (
 )
 
 // Parse parses command line argument: tasks and vars of each task
-func Parse(args ...string) ([]taskfile.Call, taskfile.Vars) {
+func Parse(args ...string) ([]taskfile.Call, *taskfile.Vars) {
 	var calls []taskfile.Call
-	var globals taskfile.Vars
+	var globals *taskfile.Vars
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {
@@ -19,18 +19,16 @@ func Parse(args ...string) ([]taskfile.Call, taskfile.Vars) {
 
 		if len(calls) < 1 {
 			if globals == nil {
-				globals = taskfile.Vars{}
+				globals = &taskfile.Vars{}
 			}
-
 			name, value := splitVar(arg)
-			globals[name] = taskfile.Var{Static: value}
+			globals.Set(name, taskfile.Var{Static: value})
 		} else {
 			if calls[len(calls)-1].Vars == nil {
-				calls[len(calls)-1].Vars = make(taskfile.Vars)
+				calls[len(calls)-1].Vars = &taskfile.Vars{}
 			}
-
-			name, value := splitVar((arg))
-			calls[len(calls)-1].Vars[name] = taskfile.Var{Static: value}
+			name, value := splitVar(arg)
+			calls[len(calls)-1].Vars.Set(name, taskfile.Var{Static: value})
 		}
 	}
 

internal/args/args_test.go

@@ -14,7 +14,7 @@ func TestArgs(t *testing.T) {
 	tests := []struct {
 		Args            []string
 		ExpectedCalls   []taskfile.Call
-		ExpectedGlobals taskfile.Vars
+		ExpectedGlobals *taskfile.Vars
 	}{
 		{
 			Args: []string{"task-a", "task-b", "task-c"},
@@ -29,16 +29,22 @@ func TestArgs(t *testing.T) {
 			ExpectedCalls: []taskfile.Call{
 				{
 					Task: "task-a",
-					Vars: taskfile.Vars{
-						"FOO": taskfile.Var{Static: "bar"},
+					Vars: &taskfile.Vars{
+						Keys: []string{"FOO"},
+						Mapping: map[string]taskfile.Var{
+							"FOO": taskfile.Var{Static: "bar"},
+						},
 					},
 				},
 				{Task: "task-b"},
 				{
 					Task: "task-c",
-					Vars: taskfile.Vars{
-						"BAR": taskfile.Var{Static: "baz"},
-						"BAZ": taskfile.Var{Static: "foo"},
+					Vars: &taskfile.Vars{
+						Keys: []string{"BAR", "BAZ"},
+						Mapping: map[string]taskfile.Var{
+							"BAR": taskfile.Var{Static: "baz"},
+							"BAZ": taskfile.Var{Static: "foo"},
+						},
 					},
 				},
 			},
@@ -48,8 +54,11 @@ func TestArgs(t *testing.T) {
 			ExpectedCalls: []taskfile.Call{
 				{
 					Task: "task-a",
-					Vars: taskfile.Vars{
-						"CONTENT": taskfile.Var{Static: "with some spaces"},
+					Vars: &taskfile.Vars{
+						Keys: []string{"CONTENT"},
+						Mapping: map[string]taskfile.Var{
+							"CONTENT": taskfile.Var{Static: "with some spaces"},
+						},
 					},
 				},
 			},
@@ -60,8 +69,11 @@ func TestArgs(t *testing.T) {
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
-			ExpectedGlobals: taskfile.Vars{
-				"FOO": {Static: "bar"},
+			ExpectedGlobals: &taskfile.Vars{
+				Keys: []string{"FOO"},
+				Mapping: map[string]taskfile.Var{
+					"FOO": {Static: "bar"},
+				},
 			},
 		},
 		{
@@ -81,9 +93,12 @@ func TestArgs(t *testing.T) {
 			ExpectedCalls: []taskfile.Call{
 				{Task: "default"},
 			},
-			ExpectedGlobals: taskfile.Vars{
-				"FOO": {Static: "bar"},
-				"BAR": {Static: "baz"},
+			ExpectedGlobals: &taskfile.Vars{
+				Keys: []string{"FOO", "BAR"},
+				Mapping: map[string]taskfile.Var{
+					"FOO": {Static: "bar"},
+					"BAR": {Static: "baz"},
+				},
 			},
 		},
 	}

internal/compiler/compiler.go

@@ -7,6 +7,6 @@ import (
 // Compiler handles compilation of a task before its execution.
 // E.g. variable merger, template processing, etc.
 type Compiler interface {
-	GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error)
+	GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error)
 	HandleDynamicVar(v taskfile.Var) (string, error)
 }

internal/compiler/env.go

@@ -9,16 +9,12 @@ import (
 
 // GetEnviron the all return all environment variables encapsulated on a
 // taskfile.Vars
-func GetEnviron() taskfile.Vars {
-	var (
-		env = os.Environ()
-		m   = make(taskfile.Vars, len(env))
-	)
-
-	for _, e := range env {
+func GetEnviron() *taskfile.Vars {
+	m := &taskfile.Vars{}
+	for _, e := range os.Environ() {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]
-		m[key] = taskfile.Var{Static: val}
+		m.Set(key, taskfile.Var{Static: val})
 	}
 	return m
 }

internal/compiler/v2/compiler_v2.go

@@ -19,8 +19,8 @@ var _ compiler.Compiler = &CompilerV2{}
 type CompilerV2 struct {
 	Dir string
 
-	Taskvars     taskfile.Vars
-	TaskfileVars taskfile.Vars
+	Taskvars     *taskfile.Vars
+	TaskfileVars *taskfile.Vars
 
 	Expansions int
 
@@ -36,10 +36,10 @@ type CompilerV2 struct {
 // 3. Taskfile variables
 // 4. Taskvars file variables
 // 5. Environment variables
-func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error) {
+func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
 	vr := varResolver{c: c, vars: compiler.GetEnviron()}
-	vr.vars["TASK"] = taskfile.Var{Static: t.Task}
-	for _, vars := range []taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
+	vr.vars.Set("TASK", taskfile.Var{Static: t.Task})
+	for _, vars := range []*taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
 		for i := 0; i < c.Expansions; i++ {
 			vr.merge(vars)
 		}
@@ -49,27 +49,28 @@ func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfil
 
 type varResolver struct {
 	c    *CompilerV2
-	vars taskfile.Vars
+	vars *taskfile.Vars
 	err  error
 }
 
-func (vr *varResolver) merge(vars taskfile.Vars) {
+func (vr *varResolver) merge(vars *taskfile.Vars) {
 	if vr.err != nil {
 		return
 	}
 	tr := templater.Templater{Vars: vr.vars}
-	for k, v := range vars {
+	vars.Range(func(k string, v taskfile.Var) error {
 		v = taskfile.Var{
 			Static: tr.Replace(v.Static),
 			Sh:     tr.Replace(v.Sh),
 		}
 		static, err := vr.c.HandleDynamicVar(v)
 		if err != nil {
 			vr.err = err
-			return
+			return err
 		}
-		vr.vars[k] = taskfile.Var{Static: static}
-	}
+		vr.vars.Set(k, taskfile.Var{Static: static})
+		return nil
+	})
 	vr.err = tr.Err()
 }
 

internal/compiler/v3/compiler_v3.go

@@ -0,0 +1,98 @@
+package v3
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/go-task/task/v2/internal/compiler"
+	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/logger"
+	"github.com/go-task/task/v2/internal/taskfile"
+	"github.com/go-task/task/v2/internal/templater"
+)
+
+var _ compiler.Compiler = &CompilerV3{}
+
+type CompilerV3 struct {
+	Dir string
+
+	TaskfileVars *taskfile.Vars
+
+	Logger *logger.Logger
+
+	dynamicCache   map[string]string
+	muDynamicCache sync.Mutex
+}
+
+func (c *CompilerV3) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
+	result := compiler.GetEnviron()
+	result.Set("TASK", taskfile.Var{Static: t.Task})
+
+	rangeFunc := func(k string, v taskfile.Var) error {
+		tr := templater.Templater{Vars: result, RemoveNoValue: true}
+		v = taskfile.Var{
+			Static: tr.Replace(v.Static),
+			Sh:     tr.Replace(v.Sh),
+		}
+		if err := tr.Err(); err != nil {
+			return err
+		}
+		static, err := c.HandleDynamicVar(v)
+		if err != nil {
+			return err
+		}
+		result.Set(k, taskfile.Var{Static: static})
+		return nil
+	}
+
+	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if err := call.Vars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if err := t.Vars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (c *CompilerV3) HandleDynamicVar(v taskfile.Var) (string, error) {
+	if v.Static != "" || v.Sh == "" {
+		return v.Static, nil
+	}
+
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[v.Sh]; ok {
+		return result, nil
+	}
+
+	var stdout bytes.Buffer
+	opts := &execext.RunCommandOptions{
+		Command: v.Sh,
+		Dir:     c.Dir,
+		Stdout:  &stdout,
+		Stderr:  c.Logger.Stderr,
+	}
+	if err := execext.RunCommand(context.Background(), opts); err != nil {
+		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
+	}
+
+	// Trim a single trailing newline from the result to make most command
+	// output easier to use in shell commands.
+	result := strings.TrimSuffix(stdout.String(), "\n")
+
+	c.dynamicCache[v.Sh] = result
+	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+
+	return result, nil
+}

internal/taskfile/call.go

@@ -3,5 +3,5 @@ package taskfile
 // Call is the parameters to a task call
 type Call struct {
 	Task string
-	Vars Vars
+	Vars *Vars
 }