Move all structs related to Taskfile to its own package

internal/taskfile/call.go

@@ -0,0 +1,7 @@
+package taskfile
+
+// Call is the parameters to a task call
+type Call struct {
+	Task string
+	Vars Vars
+}

internal/taskfile/cmd.go

@@ -0,0 +1,78 @@
+package taskfile
+
+import (
+	"errors"
+	"strings"
+)
+
+// Cmd is a task command
+type Cmd struct {
+	Cmd    string
+	Silent bool
+	Task   string
+	Vars   Vars
+}
+
+// Dep is a task dependency
+type Dep struct {
+	Task string
+	Vars Vars
+}
+
+var (
+	// ErrCantUnmarshalCmd is returned for invalid command YAML
+	ErrCantUnmarshalCmd = errors.New("task: can't unmarshal cmd value")
+	// ErrCantUnmarshalDep is returned for invalid dependency YAML
+	ErrCantUnmarshalDep = errors.New("task: can't unmarshal dep value")
+)
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var cmd string
+	if err := unmarshal(&cmd); err == nil {
+		if strings.HasPrefix(cmd, "^") {
+			c.Task = strings.TrimPrefix(cmd, "^")
+		} else {
+			c.Cmd = cmd
+		}
+		return nil
+	}
+	var cmdStruct struct {
+		Cmd    string
+		Silent bool
+	}
+	if err := unmarshal(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
+		c.Cmd = cmdStruct.Cmd
+		c.Silent = cmdStruct.Silent
+		return nil
+	}
+	var taskCall struct {
+		Task string
+		Vars Vars
+	}
+	if err := unmarshal(&taskCall); err == nil {
+		c.Task = taskCall.Task
+		c.Vars = taskCall.Vars
+		return nil
+	}
+	return ErrCantUnmarshalCmd
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var task string
+	if err := unmarshal(&task); err == nil {
+		d.Task = task
+		return nil
+	}
+	var taskCall struct {
+		Task string
+		Vars Vars
+	}
+	if err := unmarshal(&taskCall); err == nil {
+		d.Task = taskCall.Task
+		d.Vars = taskCall.Vars
+		return nil
+	}
+	return ErrCantUnmarshalDep
+}

internal/taskfile/task.go

@@ -0,0 +1,20 @@
+package taskfile
+
+// Tasks representas a group of tasks
+type Tasks map[string]*Task
+
+// Task represents a task
+type Task struct {
+	Task      string
+	Cmds      []*Cmd
+	Deps      []*Dep
+	Desc      string
+	Sources   []string
+	Generates []string
+	Status    []string
+	Dir       string
+	Vars      Vars
+	Env       Vars
+	Silent    bool
+	Method    string
+}

internal/taskfile/taskfile.go

@@ -0,0 +1,26 @@
+package taskfile
+
+// Taskfile represents a Taskfile.yml
+type Taskfile struct {
+	// TODO: version is still not used
+	Version int
+	Tasks   Tasks
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface
+func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	if err := unmarshal(&tf.Tasks); err == nil {
+		return nil
+	}
+
+	var taskfile struct {
+		Version int
+		Tasks   Tasks
+	}
+	if err := unmarshal(&taskfile); err != nil {
+		return err
+	}
+	tf.Version = taskfile.Version
+	tf.Tasks = taskfile.Tasks
+	return nil
+}

internal/taskfile/taskfile_test.go

@@ -0,0 +1,60 @@
+package taskfile_test
+
+import (
+	"testing"
+
+	"github.com/go-task/task/internal/taskfile"
+
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v2"
+)
+
+func TestCmdParse(t *testing.T) {
+	const (
+		yamlCmd      = `echo "a string command"`
+		yamlDep      = `"task-name"`
+		yamlTaskCall = `
+task: another-task
+vars:
+  PARAM1: VALUE1
+  PARAM2: VALUE2
+`
+	)
+	tests := []struct {
+		content  string
+		v        interface{}
+		expected interface{}
+	}{
+		{
+			yamlCmd,
+			&taskfile.Cmd{},
+			&taskfile.Cmd{Cmd: `echo "a string command"`},
+		},
+		{
+			yamlTaskCall,
+			&taskfile.Cmd{},
+			&taskfile.Cmd{Task: "another-task", Vars: taskfile.Vars{
+				"PARAM1": taskfile.Var{Static: "VALUE1"},
+				"PARAM2": taskfile.Var{Static: "VALUE2"},
+			}},
+		},
+		{
+			yamlDep,
+			&taskfile.Dep{},
+			&taskfile.Dep{Task: "task-name"},
+		},
+		{
+			yamlTaskCall,
+			&taskfile.Dep{},
+			&taskfile.Dep{Task: "another-task", Vars: taskfile.Vars{
+				"PARAM1": taskfile.Var{Static: "VALUE1"},
+				"PARAM2": taskfile.Var{Static: "VALUE2"},
+			}},
+		},
+	}
+	for _, test := range tests {
+		err := yaml.Unmarshal([]byte(test.content), test.v)
+		assert.NoError(t, err)
+		assert.Equal(t, test.expected, test.v)
+	}
+}

internal/taskfile/var.go

@@ -0,0 +1,58 @@
+package taskfile
+
+import (
+	"errors"
+	"strings"
+)
+
+var (
+	// ErrCantUnmarshalVar is returned for invalid var YAML.
+	ErrCantUnmarshalVar = errors.New("task: can't unmarshal var value")
+)
+
+// Vars is a string[string] variables map.
+type Vars map[string]Var
+
+// ToStringMap converts Vars to a string map containing only the static
+// variables
+func (vs Vars) ToStringMap() (m map[string]string) {
+	m = make(map[string]string, len(vs))
+	for k, v := range vs {
+		if v.Sh != "" {
+			// Dynamic variable is not yet resolved; trigger
+			// <no value> to be used in templates.
+			continue
+		}
+		m[k] = v.Static
+	}
+	return
+}
+
+// Var represents either a static or dynamic variable.
+type Var struct {
+	Static string
+	Sh     string
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface.
+func (v *Var) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var str string
+	if err := unmarshal(&str); err == nil {
+		if strings.HasPrefix(str, "$") {
+			v.Sh = strings.TrimPrefix(str, "$")
+		} else {
+			v.Static = str
+		}
+		return nil
+	}
+
+	var sh struct {
+		Sh string
+	}
+	if err := unmarshal(&sh); err == nil {
+		v.Sh = sh.Sh
+		return nil
+	}
+
+	return ErrCantUnmarshalVar
+}