add headers and format support to all actions

commands/account.go

@@ -9,16 +9,15 @@ import (
 
 // Account creates the account commands heirarchy.
 func Account() *cobra.Command {
-	cmdAccount := &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "account",
 		Short: "account commands",
 		Long:  "account is used to access account commands",
 	}
 
-	cmdAccountGet := cmdBuilder(RunAccountGet, "get", "get account", writer, aliasOpt("g"))
-	cmdAccount.AddCommand(cmdAccountGet)
+	cmdBuilder(cmd, RunAccountGet, "get", "get account", writer, aliasOpt("g"))
 
-	return cmdAccount
+	return cmd
 }
 
 // RunAccountGet runs account get.

commands/actions.go

@@ -11,19 +11,17 @@ import (
 
 // Actions creates the action commands heirarchy.
 func Actions() *cobra.Command {
-	cmdActions := &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "action",
 		Short: "action commands",
 		Long:  "action is used to access action commands",
 	}
 
-	cmdActionGet := cmdBuilder(RunCmdActionGet, "get ACTIONID", "get action", writer, aliasOpt("g"))
-	cmdActions.AddCommand(cmdActionGet)
+	cmdBuilder(cmd, RunCmdActionGet, "get ACTIONID", "get action", writer, aliasOpt("g"))
 
-	cmdActionList := cmdBuilder(RunCmdActionList, "list", "list actions", writer, aliasOpt("ls"))
-	cmdActions.AddCommand(cmdActionList)
+	cmdBuilder(cmd, RunCmdActionList, "list", "list actions", writer, aliasOpt("ls"))
 
-	return cmdActions
+	return cmd
 }
 
 // RunCmdActionList run action list.

commands/auth.go

@@ -39,16 +39,15 @@ func (use *UnknownSchemeError) Error() string {
 
 // Auth creates auth commands for doit.
 func Auth() *cobra.Command {
-	cmdAuth := &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "auth",
 		Short: "auth commands",
 		Long:  "auth is used to access auth commands",
 	}
 
-	cmdAuthLogin := cmdBuilder(RunAuthLogin, "login", "login to DigitalOcean account", writer)
-	cmdAuth.AddCommand(cmdAuthLogin)
+	cmdBuilder(cmd, RunAuthLogin, "login", "login to DigitalOcean account", writer)
 
-	return cmdAuth
+	return cmd
 }
 
 // RunAuthLogin runs auth login. It communicates with doit-server to perform auth.

commands/doit.go

@@ -189,7 +189,7 @@ func aliasOpt(aliases ...string) cmdOption {
 	}
 }
 
-func cmdBuilder(cr cmdRunner, cliText, desc string, out io.Writer, options ...cmdOption) *cobra.Command {
+func cmdBuilder(parent *cobra.Command, cr cmdRunner, cliText, desc string, out io.Writer, options ...cmdOption) *cobra.Command {
 	c := &cobra.Command{
 		Use:   cliText,
 		Short: desc,
@@ -200,10 +200,17 @@ func cmdBuilder(cr cmdRunner, cliText, desc string, out io.Writer, options ...cm
 		},
 	}
 
+	if parent != nil {
+		parent.AddCommand(c)
+	}
+
 	for _, co := range options {
 		co(c)
 	}
 
+	addStringFlag(c, doit.ArgFormat, "", "Format")
+	addBoolFlag(c, doit.ArgNoHeader, false, "hide headers")
+
 	return c
 }
 

commands/domains.go

@@ -19,18 +19,14 @@ func Domain() *cobra.Command {
 		Long:  "domain is used to access domain commands",
 	}
 
-	cmdDomainCreate := cmdBuilder(RunDomainCreate, "create <domain>", "create domain", writer, aliasOpt("c"))
-	cmd.AddCommand(cmdDomainCreate)
+	cmdDomainCreate := cmdBuilder(cmd, RunDomainCreate, "create <domain>", "create domain", writer, aliasOpt("c"))
 	addStringFlag(cmdDomainCreate, doit.ArgIPAddress, "", "IP address", requiredOpt())
 
-	cmdDomainList := cmdBuilder(RunDomainList, "list", "list comains", writer, aliasOpt("ls"))
-	cmd.AddCommand(cmdDomainList)
+	cmdBuilder(cmd, RunDomainList, "list", "list comains", writer, aliasOpt("ls"))
 
-	cmdDomainGet := cmdBuilder(RunDomainGet, "get <domain>", "get domain", writer, aliasOpt("g"))
-	cmd.AddCommand(cmdDomainGet)
+	cmdBuilder(cmd, RunDomainGet, "get <domain>", "get domain", writer, aliasOpt("g"))
 
-	cmdDomainDelete := cmdBuilder(RunDomainDelete, "delete <domain>", "delete droplet", writer, aliasOpt("g"))
-	cmd.AddCommand(cmdDomainDelete)
+	cmdBuilder(cmd, RunDomainDelete, "delete <domain>", "delete droplet", writer, aliasOpt("g"))
 
 	cmdRecord := &cobra.Command{
 		Use:   "records",
@@ -39,24 +35,20 @@ func Domain() *cobra.Command {
 	}
 	cmd.AddCommand(cmdRecord)
 
-	cmdRecordList := cmdBuilder(RunRecordList, "list <domain>", "list records", writer, aliasOpt("ls"))
-	cmdRecord.AddCommand(cmdRecordList)
+	cmdRecordList := cmdBuilder(cmdRecord, RunRecordList, "list <domain>", "list records", writer, aliasOpt("ls"))
 	addStringFlag(cmdRecordList, doit.ArgDomainName, "", "Domain name")
 
-	cmdRecordCreate := cmdBuilder(RunRecordCreate, "create <domain>", "create record", writer, aliasOpt("c"))
-	cmdRecord.AddCommand(cmdRecordCreate)
+	cmdRecordCreate := cmdBuilder(cmdRecord, RunRecordCreate, "create <domain>", "create record", writer, aliasOpt("c"))
 	addStringFlag(cmdRecordCreate, doit.ArgRecordType, "", "Record type")
 	addStringFlag(cmdRecordCreate, doit.ArgRecordName, "", "Record name")
 	addStringFlag(cmdRecordCreate, doit.ArgRecordData, "", "Record data")
 	addIntFlag(cmdRecordCreate, doit.ArgRecordPriority, 0, "Record priority")
 	addIntFlag(cmdRecordCreate, doit.ArgRecordPort, 0, "Record port")
 	addIntFlag(cmdRecordCreate, doit.ArgRecordWeight, 0, "Record weight")
 
-	cmdRecordDelete := cmdBuilder(RunRecordDelete, "delete <domain> <record id...>", "delete record", writer, aliasOpt("d"))
-	cmdRecord.AddCommand(cmdRecordDelete)
+	cmdBuilder(cmdRecord, RunRecordDelete, "delete <domain> <record id...>", "delete record", writer, aliasOpt("d"))
 
-	cmdRecordUpdate := cmdBuilder(RunRecordUpdate, "update <domain>", "update record", writer, aliasOpt("u"))
-	cmdRecord.AddCommand(cmdRecordUpdate)
+	cmdRecordUpdate := cmdBuilder(cmdRecord, RunRecordUpdate, "update <domain>", "update record", writer, aliasOpt("u"))
 	addIntFlag(cmdRecordUpdate, doit.ArgRecordID, 0, "Record ID")
 	addStringFlag(cmdRecordUpdate, doit.ArgRecordType, "", "Record type")
 	addStringFlag(cmdRecordUpdate, doit.ArgRecordName, "", "Record name")

commands/droplet_actions.go

@@ -38,79 +38,62 @@ func DropletAction() *cobra.Command {
 		Long:    "droplet-action is used to access droplet action commands",
 	}
 
-	cmdDropletActionGet := cmdBuilder(RunDropletActionGet, "get", "get droplet action", writer, aliasOpt("g"))
-	cmd.AddCommand(cmdDropletActionGet)
+	cmdDropletActionGet := cmdBuilder(cmd, RunDropletActionGet, "get", "get droplet action", writer, aliasOpt("g"))
 	addIntFlag(cmdDropletActionGet, doit.ArgActionID, 0, "Action ID", requiredOpt())
 
-	cmdDropletActionDisableBackups := cmdBuilder(RunDropletActionDisableBackups,
+	cmdBuilder(cmd, RunDropletActionDisableBackups,
 		"disable-backups <droplet-id>", "disable backups", writer)
-	cmd.AddCommand(cmdDropletActionDisableBackups)
 
-	cmdDropletActionReboot := cmdBuilder(RunDropletActionReboot,
+	cmdBuilder(cmd, RunDropletActionReboot,
 		"reboot <droplet-id>", "reboot droplet", writer)
-	cmd.AddCommand(cmdDropletActionReboot)
 
-	cmdDropletActionPowerCycle := cmdBuilder(RunDropletActionPowerCycle,
+	cmdBuilder(cmd, RunDropletActionPowerCycle,
 		"power-cycle <droplet-id>", "power cycle droplet", writer)
-	cmd.AddCommand(cmdDropletActionPowerCycle)
 
-	cmdDropletActionShutdown := cmdBuilder(RunDropletActionShutdown,
+	cmdBuilder(cmd, RunDropletActionShutdown,
 		"shutdown <droplet-id>", "shutdown droplet", writer)
-	cmd.AddCommand(cmdDropletActionShutdown)
 
-	cmdDropletActionPowerOff := cmdBuilder(RunDropletActionPowerOff,
+	cmdBuilder(cmd, RunDropletActionPowerOff,
 		"power-off <droplet-id>", "power off droplet", writer)
-	cmd.AddCommand(cmdDropletActionPowerOff)
 
-	cmdDropletActionPowerOn := cmdBuilder(RunDropletActionPowerOn,
+	cmdBuilder(cmd, RunDropletActionPowerOn,
 		"power-on <droplet-id>", "power on droplet", writer)
-	cmd.AddCommand(cmdDropletActionPowerOn)
 
-	cmdDropletActionPasswordReset := cmdBuilder(RunDropletActionPasswordReset,
+	cmdBuilder(cmd, RunDropletActionPasswordReset,
 		"power-reset <droplet-id>", "power reset droplet", writer)
-	cmd.AddCommand(cmdDropletActionPasswordReset)
 
-	cmdDropletActionEnableIPv6 := cmdBuilder(RunDropletActionEnableIPv6,
+	cmdBuilder(cmd, RunDropletActionEnableIPv6,
 		"enable-ipv6 <droplet-id>", "enable ipv6", writer)
-	cmd.AddCommand(cmdDropletActionEnableIPv6)
 
-	cmdDropletActionEnablePrivateNetworking := cmdBuilder(RunDropletActionEnablePrivateNetworking,
+	cmdBuilder(cmd, RunDropletActionEnablePrivateNetworking,
 		"enable-private-networking <droplet-id>", "enable private networking", writer)
-	cmd.AddCommand(cmdDropletActionEnablePrivateNetworking)
 
-	cmdDropletActionUpgrade := cmdBuilder(RunDropletActionUpgrade,
+	cmdBuilder(cmd, RunDropletActionUpgrade,
 		"upgrade <droplet-id>", "upgrade droplet", writer)
-	cmd.AddCommand(cmdDropletActionUpgrade)
 
-	cmdDropletActionRestore := cmdBuilder(RunDropletActionRestore,
+	cmdDropletActionRestore := cmdBuilder(cmd, RunDropletActionRestore,
 		"restore <droplet-id>", "restore backup", writer)
-	cmd.AddCommand(cmdDropletActionRestore)
 	addIntFlag(cmdDropletActionRestore, doit.ArgImageID, 0, "Image ID", requiredOpt())
 
-	cmdDropletActionResize := cmdBuilder(RunDropletActionResize,
+	cmdDropletActionResize := cmdBuilder(cmd, RunDropletActionResize,
 		"resize <droplet-id>", "resize droplet", writer)
-	cmd.AddCommand(cmdDropletActionResize)
 	addIntFlag(cmdDropletActionResize, doit.ArgImageID, 0, "Image ID", requiredOpt())
 	addBoolFlag(cmdDropletActionResize, doit.ArgResizeDisk, false, "Resize disk")
 
-	cmdDropletActionRebuild := cmdBuilder(RunDropletActionRebuild,
+	cmdDropletActionRebuild := cmdBuilder(cmd, RunDropletActionRebuild,
 		"rebuild <droplet-id>", "rebuild droplet", writer)
-	cmd.AddCommand(cmdDropletActionRebuild)
 	addIntFlag(cmdDropletActionRebuild, doit.ArgImageID, 0, "Image ID", requiredOpt())
 
-	cmdDropletActionRename := cmdBuilder(RunDropletActionRename,
+	cmdDropletActionRename := cmdBuilder(cmd, RunDropletActionRename,
 		"rename <droplet-id>", "rename droplet", writer)
-	cmd.AddCommand(cmdDropletActionRename)
 	addStringFlag(cmdDropletActionRename, doit.ArgDropletName, "", "Droplet name", requiredOpt())
 
-	cmdDropletActionChangeKernel := cmdBuilder(RunDropletActionChangeKernel,
+	cmdDropletActionChangeKernel := cmdBuilder(cmd, RunDropletActionChangeKernel,
 		"change-kernel <droplet-id>", "change kernel", writer)
-	cmd.AddCommand(cmdDropletActionChangeKernel)
 	addIntFlag(cmdDropletActionChangeKernel, doit.ArgKernelID, 0, "Kernel ID", requiredOpt())
 
-	cmdDropletActionSnapshot := cmdBuilder(RunDropletActionSnapshot,
+	cmdDropletActionSnapshot := cmdBuilder(cmd, RunDropletActionSnapshot,
 		"snapshot <droplet-id>", "snapshot droplet", writer)
-	cmd.AddCommand(cmdDropletActionSnapshot)
 	addIntFlag(cmdDropletActionSnapshot, doit.ArgSnapshotName, 0, "Snapshot name", requiredOpt())
 
 	return cmd

commands/droplets.go

@@ -25,16 +25,14 @@ func Droplet() *cobra.Command {
 		Long:    "droplet is used to access droplet commands",
 	}
 
-	cmdDropletActions := cmdBuilder(RunDropletActions, "actions", "droplet actions", writer, aliasOpt("a"))
-	cmd.AddCommand(cmdDropletActions)
+	cmdDropletActions := cmdBuilder(cmd, RunDropletActions, "actions", "droplet actions", writer, aliasOpt("a"))
 	addIntFlag(cmdDropletActions, doit.ArgDropletID, 0, "Droplet ID")
 
-	cmdDropletBackups := cmdBuilder(RunDropletBackups, "backups", "droplet backups", writer, aliasOpt("b"))
-	cmd.AddCommand(cmdDropletBackups)
+	cmdDropletBackups := cmdBuilder(cmd, RunDropletBackups, "backups", "droplet backups", writer, aliasOpt("b"))
 	addIntFlag(cmdDropletBackups, doit.ArgDropletID, 0, "Droplet ID")
 
-	cmdDropletCreate := cmdBuilder(RunDropletCreate, "create NAME [NAME ...]", "create droplet", writer, aliasOpt("c"))
-	cmd.AddCommand(cmdDropletCreate)
+	cmdDropletCreate := cmdBuilder(cmd, RunDropletCreate, "create NAME [NAME ...]", "create droplet", writer,
+		aliasOpt("c"))
 	addStringSliceFlag(cmdDropletCreate, doit.ArgSSHKeys, []string{}, "SSH Keys or fingerprints")
 	addStringFlag(cmdDropletCreate, doit.ArgUserData, "", "User data")
 	addStringFlag(cmdDropletCreate, doit.ArgUserDataFile, "", "User data file")
@@ -46,27 +44,19 @@ func Droplet() *cobra.Command {
 	addBoolFlag(cmdDropletCreate, doit.ArgPrivateNetworking, false, "Private networking")
 	addStringFlag(cmdDropletCreate, doit.ArgImage, "", "Droplet image", requiredOpt())
 
-	cmdDropletDelete := cmdBuilder(RunDropletDelete, "delete ID [ID ...]", "delete droplet", writer, aliasOpt("d", "del"))
-	cmd.AddCommand(cmdDropletDelete)
+	cmdBuilder(cmd, RunDropletDelete, "delete ID [ID ...]", "delete droplet", writer, aliasOpt("d", "del"))
 
-	cmdDropletGet := cmdBuilder(RunDropletGet, "get", "get droplet", writer, aliasOpt("g"))
-	cmd.AddCommand(cmdDropletGet)
+	cmdBuilder(cmd, RunDropletGet, "get", "get droplet", writer, aliasOpt("g"))
 
-	cmdDropletKernels := cmdBuilder(RunDropletKernels, "kernels", "droplet kernels", writer, aliasOpt("k"))
-	cmd.AddCommand(cmdDropletKernels)
+	cmdDropletKernels := cmdBuilder(cmd, RunDropletKernels, "kernels", "droplet kernels", writer, aliasOpt("k"))
 	addIntFlag(cmdDropletKernels, doit.ArgDropletID, 0, "Droplet ID", requiredOpt())
 
-	cmdDropletList := cmdBuilder(RunDropletList, "list [REGEX]", "list droplets", writer, aliasOpt("ls"))
-	cmd.AddCommand(cmdDropletList)
-	addStringFlag(cmdDropletList, doit.ArgFormat, "", "Format")
-	addBoolFlag(cmdDropletList, doit.ArgNoHeader, false, "hide headers")
+	cmdBuilder(cmd, RunDropletList, "list [REGEX]", "list droplets", writer, aliasOpt("ls"))
 
-	cmdDropletNeighbors := cmdBuilder(RunDropletNeighbors, "neighbors", "droplet neighbors", writer, aliasOpt("n"))
-	cmd.AddCommand(cmdDropletNeighbors)
+	cmdDropletNeighbors := cmdBuilder(cmd, RunDropletNeighbors, "neighbors", "droplet neighbors", writer, aliasOpt("n"))
 	addIntFlag(cmdDropletNeighbors, doit.ArgDropletID, 0, "Droplet ID", requiredOpt())
 
-	cmdDropletSnapshots := cmdBuilder(RunDropletSnapshots, "snapshots", "snapshots", writer, aliasOpt("s"))
-	cmd.AddCommand(cmdDropletSnapshots)
+	cmdDropletSnapshots := cmdBuilder(cmd, RunDropletSnapshots, "snapshots", "snapshots", writer, aliasOpt("s"))
 	addIntFlag(cmdDropletSnapshots, doit.ArgDropletID, 0, "Droplet ID", requiredOpt())
 
 	return cmd

commands/floating_ip_actions.go

@@ -16,19 +16,16 @@ func FloatingIPAction() *cobra.Command {
 		Long:  "floating IP action commands",
 	}
 
-	cmdFloatingIPActionsGet := cmdBuilder(RunFloatingIPActionsGet,
+	cmdFloatingIPActionsGet := cmdBuilder(cmd, RunFloatingIPActionsGet,
 		"get <floating-ip>", "get floating-ip action", writer)
-	cmd.AddCommand(cmdFloatingIPActionsGet)
 	addIntFlag(cmdFloatingIPActionsGet, doit.ArgActionID, 0, "action id", requiredOpt())
 
-	cmdFloatingIPActionsAssign := cmdBuilder(RunFloatingIPActionsAssign,
+	cmdFloatingIPActionsAssign := cmdBuilder(cmd, RunFloatingIPActionsAssign,
 		"assign <floating-ip>", "assign a floating IP to a droplet", writer)
-	cmd.AddCommand(cmdFloatingIPActionsAssign)
 	addIntFlag(cmdFloatingIPActionsAssign, doit.ArgDropletID, 0, "ID of the droplet to assign the IP to", requiredOpt())
 
-	cmdFloatingIPActionsUnassign := cmdBuilder(RunFloatingIPActionsUnassign,
+	cmdBuilder(cmd, RunFloatingIPActionsUnassign,
 		"unassign <floating-ip>", "unassign a floating IP to a droplet", writer)
-	cmd.AddCommand(cmdFloatingIPActionsUnassign)
 
 	return cmd
 }

commands/floating_ips.go

@@ -18,19 +18,15 @@ func FloatingIP() *cobra.Command {
 		Aliases: []string{"fip"},
 	}
 
-	cmdFloatingIPCreate := cmdBuilder(RunFloatingIPCreate, "create", "create a floating IP", writer, aliasOpt("c"))
-	cmd.AddCommand(cmdFloatingIPCreate)
+	cmdFloatingIPCreate := cmdBuilder(cmd, RunFloatingIPCreate, "create", "create a floating IP", writer, aliasOpt("c"))
 	addStringFlag(cmdFloatingIPCreate, doit.ArgRegionSlug, "", "Region where to create the floating IP.", requiredOpt())
 	addIntFlag(cmdFloatingIPCreate, doit.ArgDropletID, 0, "ID of the droplet to assign the IP to. (Optional)")
 
-	cmdFloatingIPGet := cmdBuilder(RunFloatingIPGet, "get <floating-ip>", "get the details of a floating IP", writer, aliasOpt("g"))
-	cmd.AddCommand(cmdFloatingIPGet)
+	cmdBuilder(cmd, RunFloatingIPGet, "get <floating-ip>", "get the details of a floating IP", writer, aliasOpt("g"))
 
-	cmdFloatingIPDelete := cmdBuilder(RunFloatingIPDelete, "delete <floating-ip>", "delete a floating IP address", writer, aliasOpt("d"))
-	cmd.AddCommand(cmdFloatingIPDelete)
+	cmdBuilder(cmd, RunFloatingIPDelete, "delete <floating-ip>", "delete a floating IP address", writer, aliasOpt("d"))
 
-	cmdFloatingIPList := cmdBuilder(RunFloatingIPList, "list", "list all floating IP addresses", writer, aliasOpt("ls"))
-	cmd.AddCommand(cmdFloatingIPList)
+	cmdBuilder(cmd, RunFloatingIPList, "list", "list all floating IP addresses", writer, aliasOpt("ls"))
 
 	return cmd
 }

commands/image_actions.go

@@ -18,14 +18,12 @@ func ImageAction() *cobra.Command {
 		Long:  "image-action commands",
 	}
 
-	cmdImageActionsGet := cmdBuilder(RunImageActionsGet,
+	cmdImageActionsGet := cmdBuilder(cmd, RunImageActionsGet,
 		"get <image-id>", "get image action", writer)
-	cmd.AddCommand(cmdImageActionsGet)
 	addIntFlag(cmdImageActionsGet, doit.ArgActionID, 0, "action id", requiredOpt())
 
-	cmdImageActionsTransfer := cmdBuilder(RunImageActionsTransfer,
+	cmdImageActionsTransfer := cmdBuilder(cmd, RunImageActionsTransfer,
 		"transfer <image-id>", "transfer imagr", writer)
-	cmd.AddCommand(cmdImageActionsTransfer)
 	addStringFlag(cmdImageActionsTransfer, doit.ArgRegionSlug, "", "region", requiredOpt())
 
 	return cmd