refactor: join task and vars parameters in a single Call struct

andreynering · andreynering · commit 7a7f66dfdc94 · 2017-07-08T14:34:17.000-03:00
diff --git a/command.go b/command.go
@@ -66,3 +66,9 @@ func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	}
 	return ErrCantUnmarshalDep
 }
+
+// Call is the parameters to a task call
+type Call struct {
+	Task string
+	Vars Vars
+}
diff --git a/task.go b/task.go
@@ -98,61 +98,61 @@ func (e *Executor) Run(args ...string) error {
 	}
 
 	for _, a := range args {
-		if err := e.RunTask(context.Background(), a, nil); err != nil {
+		if err := e.RunTask(context.Background(), Call{Task: a}); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
 // RunTask runs a task by its name
-func (e *Executor) RunTask(ctx context.Context, name string, vars Vars) error {
-	t, ok := e.Tasks[name]
+func (e *Executor) RunTask(ctx context.Context, call Call) error {
+	t, ok := e.Tasks[call.Task]
 	if !ok {
-		return &taskNotFoundError{name}
+		return &taskNotFoundError{call.Task}
 	}
 
 	if atomic.AddInt32(&t.callCount, 1) >= MaximumTaskCall {
-		return &MaximumTaskCallExceededError{task: name}
+		return &MaximumTaskCallExceededError{task: call.Task}
 	}
 
-	if err := e.runDeps(ctx, name, vars); err != nil {
+	if err := e.runDeps(ctx, call); err != nil {
 		return err
 	}
 
 	if !e.Force {
-		upToDate, err := e.isTaskUpToDate(ctx, name, vars)
+		upToDate, err := e.isTaskUpToDate(ctx, call)
 		if err != nil {
 			return err
 		}
 		if upToDate {
-			e.printfln(`task: Task "%s" is up to date`, name)
+			e.printfln(`task: Task "%s" is up to date`, call.Task)
 			return nil
 		}
 	}
 
 	for i := range t.Cmds {
-		if err := e.runCommand(ctx, name, i, vars); err != nil {
-			return &taskRunError{name, err}
+		if err := e.runCommand(ctx, call, i); err != nil {
+			return &taskRunError{call.Task, err}
 		}
 	}
 	return nil
 }
 
-func (e *Executor) runDeps(ctx context.Context, task string, vars Vars) error {
+func (e *Executor) runDeps(ctx context.Context, call Call) error {
 	g, ctx := errgroup.WithContext(ctx)
-	t := e.Tasks[task]
+	t := e.Tasks[call.Task]
 
 	for _, d := range t.Deps {
 		d := d
 
 		g.Go(func() error {
-			dep, err := e.ReplaceVariables(d.Task, task, vars)
+			dep, err := e.ReplaceVariables(d.Task, call)
 			if err != nil {
 				return err
 			}
 
-			if err = e.RunTask(ctx, dep, d.Vars); err != nil {
+			if err = e.RunTask(ctx, Call{Task: dep, Vars: d.Vars}); err != nil {
 				return err
 			}
 			return nil
@@ -165,27 +165,27 @@ func (e *Executor) runDeps(ctx context.Context, task string, vars Vars) error {
 	return nil
 }
 
-func (e *Executor) isTaskUpToDate(ctx context.Context, task string, vars Vars) (bool, error) {
-	t := e.Tasks[task]
+func (e *Executor) isTaskUpToDate(ctx context.Context, call Call) (bool, error) {
+	t := e.Tasks[call.Task]
 
 	if len(t.Status) > 0 {
-		return e.isUpToDateStatus(ctx, task, vars)
+		return e.isUpToDateStatus(ctx, call)
 	}
-	return e.isUpToDateTimestamp(ctx, task, vars)
+	return e.isUpToDateTimestamp(ctx, call)
 }
 
-func (e *Executor) isUpToDateStatus(ctx context.Context, task string, vars Vars) (bool, error) {
-	t := e.Tasks[task]
+func (e *Executor) isUpToDateStatus(ctx context.Context, call Call) (bool, error) {
+	t := e.Tasks[call.Task]
 
-	environ, err := e.getEnviron(task, vars)
+	environ, err := e.getEnviron(call)
 	if err != nil {
 		return false, err
 	}
-	dir, err := e.getTaskDir(task, vars)
+	dir, err := e.getTaskDir(call)
 	if err != nil {
 		return false, err
 	}
-	status, err := e.ReplaceSliceVariables(t.Status, task, vars)
+	status, err := e.ReplaceSliceVariables(t.Status, call)
 	if err != nil {
 		return false, err
 	}
@@ -204,23 +204,23 @@ func (e *Executor) isUpToDateStatus(ctx context.Context, task string, vars Vars)
 	return true, nil
 }
 
-func (e *Executor) isUpToDateTimestamp(ctx context.Context, task string, vars Vars) (bool, error) {
-	t := e.Tasks[task]
+func (e *Executor) isUpToDateTimestamp(ctx context.Context, call Call) (bool, error) {
+	t := e.Tasks[call.Task]
 
 	if len(t.Sources) == 0 || len(t.Generates) == 0 {
 		return false, nil
 	}
 
-	dir, err := e.getTaskDir(task, vars)
+	dir, err := e.getTaskDir(call)
 	if err != nil {
 		return false, err
 	}
 
-	sources, err := e.ReplaceSliceVariables(t.Sources, task, vars)
+	sources, err := e.ReplaceSliceVariables(t.Sources, call)
 	if err != nil {
 		return false, err
 	}
-	generates, err := e.ReplaceSliceVariables(t.Generates, task, vars)
+	generates, err := e.ReplaceSliceVariables(t.Generates, call)
 	if err != nil {
 		return false, err
 	}
@@ -238,33 +238,33 @@ func (e *Executor) isUpToDateTimestamp(ctx context.Context, task string, vars Va
 	return generatesMinTime.After(sourcesMaxTime), nil
 }
 
-func (e *Executor) runCommand(ctx context.Context, task string, i int, vars Vars) error {
-	t := e.Tasks[task]
+func (e *Executor) runCommand(ctx context.Context, call Call, i int) error {
+	t := e.Tasks[call.Task]
 	cmd := t.Cmds[i]
 
 	if cmd.Cmd == "" {
 		cmdVars := make(Vars, len(cmd.Vars))
 		for k, v := range cmd.Vars {
-			v, err := e.ReplaceVariables(v, task, vars)
+			v, err := e.ReplaceVariables(v, call)
 			if err != nil {
 				return err
 			}
 			cmdVars[k] = v
 		}
-		return e.RunTask(ctx, cmd.Task, cmdVars)
+		return e.RunTask(ctx, Call{Task: cmd.Task, Vars: cmdVars})
 	}
 
-	c, err := e.ReplaceVariables(cmd.Cmd, task, vars)
+	c, err := e.ReplaceVariables(cmd.Cmd, call)
 	if err != nil {
 		return err
 	}
 
-	dir, err := e.getTaskDir(task, vars)
+	dir, err := e.getTaskDir(call)
 	if err != nil {
 		return err
 	}
 
-	envs, err := e.getEnviron(task, vars)
+	envs, err := e.getEnviron(call)
 	if err != nil {
 		return err
 	}
@@ -294,23 +294,23 @@ func (e *Executor) runCommand(ctx context.Context, task string, i int, vars Vars
 	return nil
 }
 
-func (e *Executor) getTaskDir(task string, vars Vars) (string, error) {
-	t := e.Tasks[task]
+func (e *Executor) getTaskDir(call Call) (string, error) {
+	t := e.Tasks[call.Task]
 
-	exeDir, err := e.ReplaceVariables(e.Dir, task, vars)
+	exeDir, err := e.ReplaceVariables(e.Dir, call)
 	if err != nil {
 		return "", err
 	}
-	taskDir, err := e.ReplaceVariables(t.Dir, task, vars)
+	taskDir, err := e.ReplaceVariables(t.Dir, call)
 	if err != nil {
 		return "", err
 	}
 
 	return filepath.Join(exeDir, taskDir), nil
 }
 
-func (e *Executor) getEnviron(task string, vars Vars) ([]string, error) {
-	t := e.Tasks[task]
+func (e *Executor) getEnviron(call Call) ([]string, error) {
+	t := e.Tasks[call.Task]
 
 	if t.Env == nil {
 		return nil, nil
@@ -319,7 +319,7 @@ func (e *Executor) getEnviron(task string, vars Vars) ([]string, error) {
 	envs := os.Environ()
 
 	for k, v := range t.Env {
-		env, err := e.ReplaceVariables(fmt.Sprintf("%s=%s", k, v), task, vars)
+		env, err := e.ReplaceVariables(fmt.Sprintf("%s=%s", k, v), call)
 		if err != nil {
 			return nil, err
 		}
diff --git a/variable_handling.go b/variable_handling.go
@@ -56,8 +56,8 @@ func (e *Executor) handleDynamicVariableContent(value string) (string, error) {
 	return result, nil
 }
 
-func (e *Executor) getVariables(task string, vars Vars) (map[string]string, error) {
-	t := e.Tasks[task]
+func (e *Executor) getVariables(call Call) (map[string]string, error) {
+	t := e.Tasks[call.Task]
 
 	localVariables := make(map[string]string)
 	for key, value := range t.Vars {
@@ -79,8 +79,8 @@ func (e *Executor) getVariables(task string, vars Vars) (map[string]string, erro
 	for key, value := range getEnvironmentVariables() {
 		localVariables[key] = value
 	}
-	if vars != nil {
-		for k, v := range vars {
+	if call.Vars != nil {
+		for k, v := range call.Vars {
 			val, err := e.handleDynamicVariableContent(v)
 			if err != nil {
 				return nil, err
@@ -120,11 +120,11 @@ func init() {
 }
 
 // ReplaceSliceVariables writes vars into initial string slice
-func (e *Executor) ReplaceSliceVariables(initials []string, task string, vars Vars) ([]string, error) {
+func (e *Executor) ReplaceSliceVariables(initials []string, call Call) ([]string, error) {
 	result := make([]string, len(initials))
 	for i, s := range initials {
 		var err error
-		result[i], err = e.ReplaceVariables(s, task, vars)
+		result[i], err = e.ReplaceVariables(s, call)
 		if err != nil {
 			return nil, err
 		}
@@ -133,8 +133,8 @@ func (e *Executor) ReplaceSliceVariables(initials []string, task string, vars Va
 }
 
 // ReplaceVariables writes vars into initial string
-func (e *Executor) ReplaceVariables(initial, task string, vars Vars) (string, error) {
-	vars, err := e.getVariables(task, vars)
+func (e *Executor) ReplaceVariables(initial string, call Call) (string, error) {
+	vars, err := e.getVariables(call)
 	if err != nil {
 		return "", err
 	}
diff --git a/watch.go b/watch.go
@@ -15,7 +15,7 @@ func (e *Executor) watchTasks(args ...string) error {
 
 	// run tasks on init
 	for _, a := range args {
-		if err := e.RunTask(context.Background(), a, nil); err != nil {
+		if err := e.RunTask(context.Background(), Call{Task: a}); err != nil {
 			e.println(err)
 			break
 		}
@@ -41,7 +41,7 @@ loop:
 		select {
 		case <-watcher.Events:
 			for _, a := range args {
-				if err := e.RunTask(context.Background(), a, nil); err != nil {
+				if err := e.RunTask(context.Background(), Call{Task: a}); err != nil {
 					e.println(err)
 					continue loop
 				}

Original file line number	Diff line number	Diff line change
`@@ -66,3 +66,9 @@ func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {`
`66`	`66`	`}`
`67`	`67`	`return ErrCantUnmarshalDep`
`68`	`68`	`}`
	`69`	`+`
	`70`	`+// Call is the parameters to a task call`
	`71`	`+type Call struct {`
	`72`	`+ Task string`
	`73`	`+ Vars Vars`
	`74`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -98,61 +98,61 @@ func (e *Executor) Run(args ...string) error {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`for _, a := range args {`
`101`		`- if err := e.RunTask(context.Background(), a, nil); err != nil {`
	`101`	`+ if err := e.RunTask(context.Background(), Call{Task: a}); err != nil {`
`102`	`102`	`return err`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`return nil`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`// RunTask runs a task by its name`
`109`		`-func (e *Executor) RunTask(ctx context.Context, name string, vars Vars) error {`
`110`		`- t, ok := e.Tasks[name]`
	`109`	`+func (e *Executor) RunTask(ctx context.Context, call Call) error {`
	`110`	`+ t, ok := e.Tasks[call.Task]`
`111`	`111`	`if !ok {`
`112`		`- return &taskNotFoundError{name}`
	`112`	`+ return &taskNotFoundError{call.Task}`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`if atomic.AddInt32(&t.callCount, 1) >= MaximumTaskCall {`
`116`		`- return &MaximumTaskCallExceededError{task: name}`
	`116`	`+ return &MaximumTaskCallExceededError{task: call.Task}`
`117`	`117`	`}`
`118`	`118`
`119`		`- if err := e.runDeps(ctx, name, vars); err != nil {`
	`119`	`+ if err := e.runDeps(ctx, call); err != nil {`
`120`	`120`	`return err`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`if !e.Force {`
`124`		`- upToDate, err := e.isTaskUpToDate(ctx, name, vars)`
	`124`	`+ upToDate, err := e.isTaskUpToDate(ctx, call)`
`125`	`125`	`if err != nil {`
`126`	`126`	`return err`
`127`	`127`	`}`
`128`	`128`	`if upToDate {`
`129`		- e.printfln(`task: Task "%s" is up to date`, name)
	`129`	+ e.printfln(`task: Task "%s" is up to date`, call.Task)
`130`	`130`	`return nil`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`for i := range t.Cmds {`
`135`		`- if err := e.runCommand(ctx, name, i, vars); err != nil {`
`136`		`- return &taskRunError{name, err}`
	`135`	`+ if err := e.runCommand(ctx, call, i); err != nil {`
	`136`	`+ return &taskRunError{call.Task, err}`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`	`return nil`
`140`	`140`	`}`
`141`	`141`
`142`		`-func (e *Executor) runDeps(ctx context.Context, task string, vars Vars) error {`
	`142`	`+func (e *Executor) runDeps(ctx context.Context, call Call) error {`
`143`	`143`	`g, ctx := errgroup.WithContext(ctx)`
`144`		`- t := e.Tasks[task]`
	`144`	`+ t := e.Tasks[call.Task]`
`145`	`145`
`146`	`146`	`for _, d := range t.Deps {`
`147`	`147`	`d := d`
`148`	`148`
`149`	`149`	`g.Go(func() error {`
`150`		`- dep, err := e.ReplaceVariables(d.Task, task, vars)`
	`150`	`+ dep, err := e.ReplaceVariables(d.Task, call)`
`151`	`151`	`if err != nil {`
`152`	`152`	`return err`
`153`	`153`	`}`
`154`	`154`
`155`		`- if err = e.RunTask(ctx, dep, d.Vars); err != nil {`
	`155`	`+ if err = e.RunTask(ctx, Call{Task: dep, Vars: d.Vars}); err != nil {`
`156`	`156`	`return err`
`157`	`157`	`}`
`158`	`158`	`return nil`
`@@ -165,27 +165,27 @@ func (e *Executor) runDeps(ctx context.Context, task string, vars Vars) error {`
`165`	`165`	`return nil`
`166`	`166`	`}`
`167`	`167`
`168`		`-func (e *Executor) isTaskUpToDate(ctx context.Context, task string, vars Vars) (bool, error) {`
`169`		`- t := e.Tasks[task]`
	`168`	`+func (e *Executor) isTaskUpToDate(ctx context.Context, call Call) (bool, error) {`
	`169`	`+ t := e.Tasks[call.Task]`
`170`	`170`
`171`	`171`	`if len(t.Status) > 0 {`
`172`		`- return e.isUpToDateStatus(ctx, task, vars)`
	`172`	`+ return e.isUpToDateStatus(ctx, call)`
`173`	`173`	`}`
`174`		`- return e.isUpToDateTimestamp(ctx, task, vars)`
	`174`	`+ return e.isUpToDateTimestamp(ctx, call)`
`175`	`175`	`}`
`176`	`176`
`177`		`-func (e *Executor) isUpToDateStatus(ctx context.Context, task string, vars Vars) (bool, error) {`
`178`		`- t := e.Tasks[task]`
	`177`	`+func (e *Executor) isUpToDateStatus(ctx context.Context, call Call) (bool, error) {`
	`178`	`+ t := e.Tasks[call.Task]`
`179`	`179`
`180`		`- environ, err := e.getEnviron(task, vars)`
	`180`	`+ environ, err := e.getEnviron(call)`
`181`	`181`	`if err != nil {`
`182`	`182`	`return false, err`
`183`	`183`	`}`
`184`		`- dir, err := e.getTaskDir(task, vars)`
	`184`	`+ dir, err := e.getTaskDir(call)`
`185`	`185`	`if err != nil {`
`186`	`186`	`return false, err`
`187`	`187`	`}`
`188`		`- status, err := e.ReplaceSliceVariables(t.Status, task, vars)`
	`188`	`+ status, err := e.ReplaceSliceVariables(t.Status, call)`
`189`	`189`	`if err != nil {`
`190`	`190`	`return false, err`
`191`	`191`	`}`
`@@ -204,23 +204,23 @@ func (e *Executor) isUpToDateStatus(ctx context.Context, task string, vars Vars)`
`204`	`204`	`return true, nil`
`205`	`205`	`}`
`206`	`206`
`207`		`-func (e *Executor) isUpToDateTimestamp(ctx context.Context, task string, vars Vars) (bool, error) {`
`208`		`- t := e.Tasks[task]`
	`207`	`+func (e *Executor) isUpToDateTimestamp(ctx context.Context, call Call) (bool, error) {`
	`208`	`+ t := e.Tasks[call.Task]`
`209`	`209`
`210`	`210`	`if len(t.Sources) == 0 \|\| len(t.Generates) == 0 {`
`211`	`211`	`return false, nil`
`212`	`212`	`}`
`213`	`213`
`214`		`- dir, err := e.getTaskDir(task, vars)`
	`214`	`+ dir, err := e.getTaskDir(call)`
`215`	`215`	`if err != nil {`
`216`	`216`	`return false, err`
`217`	`217`	`}`
`218`	`218`
`219`		`- sources, err := e.ReplaceSliceVariables(t.Sources, task, vars)`
	`219`	`+ sources, err := e.ReplaceSliceVariables(t.Sources, call)`
`220`	`220`	`if err != nil {`
`221`	`221`	`return false, err`
`222`	`222`	`}`
`223`		`- generates, err := e.ReplaceSliceVariables(t.Generates, task, vars)`
	`223`	`+ generates, err := e.ReplaceSliceVariables(t.Generates, call)`
`224`	`224`	`if err != nil {`
`225`	`225`	`return false, err`
`226`	`226`	`}`
`@@ -238,33 +238,33 @@ func (e *Executor) isUpToDateTimestamp(ctx context.Context, task string, vars Va`
`238`	`238`	`return generatesMinTime.After(sourcesMaxTime), nil`
`239`	`239`	`}`
`240`	`240`
`241`		`-func (e *Executor) runCommand(ctx context.Context, task string, i int, vars Vars) error {`
`242`		`- t := e.Tasks[task]`
	`241`	`+func (e *Executor) runCommand(ctx context.Context, call Call, i int) error {`
	`242`	`+ t := e.Tasks[call.Task]`
`243`	`243`	`cmd := t.Cmds[i]`
`244`	`244`
`245`	`245`	`if cmd.Cmd == "" {`
`246`	`246`	`cmdVars := make(Vars, len(cmd.Vars))`
`247`	`247`	`for k, v := range cmd.Vars {`
`248`		`- v, err := e.ReplaceVariables(v, task, vars)`
	`248`	`+ v, err := e.ReplaceVariables(v, call)`
`249`	`249`	`if err != nil {`
`250`	`250`	`return err`
`251`	`251`	`}`
`252`	`252`	`cmdVars[k] = v`
`253`	`253`	`}`
`254`		`- return e.RunTask(ctx, cmd.Task, cmdVars)`
	`254`	`+ return e.RunTask(ctx, Call{Task: cmd.Task, Vars: cmdVars})`
`255`	`255`	`}`
`256`	`256`
`257`		`- c, err := e.ReplaceVariables(cmd.Cmd, task, vars)`
	`257`	`+ c, err := e.ReplaceVariables(cmd.Cmd, call)`
`258`	`258`	`if err != nil {`
`259`	`259`	`return err`
`260`	`260`	`}`
`261`	`261`
`262`		`- dir, err := e.getTaskDir(task, vars)`
	`262`	`+ dir, err := e.getTaskDir(call)`
`263`	`263`	`if err != nil {`
`264`	`264`	`return err`
`265`	`265`	`}`
`266`	`266`
`267`		`- envs, err := e.getEnviron(task, vars)`
	`267`	`+ envs, err := e.getEnviron(call)`
`268`	`268`	`if err != nil {`
`269`	`269`	`return err`
`270`	`270`	`}`
`@@ -294,23 +294,23 @@ func (e *Executor) runCommand(ctx context.Context, task string, i int, vars Vars`
`294`	`294`	`return nil`
`295`	`295`	`}`
`296`	`296`
`297`		`-func (e *Executor) getTaskDir(task string, vars Vars) (string, error) {`
`298`		`- t := e.Tasks[task]`
	`297`	`+func (e *Executor) getTaskDir(call Call) (string, error) {`
	`298`	`+ t := e.Tasks[call.Task]`
`299`	`299`
`300`		`- exeDir, err := e.ReplaceVariables(e.Dir, task, vars)`
	`300`	`+ exeDir, err := e.ReplaceVariables(e.Dir, call)`
`301`	`301`	`if err != nil {`
`302`	`302`	`return "", err`
`303`	`303`	`}`
`304`		`- taskDir, err := e.ReplaceVariables(t.Dir, task, vars)`
	`304`	`+ taskDir, err := e.ReplaceVariables(t.Dir, call)`
`305`	`305`	`if err != nil {`
`306`	`306`	`return "", err`
`307`	`307`	`}`
`308`	`308`
`309`	`309`	`return filepath.Join(exeDir, taskDir), nil`
`310`	`310`	`}`
`311`	`311`
`312`		`-func (e *Executor) getEnviron(task string, vars Vars) ([]string, error) {`
`313`		`- t := e.Tasks[task]`
	`312`	`+func (e *Executor) getEnviron(call Call) ([]string, error) {`
	`313`	`+ t := e.Tasks[call.Task]`
`314`	`314`
`315`	`315`	`if t.Env == nil {`
`316`	`316`	`return nil, nil`
`@@ -319,7 +319,7 @@ func (e *Executor) getEnviron(task string, vars Vars) ([]string, error) {`
`319`	`319`	`envs := os.Environ()`
`320`	`320`
`321`	`321`	`for k, v := range t.Env {`
`322`		`- env, err := e.ReplaceVariables(fmt.Sprintf("%s=%s", k, v), task, vars)`
	`322`	`+ env, err := e.ReplaceVariables(fmt.Sprintf("%s=%s", k, v), call)`
`323`	`323`	`if err != nil {`
`324`	`324`	`return nil, err`
`325`	`325`	`}`