refactor: Create executor struct to get rid of global variables

Maybe eventually help on #17

Author: andreynering

cmd/task/task.go

@@ -2,13 +2,16 @@ package main
 
 import (
 	"fmt"
+	"log"
 
 	"github.com/go-task/task"
 
 	"github.com/spf13/pflag"
 )
 
 func main() {
+	log.SetFlags(0)
+
 	pflag.Usage = func() {
 		fmt.Println(`task [target1 target2 ...]: Runs commands under targets like make.
 
@@ -25,9 +28,40 @@ hello:
 `)
 		pflag.PrintDefaults()
 	}
-	pflag.BoolVarP(&task.Init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
-	pflag.BoolVarP(&task.Force, "force", "f", false, "forces execution even when the task is up-to-date")
-	pflag.BoolVarP(&task.Watch, "watch", "w", false, "enables watch of the given task")
+
+	var (
+		init  bool
+		force bool
+		watch bool
+	)
+
+	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
+	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
+	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
 	pflag.Parse()
-	task.Run()
+
+	if init {
+		if err := task.InitTaskfile(); err != nil {
+			log.Fatal(err)
+		}
+		return
+	}
+
+	e := task.Executor{
+		Force: force,
+		Watch: watch,
+	}
+	if err := e.ReadTaskfile(); err != nil {
+		log.Fatal(err)
+	}
+
+	args := pflag.Args()
+	if len(args) == 0 {
+		log.Println("task: No argument given, trying default task")
+		args = []string{"default"}
+	}
+
+	if err := e.Run(args...); err != nil {
+		log.Fatal(err)
+	}
 }

cyclic.go

@@ -1,8 +1,8 @@
 package task
 
 // HasCyclicDep checks if a task tree has any cyclic dependency
-func HasCyclicDep(m map[string]*Task) bool {
-	visits := make(map[string]struct{}, len(m))
+func (e *Executor) HasCyclicDep() bool {
+	visits := make(map[string]struct{}, len(e.Tasks))
 
 	var checkCyclicDep func(string, *Task) bool
 	checkCyclicDep = func(name string, t *Task) bool {
@@ -13,14 +13,14 @@ func HasCyclicDep(m map[string]*Task) bool {
 		defer delete(visits, name)
 
 		for _, d := range t.Deps {
-			if !checkCyclicDep(d, m[d]) {
+			if !checkCyclicDep(d, e.Tasks[d]) {
 				return false
 			}
 		}
 		return true
 	}
 
-	for k, v := range m {
+	for k, v := range e.Tasks {
 		if !checkCyclicDep(k, v) {
 			return true
 		}

cyclic_test.go

@@ -7,30 +7,34 @@ import (
 )
 
 func TestCyclicDepCheck(t *testing.T) {
-	isCyclic := map[string]*task.Task{
-		"task-a": &task.Task{
-			Deps: []string{"task-b"},
-		},
-		"task-b": &task.Task{
-			Deps: []string{"task-a"},
+	isCyclic := &task.Executor{
+		Tasks: map[string]*task.Task{
+			"task-a": &task.Task{
+				Deps: []string{"task-b"},
+			},
+			"task-b": &task.Task{
+				Deps: []string{"task-a"},
+			},
 		},
 	}
 
-	if !task.HasCyclicDep(isCyclic) {
+	if !isCyclic.HasCyclicDep() {
 		t.Error("Task should be cyclic")
 	}
 
-	isNotCyclic := map[string]*task.Task{
-		"task-a": &task.Task{
-			Deps: []string{"task-c"},
-		},
-		"task-b": &task.Task{
-			Deps: []string{"task-c"},
+	isNotCyclic := &task.Executor{
+		Tasks: map[string]*task.Task{
+			"task-a": &task.Task{
+				Deps: []string{"task-c"},
+			},
+			"task-b": &task.Task{
+				Deps: []string{"task-c"},
+			},
+			"task-c": &task.Task{},
 		},
-		"task-c": &task.Task{},
 	}
 
-	if task.HasCyclicDep(isNotCyclic) {
+	if isNotCyclic.HasCyclicDep() {
 		t.Error("Task should not be cyclic")
 	}
 }

errors.go

@@ -1,9 +1,17 @@
 package task
 
 import (
+	"errors"
 	"fmt"
 )
 
+var (
+	// ErrCyclicDependencyDetected is returned when a cyclic dependency was found in the Taskfile
+	ErrCyclicDependencyDetected = errors.New("task: cyclic dependency detected")
+	// ErrTaskfileAlreadyExists is returned on creating a Taskfile if one already exists
+	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
+)
+
 type taskFileNotFound struct {
 	taskFile string
 }

help.go

@@ -7,8 +7,8 @@ import (
 	"text/tabwriter"
 )
 
-func printExistingTasksHelp() {
-	tasks := tasksWithDesc()
+func (e *Executor) printExistingTasksHelp() {
+	tasks := e.tasksWithDesc()
 	if len(tasks) == 0 {
 		return
 	}
@@ -17,13 +17,13 @@ func printExistingTasksHelp() {
 	// Format in tab-separated columns with a tab stop of 8.
 	w := tabwriter.NewWriter(os.Stdout, 0, 8, 0, '\t', 0)
 	for _, task := range tasks {
-		fmt.Fprintln(w, fmt.Sprintf("- %s:\t%s", task, Tasks[task].Desc))
+		fmt.Fprintln(w, fmt.Sprintf("- %s:\t%s", task, e.Tasks[task].Desc))
 	}
 	w.Flush()
 }
 
-func tasksWithDesc() (tasks []string) {
-	for name, task := range Tasks {
+func (e *Executor) tasksWithDesc() (tasks []string) {
+	for name, task := range e.Tasks {
 		if task.Desc != "" {
 			tasks = append(tasks, name)
 		}

init.go

@@ -13,17 +13,17 @@ default:
     - echo "Hello, World!"
 `
 
-func initTaskfile() {
+// InitTaskfile Taskfile creates a new Taskfile
+func InitTaskfile() error {
 	for _, f := range []string{"Taskfile.yml", "Taskfile.toml", "Taskfile.json"} {
 		if _, err := os.Stat(f); err == nil {
-			log.Printf("A Taskfile already exists")
-			os.Exit(1)
-			return
+			return ErrTaskfileAlreadyExists
 		}
 	}
 
 	if err := ioutil.WriteFile("Taskfile.yml", []byte(defaultTaskfile), 0666); err != nil {
-		log.Fatalf("%v", err)
+		return err
 	}
 	log.Printf("Taskfile.yml created in the current directory")
+	return nil
 }

read_taskfile.go

@@ -11,27 +11,30 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
-func readTaskfile() (map[string]*Task, error) {
-	initialTasks, err := readTaskfileData(TaskFilePath)
+// ReadTaskfile parses Taskfile from the disk
+func (e *Executor) ReadTaskfile() error {
+	var err error
+	e.Tasks, err = e.readTaskfileData(TaskFilePath)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	mergeTasks, err := readTaskfileData(fmt.Sprintf("%s_%s", TaskFilePath, runtime.GOOS))
+
+	osTasks, err := e.readTaskfileData(fmt.Sprintf("%s_%s", TaskFilePath, runtime.GOOS))
 	if err != nil {
 		switch err.(type) {
-		default:
-			return nil, err
 		case taskFileNotFound:
-			return initialTasks, nil
+			return nil
+		default:
+			return err
 		}
 	}
-	if err := mergo.MapWithOverwrite(&initialTasks, mergeTasks); err != nil {
-		return nil, err
+	if err := mergo.MapWithOverwrite(&e.Tasks, osTasks); err != nil {
+		return err
 	}
-	return initialTasks, nil
+	return nil
 }
 
-func readTaskfileData(path string) (tasks map[string]*Task, err error) {
+func (e *Executor) readTaskfileData(path string) (tasks map[string]*Task, err error) {
 	if b, err := ioutil.ReadFile(path + ".yml"); err == nil {
 		return tasks, yaml.Unmarshal(b, &tasks)
 	}