Add support for 'platforms' in both task and command (#980)

taskfile/cmd.go

@@ -14,6 +14,7 @@ type Cmd struct {
 	Vars        *Vars
 	IgnoreError bool
 	Defer       bool
+	Platforms   []*Platform
 }
 
 // Dep is a task dependency
@@ -40,11 +41,13 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 			Cmd         string
 			Silent      bool
 			IgnoreError bool `yaml:"ignore_error"`
+			Platforms   []*Platform
 		}
 		if err := node.Decode(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
 			c.Cmd = cmdStruct.Cmd
 			c.Silent = cmdStruct.Silent
 			c.IgnoreError = cmdStruct.IgnoreError
+			c.Platforms = cmdStruct.Platforms
 			return nil
 		}
 

taskfile/platforms.go

@@ -0,0 +1,113 @@
+package taskfile
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+// Platform represents GOOS and GOARCH values
+type Platform struct {
+	OS   string
+	Arch string
+}
+
+// ParsePlatform takes a string representing an OS/Arch combination (or either on their own)
+// and parses it into the Platform struct. It returns an error if the input string is invalid.
+// Valid combinations for input: OS, Arch, OS/Arch
+func (p *Platform) ParsePlatform(input string) error {
+	// tidy up input
+	platformString := strings.ToLower(strings.TrimSpace(input))
+	splitValues := strings.Split(platformString, "/")
+	if len(splitValues) > 2 {
+		return fmt.Errorf("task: Invalid OS/Arch provided: %s", input)
+	}
+	err := p.parseOsOrArch(splitValues[0])
+	if err != nil {
+		return err
+	}
+	if len(splitValues) == 2 {
+		return p.parseArch(splitValues[1])
+	}
+	return nil
+}
+
+// supportedOSes is a list of supported OSes
+var supportedOSes = map[string]struct{}{
+	"windows": {},
+	"darwin":  {},
+	"linux":   {},
+	"freebsd": {},
+}
+
+func isSupportedOS(input string) bool {
+	_, exists := supportedOSes[input]
+	return exists
+}
+
+// supportedArchs is a list of supported architectures
+var supportedArchs = map[string]struct{}{
+	"amd64": {},
+	"arm64": {},
+	"386":   {},
+}
+
+func isSupportedArch(input string) bool {
+	_, exists := supportedArchs[input]
+	return exists
+}
+
+// MatchesCurrentPlatform returns true if the platform matches the current platform
+func (p *Platform) MatchesCurrentPlatform() bool {
+	return (p.OS == "" || p.OS == runtime.GOOS) &&
+		(p.Arch == "" || p.Arch == runtime.GOARCH)
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface.
+func (p *Platform) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var platform string
+		if err := node.Decode(&platform); err != nil {
+			return err
+		}
+		if err := p.ParsePlatform(platform); err != nil {
+			return err
+		}
+		return nil
+	}
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into platform", node.Line, node.ShortTag())
+}
+
+// parseOsOrArch will check if the given input is a valid OS or Arch value.
+// If so, it will store it. If not, an error is returned
+func (p *Platform) parseOsOrArch(osOrArch string) error {
+	if osOrArch == "" {
+		return fmt.Errorf("task: Blank OS/Arch value provided")
+	}
+	if isSupportedOS(osOrArch) {
+		p.OS = osOrArch
+		return nil
+	}
+	if isSupportedArch(osOrArch) {
+		p.Arch = osOrArch
+		return nil
+	}
+	return fmt.Errorf("task: Invalid OS/Arch value provided (%s)", osOrArch)
+}
+func (p *Platform) parseArch(arch string) error {
+	if arch == "" {
+		return fmt.Errorf("task: Blank Arch value provided")
+	}
+	if p.Arch != "" {
+		return fmt.Errorf("task: Multiple Arch values provided")
+	}
+	if isSupportedArch(arch) {
+		p.Arch = arch
+		return nil
+	}
+	return fmt.Errorf("task: Invalid Arch value provided (%s)", arch)
+}

taskfile/task.go

@@ -36,6 +36,7 @@ type Task struct {
 	IncludeVars          *Vars
 	IncludedTaskfileVars *Vars
 	IncludedTaskfile     *IncludedTaskfile
+	Platforms            []*Platform
 }
 
 func (t *Task) Name() string {
@@ -90,6 +91,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 			Prefix        string
 			IgnoreError   bool `yaml:"ignore_error"`
 			Run           string
+			Platforms     []*Platform
 		}
 		if err := node.Decode(&task); err != nil {
 			return err
@@ -115,6 +117,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 		t.Prefix = task.Prefix
 		t.IgnoreError = task.IgnoreError
 		t.Run = task.Run
+		t.Platforms = task.Platforms
 		return nil
 	}
 
@@ -150,6 +153,7 @@ func (t *Task) DeepCopy() *Task {
 		IncludeVars:          t.IncludeVars.DeepCopy(),
 		IncludedTaskfileVars: t.IncludedTaskfileVars.DeepCopy(),
 		IncludedTaskfile:     t.IncludedTaskfile.DeepCopy(),
+		Platforms:            deepCopySlice(t.Platforms),
 	}
 	return c
 }