feat: allowing use of parameters over config

Author: gnugomez

README.md

@@ -40,7 +40,7 @@ voyage deploy -config /path/to/config.json
 As an alternative to providing all arguments on the command line, you can use a JSON configuration file by specifying the `-config` flag.
 
 > [!NOTE]
-> When the `-config` flag is used, all other command-line arguments for the deploy command are ignored.
+> When the `-config` flag is used, values from the configuration file will be overridden by any command-line arguments that are provided.
 
 **Example `config.json`:**
 

command/parser.go

@@ -8,17 +8,57 @@ import (
 	"strings"
 )
 
+// Constants for default values and configuration
+const (
+	defaultLogLevel = "info"
+)
+
+// PrintUsageFunc represents a function that prints command usage information
 type PrintUsageFunc func()
 
+// missingParamsError represents an error when required parameters are missing
 type missingParamsError struct {
 	params []string
 }
 
+// Error implements the error interface for missingParamsError
 func (e *missingParamsError) Error() string {
+	if len(e.params) == 1 {
+		return fmt.Sprintf("missing required parameter: %s", e.params[0])
+	}
 	return fmt.Sprintf("missing required parameters: %s", strings.Join(e.params, ", "))
 }
 
+// deployCommandParametersParser parses command line arguments and configuration file
+// to create DeployCommandParameters for the deploy command.
+//
+// It supports both command-line flags and JSON configuration files, with command-line
+// flags taking precedence over configuration file values.
+//
+// Returns the parsed parameters, a usage function, and any error encountered.
 func deployCommandParametersParser(args []string) (DeployCommandParameters, PrintUsageFunc, error) {
+	fs := setupDeployFlags()
+
+	if err := fs.Parse(args); err != nil {
+		return DeployCommandParameters{}, fs.Usage, err
+	}
+
+	params, err := loadConfigFromFile(fs)
+	if err != nil {
+		return DeployCommandParameters{}, fs.Usage, err
+	}
+
+	params = overrideWithFlags(fs, params)
+
+	if err := validateParameters(params); err != nil {
+		return DeployCommandParameters{}, fs.Usage, err
+	}
+
+	return params, fs.Usage, nil
+}
+
+// setupDeployFlags creates and configures the flag set for deploy command
+func setupDeployFlags() *flag.FlagSet {
 	fs := flag.NewFlagSet("deploy", flag.ContinueOnError)
 	fs.Usage = func() {
 		fmt.Fprintf(fs.Output(), "Usage of %s:\n", fs.Name())
@@ -29,40 +69,75 @@ func deployCommandParametersParser(args []string) (DeployCommandParameters, Prin
 		fmt.Fprintf(fs.Output(), "  voyage deploy -config my-config.json\n")
 	}
 
-	configPath := fs.String("config", "", "path to a JSON configuration file")
-	repo := fs.String("r", "", "repository name")
-	var composePaths stringSlice
-	fs.Var(&composePaths, "c", "path to docker-compose.yml (can be specified multiple times)")
-	branch := fs.String("b", "", "branch name")
-	outPath := fs.String("o", "", "out path")
-	force := fs.Bool("f", false, "force deployment even if no changes detected")
-	logLevel := fs.String("l", "info", "log level (debug, info, error, fatal)")
+	fs.String("config", "", "path to a JSON configuration file")
+	fs.String("r", "", "repository name")
+	fs.Var(&stringSlice{}, "c", "path to docker-compose.yml (can be specified multiple times)")
+	fs.String("b", "", "branch name")
+	fs.String("o", "", "out path")
+	fs.Bool("f", false, "force deployment even if no changes detected")
+	fs.String("l", defaultLogLevel, "log level (debug, info, error, fatal)")
 
-	if err := fs.Parse(args); err != nil {
-		return DeployCommandParameters{}, fs.Usage, err
-	}
+	return fs
+}
 
+// loadConfigFromFile loads parameters from configuration file if provided
+func loadConfigFromFile(fs *flag.FlagSet) (DeployCommandParameters, error) {
 	params := DeployCommandParameters{}
+	configPath := fs.Lookup("config").Value.String()
 
-	if *configPath != "" {
-		file, err := os.ReadFile(*configPath)
+	if configPath != "" {
+		file, err := os.ReadFile(configPath)
 		if err != nil {
-			return DeployCommandParameters{}, fs.Usage, fmt.Errorf("error reading config file %s: %w", *configPath, err)
+			return params, fmt.Errorf("error reading config file %s: %w", configPath, err)
 		}
 		if err := json.Unmarshal(file, &params); err != nil {
-			return DeployCommandParameters{}, fs.Usage, fmt.Errorf("error parsing config file %s: %w", *configPath, err)
+			return params, fmt.Errorf("error parsing config file %s: %w", configPath, err)
+		}
+	}
+
+	return params, nil
+}
+
+// overrideWithFlags applies command-line flag values to override config file values
+func overrideWithFlags(fs *flag.FlagSet, params DeployCommandParameters) DeployCommandParameters {
+	// Override with command-line flags if they were provided
+	if repo := fs.Lookup("r").Value.String(); repo != "" {
+		params.Repo = repo
+	}
+
+	if composePathsFlag := fs.Lookup("c"); composePathsFlag != nil {
+		if composePaths, ok := composePathsFlag.Value.(*stringSlice); ok && len(*composePaths) > 0 {
+			params.RemoteComposePaths = []string(*composePaths)
 		}
-	} else {
-		params.Repo = *repo
-		params.RemoteComposePaths = composePaths
-		params.Branch = *branch
-		params.OutPath = *outPath
-		params.Force = *force
-		params.LogLevel = *logLevel
 	}
 
-	// Validate the final parameters
+	if branch := fs.Lookup("b").Value.String(); branch != "" {
+		params.Branch = branch
+	}
+
+	if outPath := fs.Lookup("o").Value.String(); outPath != "" {
+		params.OutPath = outPath
+	}
+
+	// Handle boolean flag - check if it was explicitly set
+	if forceFlag := fs.Lookup("f"); forceFlag.Value.String() == "true" {
+		params.Force = true
+	}
+
+	// Handle log level - always override if different from default
+	if logLevel := fs.Lookup("l").Value.String(); logLevel != defaultLogLevel {
+		params.LogLevel = logLevel
+	} else if params.LogLevel == "" {
+		params.LogLevel = defaultLogLevel
+	}
+
+	return params
+}
+
+// validateParameters validates that all required parameters are present
+func validateParameters(params DeployCommandParameters) error {
 	var missingParams []string
+
 	if params.Repo == "" {
 		missingParams = append(missingParams, "-r (repository)")
 	}
@@ -77,8 +152,8 @@ func deployCommandParametersParser(args []string) (DeployCommandParameters, Prin
 	}
 
 	if len(missingParams) > 0 {
-		return DeployCommandParameters{}, fs.Usage, &missingParamsError{params: missingParams}
+		return &missingParamsError{params: missingParams}
 	}
 
-	return params, fs.Usage, nil
+	return nil
 }

command/parser_test.go

@@ -79,6 +79,47 @@ func TestDeployCommandParametersParser(t *testing.T) {
 		}
 	})
 
+	t.Run(("Merges config file and flags, with flags taking precedence"), func(t *testing.T) {
+		tempDir := t.TempDir()
+		configPath := filepath.Join(tempDir, "config.json")
+		configContent := `{
+			"repo": "my-repo",
+			"branch": "main",
+			"outPath": "/tmp/voyage",
+			"remoteComposePaths": ["docker-compose.yml"],
+			"force": false,
+			"logLevel": "info"
+		}`
+
+		if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		args := []string{
+			"-config", configPath,
+			"-b", "feature-branch", // Override branch
+			"-f", // Override force to true
+		}
+
+		params, _, err := deployCommandParametersParser(args)
+		if err != nil {
+			t.Fatalf("Expected no error, but got %v", err)
+		}
+
+		if params.Repo != "my-repo" {
+			t.Errorf("Expected repo to be 'my-repo', got '%s'", params.Repo)
+		}
+		if params.Branch != "feature-branch" {
+			t.Errorf("Expected branch to be 'feature-branch', got '%s'", params.Branch)
+		}
+		if !params.Force {
+			t.Errorf("Expected force to be true, got false")
+		}
+		if params.LogLevel != "info" {
+			t.Errorf("Expected logLevel to be 'info', got '%s'", params.LogLevel)
+		}
+	})
+
 	t.Run("Returns error for non-existent config file", func(t *testing.T) {
 		args := []string{"-config", "/path/to/non-existent-config.json"}
 		_, _, err := deployCommandParametersParser(args)