Extract `func (c *CommandArgumentValidator) validate(args []strin…

cmd/alias.go

@@ -46,10 +46,10 @@ func (c *AliasCommand) Run(args []string) int {
 
 	args = c.flags.Args()
 
-	switch len(args) {
-	case 0:
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 0, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}

cmd/check.go

@@ -33,7 +33,10 @@ var Requirements = []trellis.Requirement{
 }
 
 func (c *CheckCommand) Run(args []string) int {
-	if len(args) > 0 {
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}

cmd/command_argument_validator.go

@@ -0,0 +1,27 @@
+package cmd
+
+import "fmt"
+
+type CommandArgumentValidator struct {
+	required int
+	optional int
+}
+
+func (c *CommandArgumentValidator) validate(args []string) (err error) {
+	argCount := len(args)
+	totalArgs := c.required + c.optional
+
+	expectedCount := fmt.Sprintf("exactly %d", c.required)
+	if (c.optional > 0) {
+		expectedCount = fmt.Sprintf("between %d and %d", c.required, totalArgs)
+	}
+
+	if argCount > totalArgs {
+		return fmt.Errorf("Error: too many arguments (expected %s, got %d)\n", expectedCount, argCount)
+	}
+	if argCount < c.required {
+		return fmt.Errorf("Error: missing arguments (expected %s, got %d)\n", expectedCount, argCount)
+	}
+
+	return nil
+}

cmd/command_argument_validator_test.go

@@ -0,0 +1,82 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCommandArgumentValidatorValidate(t *testing.T) {
+	cases := []struct {
+		name             string
+		args             []string
+		requiredArgCount int
+		optionalArgCount int
+		expectedMessage  string
+	}{
+		{
+			"valid_without_optional",
+			[]string{"a", "b", "c"},
+			3,
+			0,
+			"",
+		},
+		{
+			"valid_with_optional",
+			[]string{"a", "b", "c"},
+			1,
+			2,
+			"",
+		},
+		{
+			"missing_without_optional",
+			[]string{"a", "b", "c"},
+			4,
+			0,
+			"missing arguments (expected exactly 4, got 3)",
+		},
+		{
+			"missing_with_optional",
+			[]string{"a", "b", "c"},
+			4,
+			2,
+			"missing arguments (expected between 4 and 6, got 3)",
+		},
+		{
+			"too_many_without_optional",
+			[]string{"a", "b", "c"},
+			2,
+			0,
+			"too many arguments (expected exactly 2, got 3)",
+		},
+		{
+			"too_many_with_optional",
+			[]string{"a", "b", "c"},
+			1,
+			1,
+			"too many arguments (expected between 1 and 2, got 3)",
+		},
+	}
+
+	for _, tc := range cases {
+		validator := &CommandArgumentValidator{
+			required: tc.requiredArgCount,
+			optional: tc.optionalArgCount,
+		}
+
+		actual := validator.validate(tc.args)
+
+		if "" == tc.expectedMessage && actual != nil {
+			t.Errorf("expected result to be valid, got %s", actual)
+		}
+
+		if "" != tc.expectedMessage && actual == nil {
+			t.Errorf("expected result to be invalid, got nil")
+		}
+
+		if "" != tc.expectedMessage && actual != nil {
+			if !strings.Contains(actual.Error(), tc.expectedMessage) {
+				t.Errorf("expected error to contains %s, got %s", tc.expectedMessage, actual)
+			}
+		}
+	}
+}

cmd/deploy.go

@@ -36,28 +36,25 @@ func (c *DeployCommand) Run(args []string) int {
 		return 1
 	}
 
-	var environment string
-	var siteName string
-
 	if err := c.flags.Parse(args); err != nil {
 		return 1
 	}
 
 	args = c.flags.Args()
 
-	switch len(args) {
-	case 0:
+	commandArgumentValidator := &CommandArgumentValidator{required: 1, optional: 1}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
-	case 1:
-		environment = args[0]
-	case 2:
-		environment = args[0]
+	}
+
+	environment := args[0]
+
+	siteName := ""
+	if len(args) == 2 {
 		siteName = args[1]
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 2, got %d)\n", len(args)))
-		c.UI.Output(c.Help())
-		return 1
 	}
 
 	_, ok := c.Trellis.Environments[environment]

cmd/dot_env.go

@@ -20,19 +20,19 @@ func (c *DotEnvCommand) Run(args []string) int {
 		return 1
 	}
 
-	var environment string
-
-	switch len(args) {
-	case 0:
-		environment = "development"
-	case 1:
-		environment = args[0]
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 0 or 1, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 1}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}
 
+	environment := "development"
+	if len(args) == 1 {
+		environment = args[0]
+	}
+
 	_, ok := c.Trellis.Environments[environment]
 	if !ok {
 		c.UI.Error(fmt.Sprintf("Error: %s is not a valid environment", environment))

cmd/down.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"fmt"
 	"strings"
 
 	"trellis-cli/trellis"
@@ -20,10 +19,10 @@ func (c *DownCommand) Run(args []string) int {
 		return 1
 	}
 
-	switch len(args) {
-	case 0:
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 0, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}

cmd/droplet_create.go

@@ -57,26 +57,22 @@ func (c *DropletCreateCommand) Run(args []string) int {
 		return 1
 	}
 
-	var environment string
-
 	if err := c.flags.Parse(args); err != nil {
 		return 1
 	}
 
 	args = c.flags.Args()
 
-	switch len(args) {
-	case 0:
-		c.UI.Output(c.Help())
-		return 1
-	case 1:
-		environment = args[0]
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 1, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 1}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}
 
+	environment := args[0]
+
 	if environment == "development" {
 		c.UI.Error("create command only supports staging/production environments")
 		return 1

cmd/galaxy_install.go

@@ -20,8 +20,10 @@ func (c *GalaxyInstallCommand) Run(args []string) int {
 		return 1
 	}
 
-	if len(args) > 0 {
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 0, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}

cmd/info.go

@@ -19,6 +19,14 @@ func (c *InfoCommand) Run(args []string) int {
 		return 1
 	}
 
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
+		c.UI.Output(c.Help())
+		return 1
+	}
+
 	for name, config := range c.Trellis.Environments {
 		var siteNames []string
 

cmd/init.go

@@ -21,10 +21,10 @@ func (c *InitCommand) Run(args []string) int {
 		return 1
 	}
 
-	switch len(args) {
-	case 0:
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 0, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 0, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}

cmd/new.go

@@ -46,27 +46,22 @@ func (c *NewCommand) init() {
 }
 
 func (c *NewCommand) Run(args []string) int {
-	var path string
-
 	if err := c.flags.Parse(args); err != nil {
 		return 1
 	}
 
 	args = c.flags.Args()
 
-	switch len(args) {
-	case 0:
-		c.UI.Error("Error: missing PATH argument\n")
-		c.UI.Output(c.Help())
-		return 1
-	case 1:
-		path = args[0]
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 1, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 1, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}
 
+	path := args[0]
+
 	path, _ = filepath.Abs(path)
 	fi, statErr := os.Stat(path)
 

cmd/new_test.go

@@ -23,7 +23,7 @@ func TestNewRunValidations(t *testing.T) {
 			"no_args",
 			false,
 			nil,
-			"Error: missing PATH argument",
+			"Error: missing arguments (expected exactly 1, got 0)",
 			1,
 		},
 		{

cmd/provision.go

@@ -38,27 +38,22 @@ func (c *ProvisionCommand) Run(args []string) int {
 		return 1
 	}
 
-	var environment string
-
 	if err := c.flags.Parse(args); err != nil {
 		return 1
 	}
 
 	args = c.flags.Args()
 
-	switch len(args) {
-	case 0:
-		c.UI.Error("Error: missing ENVIRONMENT argument\n")
-		c.UI.Output(c.Help())
-		return 1
-	case 1:
-		environment = args[0]
-	default:
-		c.UI.Error(fmt.Sprintf("Error: too many arguments (expected 1, got %d)\n", len(args)))
+	commandArgumentValidator := &CommandArgumentValidator{required: 1, optional: 0}
+	commandArgumentErr := commandArgumentValidator.validate(args)
+	if commandArgumentErr != nil {
+		c.UI.Error(commandArgumentErr.Error())
 		c.UI.Output(c.Help())
 		return 1
 	}
 
+	environment := args[0]
+
 	_, ok := c.Trellis.Environments[environment]
 	if !ok {
 		c.UI.Error(fmt.Sprintf("Error: %s is not a valid environment", environment))

cmd/provision_test.go

@@ -31,7 +31,7 @@ func TestProvisionRunValidations(t *testing.T) {
 			"no_args",
 			true,
 			nil,
-			"Error: missing ENVIRONMENT argument",
+			"Error: missing arguments (expected exactly 1, got 0)",
 			1,
 		},
 		{