From 7a7f66dfdc949ea77de738d7e1ac70f3a79d52e6 Mon Sep 17 00:00:00 2001 From: Andrey Nering Date: Sat, 8 Jul 2017 14:34:17 -0300 Subject: [PATCH] refactor: join task and vars parameters in a single Call struct --- command.go | 6 ++++ task.go | 84 ++++++++++++++++++++++---------------------- variable_handling.go | 16 ++++----- watch.go | 4 +-- 4 files changed, 58 insertions(+), 52 deletions(-) diff --git a/command.go b/command.go index 4c6b19bd..3d369fd4 100644 --- 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 index 5a5725e1..31a0a9e9 100644 --- a/task.go +++ b/task.go @@ -98,7 +98,7 @@ 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 } } @@ -106,53 +106,53 @@ func (e *Executor) Run(args ...string) error { } // 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,14 +294,14 @@ 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 } @@ -309,8 +309,8 @@ func (e *Executor) getTaskDir(task string, vars Vars) (string, error) { 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 index cb53b0c0..cd5b06ff 100644 --- 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 index b58f8003..b7fd0923 100644 --- 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 }