113 lines
3.3 KiB
Go
113 lines
3.3 KiB
Go
package cmd
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
)
|
|
|
|
// Command represents a CLI command.
|
|
type Command struct {
|
|
Name string
|
|
Description string
|
|
FlagSet *flag.FlagSet
|
|
SubCommands map[string]*Command
|
|
Execute func(cmd *Command, args []string)
|
|
}
|
|
|
|
// RootCmd is now defined at the package level, making it accessible from other packages.
|
|
var RootCmd = NewCommand("backup", "Main entry point for backup utility", nil)
|
|
|
|
// NewCommand creates a new command instance.
|
|
func NewCommand(name, description string, execute func(cmd *Command, args []string)) *Command {
|
|
return &Command{
|
|
Name: name,
|
|
Description: description,
|
|
FlagSet: flag.NewFlagSet(name, flag.ExitOnError),
|
|
SubCommands: make(map[string]*Command),
|
|
Execute: execute,
|
|
}
|
|
}
|
|
|
|
// AddSubCommand adds a subcommand to a command.
|
|
func (c *Command) AddSubCommand(subCmd *Command) {
|
|
c.SubCommands[subCmd.Name] = subCmd
|
|
}
|
|
|
|
// FindSubCommand looks for a subcommand by name.
|
|
func (c *Command) FindSubCommand(name string) (*Command, bool) {
|
|
subCmd, found := c.SubCommands[name]
|
|
return subCmd, found
|
|
}
|
|
|
|
// ExecuteCommand executes the command with the provided arguments.
|
|
func ExecuteCommand(rootCmd *Command, args []string) error {
|
|
if len(args) < 1 {
|
|
fmt.Println("No command provided")
|
|
return nil
|
|
}
|
|
|
|
cmdName := args[0]
|
|
subArgs := args[1:]
|
|
|
|
cmd, found := rootCmd.FindSubCommand(cmdName)
|
|
if !found {
|
|
fmt.Printf("Unknown command: %s\n", cmdName)
|
|
return nil
|
|
}
|
|
|
|
// Look for sub-subcommands if applicable.
|
|
if len(subArgs) > 0 {
|
|
subCmdName := subArgs[0]
|
|
subCmd, found := cmd.FindSubCommand(subCmdName)
|
|
if found {
|
|
// Parse flags for sub-subcommands.
|
|
subCmd.FlagSet.Parse(subArgs[1:])
|
|
subCmd.Execute(subCmd, subCmd.FlagSet.Args())
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// Parse flags for direct subcommands.
|
|
cmd.FlagSet.Parse(subArgs)
|
|
cmd.Execute(cmd, cmd.FlagSet.Args())
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
configCmd := NewCommand("config", "Configuration management", nil)
|
|
|
|
editCmd := NewCommand("edit", "Edit a configuration option", func(cmd *Command, args []string) {
|
|
// Ensure the flag is parsed before trying to access it
|
|
cmd.FlagSet.Parse(args)
|
|
configOption := cmd.FlagSet.Lookup("config-option").Value.String()
|
|
if configOption == "" {
|
|
fmt.Println("No config option specified")
|
|
return
|
|
}
|
|
// The new value should be the first argument after the flags
|
|
if len(cmd.FlagSet.Args()) == 0 {
|
|
fmt.Println("No new value specified for the config option")
|
|
return
|
|
}
|
|
newValue := cmd.FlagSet.Arg(0)
|
|
if err := EditConfigOption(configOption, newValue); err != nil {
|
|
fmt.Println("Error editing config option:", err)
|
|
return
|
|
}
|
|
fmt.Println("Config option updated successfully")
|
|
})
|
|
editCmd.FlagSet.String("config-option", "", "The configuration option to edit")
|
|
|
|
openCmd := NewCommand("open", "Open the configuration in nano", func(cmd *Command, args []string) {
|
|
if err := OpenConfigInNano(); err != nil {
|
|
fmt.Println("Error opening config in nano:", err)
|
|
return
|
|
}
|
|
fmt.Println("Configuration opened in nano")
|
|
})
|
|
|
|
configCmd.AddSubCommand(editCmd)
|
|
configCmd.AddSubCommand(openCmd)
|
|
RootCmd.AddSubCommand(configCmd)
|
|
}
|