go/task
go/task
1
0
Fork 0
mirror of https://github.com/go-task/task.git synced 2025-06-02 23:27:37 +02:00
Code Issues Releases Activity

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

Browse Source
This commit is contained in:
Andrey Nering 2017-07-08 14:34:17 -03:00
parent a1140aa62f
commit 7a7f66dfdc
4 changed files with 58 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
command.go
View File

@ -66,3 +66,9 @@ func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {
} }
return ErrCantUnmarshalDep return ErrCantUnmarshalDep
} }
// Call is the parameters to a task call
type Call struct {
Task string
Vars Vars
}

84
task.go
View File

@ -98,7 +98,7 @@ func (e *Executor) Run(args ...string) error {
} }
for _, a := range args { 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 err
} }
} }
@ -106,53 +106,53 @@ func (e *Executor) Run(args ...string) error {
} }
// RunTask runs a task by its name // RunTask runs a task by its name
func (e *Executor) RunTask(ctx context.Context, name string, vars Vars) error { func (e *Executor) RunTask(ctx context.Context, call Call) error {
t, ok := e.Tasks[name] t, ok := e.Tasks[call.Task]
if !ok { if !ok {
return &taskNotFoundError{name} return &taskNotFoundError{call.Task}
} }
if atomic.AddInt32(&t.callCount, 1) >= MaximumTaskCall { 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 return err
} }
if !e.Force { if !e.Force {
upToDate, err := e.isTaskUpToDate(ctx, name, vars) upToDate, err := e.isTaskUpToDate(ctx, call)
if err != nil { if err != nil {
return err return err
} }
if upToDate { 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 return nil
} }
} }
for i := range t.Cmds { for i := range t.Cmds {
if err := e.runCommand(ctx, name, i, vars); err != nil { if err := e.runCommand(ctx, call, i); err != nil {
return &taskRunError{name, err} return &taskRunError{call.Task, err}
} }
} }
return nil 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) g, ctx := errgroup.WithContext(ctx)
t := e.Tasks[task] t := e.Tasks[call.Task]
for _, d := range t.Deps { for _, d := range t.Deps {
d := d d := d
g.Go(func() error { g.Go(func() error {
dep, err := e.ReplaceVariables(d.Task, task, vars) dep, err := e.ReplaceVariables(d.Task, call)
if err != nil { if err != nil {
return err 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 err
} }
return nil return nil
@ -165,27 +165,27 @@ func (e *Executor) runDeps(ctx context.Context, task string, vars Vars) error {
return nil return nil
} }
func (e *Executor) isTaskUpToDate(ctx context.Context, task string, vars Vars) (bool, error) { func (e *Executor) isTaskUpToDate(ctx context.Context, call Call) (bool, error) {
t := e.Tasks[task] t := e.Tasks[call.Task]
if len(t.Status) > 0 { 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) { func (e *Executor) isUpToDateStatus(ctx context.Context, call Call) (bool, error) {
t := e.Tasks[task] t := e.Tasks[call.Task]
environ, err := e.getEnviron(task, vars) environ, err := e.getEnviron(call)
if err != nil { if err != nil {
return false, err return false, err
} }
dir, err := e.getTaskDir(task, vars) dir, err := e.getTaskDir(call)
if err != nil { if err != nil {
return false, err return false, err
} }
status, err := e.ReplaceSliceVariables(t.Status, task, vars) status, err := e.ReplaceSliceVariables(t.Status, call)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -204,23 +204,23 @@ func (e *Executor) isUpToDateStatus(ctx context.Context, task string, vars Vars)
return true, nil return true, nil
} }
func (e *Executor) isUpToDateTimestamp(ctx context.Context, task string, vars Vars) (bool, error) { func (e *Executor) isUpToDateTimestamp(ctx context.Context, call Call) (bool, error) {
t := e.Tasks[task] t := e.Tasks[call.Task]
if len(t.Sources) == 0 || len(t.Generates) == 0 { if len(t.Sources) == 0 || len(t.Generates) == 0 {
return false, nil return false, nil
} }
dir, err := e.getTaskDir(task, vars) dir, err := e.getTaskDir(call)
if err != nil { if err != nil {
return false, err return false, err
} }
sources, err := e.ReplaceSliceVariables(t.Sources, task, vars) sources, err := e.ReplaceSliceVariables(t.Sources, call)
if err != nil { if err != nil {
return false, err return false, err
} }
generates, err := e.ReplaceSliceVariables(t.Generates, task, vars) generates, err := e.ReplaceSliceVariables(t.Generates, call)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -238,33 +238,33 @@ func (e *Executor) isUpToDateTimestamp(ctx context.Context, task string, vars Va
return generatesMinTime.After(sourcesMaxTime), nil return generatesMinTime.After(sourcesMaxTime), nil
} }
func (e *Executor) runCommand(ctx context.Context, task string, i int, vars Vars) error { func (e *Executor) runCommand(ctx context.Context, call Call, i int) error {
t := e.Tasks[task] t := e.Tasks[call.Task]
cmd := t.Cmds[i] cmd := t.Cmds[i]
if cmd.Cmd == "" { if cmd.Cmd == "" {
cmdVars := make(Vars, len(cmd.Vars)) cmdVars := make(Vars, len(cmd.Vars))
for k, v := range cmd.Vars { for k, v := range cmd.Vars {
v, err := e.ReplaceVariables(v, task, vars) v, err := e.ReplaceVariables(v, call)
if err != nil { if err != nil {
return err return err
} }
cmdVars[k] = v 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 { if err != nil {
return err return err
} }
dir, err := e.getTaskDir(task, vars) dir, err := e.getTaskDir(call)
if err != nil { if err != nil {
return err return err
} }
envs, err := e.getEnviron(task, vars) envs, err := e.getEnviron(call)
if err != nil { if err != nil {
return err return err
} }
@ -294,14 +294,14 @@ func (e *Executor) runCommand(ctx context.Context, task string, i int, vars Vars
return nil return nil
} }
func (e *Executor) getTaskDir(task string, vars Vars) (string, error) { func (e *Executor) getTaskDir(call Call) (string, error) {
t := e.Tasks[task] t := e.Tasks[call.Task]
exeDir, err := e.ReplaceVariables(e.Dir, task, vars) exeDir, err := e.ReplaceVariables(e.Dir, call)
if err != nil { if err != nil {
return "", err return "", err
} }
taskDir, err := e.ReplaceVariables(t.Dir, task, vars) taskDir, err := e.ReplaceVariables(t.Dir, call)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -309,8 +309,8 @@ func (e *Executor) getTaskDir(task string, vars Vars) (string, error) {
return filepath.Join(exeDir, taskDir), nil return filepath.Join(exeDir, taskDir), nil
} }
func (e *Executor) getEnviron(task string, vars Vars) ([]string, error) { func (e *Executor) getEnviron(call Call) ([]string, error) {
t := e.Tasks[task] t := e.Tasks[call.Task]
if t.Env == nil { if t.Env == nil {
return nil, nil return nil, nil
@ -319,7 +319,7 @@ func (e *Executor) getEnviron(task string, vars Vars) ([]string, error) {
envs := os.Environ() envs := os.Environ()
for k, v := range t.Env { 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 { if err != nil {
return nil, err return nil, err
} }

16
variable_handling.go
View File

@ -56,8 +56,8 @@ func (e *Executor) handleDynamicVariableContent(value string) (string, error) {
return result, nil return result, nil
} }
func (e *Executor) getVariables(task string, vars Vars) (map[string]string, error) { func (e *Executor) getVariables(call Call) (map[string]string, error) {
t := e.Tasks[task] t := e.Tasks[call.Task]
localVariables := make(map[string]string) localVariables := make(map[string]string)
for key, value := range t.Vars { 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() { for key, value := range getEnvironmentVariables() {
localVariables[key] = value localVariables[key] = value
} }
if vars != nil { if call.Vars != nil {
for k, v := range vars { for k, v := range call.Vars {
val, err := e.handleDynamicVariableContent(v) val, err := e.handleDynamicVariableContent(v)
if err != nil { if err != nil {
return nil, err return nil, err
@ -120,11 +120,11 @@ func init() {
} }
// ReplaceSliceVariables writes vars into initial string slice // 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)) result := make([]string, len(initials))
for i, s := range initials { for i, s := range initials {
var err error var err error
result[i], err = e.ReplaceVariables(s, task, vars) result[i], err = e.ReplaceVariables(s, call)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -133,8 +133,8 @@ func (e *Executor) ReplaceSliceVariables(initials []string, task string, vars Va
} }
// ReplaceVariables writes vars into initial string // ReplaceVariables writes vars into initial string
func (e *Executor) ReplaceVariables(initial, task string, vars Vars) (string, error) { func (e *Executor) ReplaceVariables(initial string, call Call) (string, error) {
vars, err := e.getVariables(task, vars) vars, err := e.getVariables(call)
if err != nil { if err != nil {
return "", err return "", err
} }

4
watch.go
View File

@ -15,7 +15,7 @@ func (e *Executor) watchTasks(args ...string) error {
// run tasks on init // run tasks on init
for _, a := range args { 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) e.println(err)
break break
} }
@ -41,7 +41,7 @@ loop:
select { select {
case <-watcher.Events: case <-watcher.Events:
for _, a := range args { 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) e.println(err)
continue loop continue loop
} }