Updated

Author: djthorpe

cmd/api/cmd.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"fmt"
+
 	"github.com/djthorpe/go-tablewriter"
 	"github.com/mutablelogic/go-client"
 )
@@ -24,11 +26,19 @@ type Fn struct {
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-func (c *Cmd) Get(match string) *Fn {
-	for _, fn := range c.Fn {
-		if fn.Name == match {
-			return &fn
-		}
+func (c *Cmd) Get(args []string) *Fn {
+	if len(args) == 0 {
+		return nil
 	}
+	fmt.Println("TODO: %q", args)
 	return nil
+	/*
+	   	for _, fn := range c.Fn {
+	   		if fn.Name == match {
+	   			return &fn
+	   		}
+	   	}
+
+	   return nil
+	*/
 }

cmd/api/flags.go

@@ -49,7 +49,7 @@ func NewFlags(name string) *Flags {
 	flags := new(Flags)
 	flags.FlagSet = flag.NewFlagSet(name, flag.ContinueOnError)
 	flags.names = make(map[string]*Value)
-	flags.FlagSet.Usage = flags.PrintUsage
+	flags.FlagSet.Usage = func() {}
 
 	// Register global flags
 	flags.Bool("", "debug", false, "Enable debug logging")
@@ -70,6 +70,9 @@ func (flags *Flags) Register(c Cmd) {
 func (flags *Flags) Parse(args []string) error {
 	// Parse command line
 	if err := flags.FlagSet.Parse(args); err != nil {
+		if err == flag.ErrHelp {
+			flags.PrintUsage()
+		}
 		return err
 	}
 
@@ -82,22 +85,24 @@ func (flags *Flags) Parse(args []string) error {
 	// Set client options
 	opts := []client.ClientOpt{}
 	if flags.GetBool("debug") {
-		verbose := flags.GetBool("verbose")
-		opts = append(opts, client.OptTrace(flags.Output(), verbose))
+		// Append debug option with optional verbose
+		opts = append(opts, client.OptTrace(flags.Output(), flags.GetBool("verbose")))
 	}
 
 	// Parse the commands
 	for _, cmd := range flags.cmds {
-		cmd.Parse(flags, opts...)
+		if err := cmd.Parse(flags, opts...); err != nil {
+			return fmt.Errorf("%v: %w", cmd.Name, err)
+		}
 	}
 
 	// Return success
 	return nil
 }
 
-// GetCommand returns a command set from a name, or nil if the command set does
+// GetCommandSet returns a command set from a name, or nil if the command set does
 // not exist
-func (flags *Flags) GetCommand(name string) *Cmd {
+func (flags *Flags) GetCommandSet(name string) *Cmd {
 	for _, cmd := range flags.cmds {
 		if cmd.Name == name {
 			return &cmd
@@ -149,38 +154,65 @@ func (flags *Flags) PrintVersion() {
 func (flags *Flags) PrintUsage() {
 	w := flags.Output()
 	if flags.NArg() == 1 {
-		cmd := flags.GetCommand(flags.Arg(0))
-		if cmd == nil {
-			fmt.Fprintf(w, "Unknown command: %q\n", flags.Arg(0))
-			return
+		cmd := flags.GetCommandSet(flags.Arg(0))
+		if cmd != nil {
+			flags.PrintCommandUsage(cmd)
 		}
-		fmt.Fprintln(w, flags.Name(), cmd.Name)
-		fmt.Fprintln(w, "  ", cmd.Description)
-		fmt.Fprintln(w, "")
-		flags.PrintCommandFlags(cmd.Name)
 	} else {
-		fmt.Fprintln(w, flags.Name())
+		fmt.Fprintln(w, "Name:", flags.Name())
 		fmt.Fprintln(w, "  General command-line interface to API clients")
 		fmt.Fprintln(w, "")
-		fmt.Fprintln(w, "Syntax:")
+
+		// Command Sets
+		fmt.Fprintln(w, "Command Sets:")
+		for _, cmd := range flags.cmds {
+			fmt.Fprintln(w, "  ", flags.Name(), cmd.Name)
+			fmt.Fprintln(w, "    ", cmd.Description)
+			fmt.Fprintln(w, "")
+		}
+
+		// Help
+		fmt.Fprintln(w, "Help:")
 		fmt.Fprintln(w, "  ", flags.Name(), "version")
 		fmt.Fprintln(w, "    ", "Return the version of the application")
 		fmt.Fprintln(w, "")
+
+		// Help for command sets
 		for _, cmd := range flags.cmds {
 			fmt.Fprintln(w, "  ", flags.Name(), "-help", cmd.Name)
 			fmt.Fprintln(w, "    ", "Display", cmd.Name, "command syntax")
 			fmt.Fprintln(w, "")
 		}
+
+		fmt.Fprintln(w, "")
+		flags.PrintGlobalFlags()
 	}
-	fmt.Fprintln(w, "")
-	flags.PrintGlobalFlags()
 }
 
 // PrintGlobalFlags prints out the global flags
 func (flags *Flags) PrintGlobalFlags() {
 	flags.PrintCommandFlags("")
 }
 
+// PrintCommandUsage prints the usage of a commandset
+func (flags *Flags) PrintCommandUsage(cmd *Cmd) {
+	w := flags.Output()
+	fmt.Fprintln(w, "Name:", flags.Name(), cmd.Name)
+	fmt.Fprintln(w, "  ", cmd.Description)
+	fmt.Fprintln(w, "")
+
+	// Help for command sets
+	fmt.Fprintln(w, "Commands:")
+	for _, fn := range cmd.Fn {
+		fmt.Fprintln(w, "  ", flags.Name(), cmd.Name, fn.Name)
+		fmt.Fprintln(w, "    ", fn.Description)
+		fmt.Fprintln(w, "")
+	}
+	flags.PrintCommandFlags(cmd.Name)
+	fmt.Fprintln(w, "")
+	flags.PrintGlobalFlags()
+}
+
 // PrintGlobalFlags prints out the global flags
 func (flags *Flags) PrintCommandFlags(cmd string) {
 	w := flags.Output()

cmd/api/ipify.go

@@ -17,7 +17,7 @@ func ipifyRegister(flags *Flags) {
 		Parse:       ipifyParse,
 		Fn: []Fn{
 			// Default caller
-			{Call: ipifyGetAddress},
+			{Call: ipifyGetAddress, Description: "Get the public IP address"},
 		},
 	})
 }

cmd/api/main.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"strings"
 
 	"github.com/djthorpe/go-tablewriter"
 )
@@ -22,33 +21,38 @@ func main() {
 	if err := flags.Parse(os.Args[1:]); errors.Is(err, ErrHelp) {
 		os.Exit(0)
 	} else if err != nil {
-		fmt.Fprintln(os.Stderr, err)
 		os.Exit(-1)
 	}
 
 	// If there are no arguments, print help
 	if flags.NArg() == 0 {
-		flags.Usage()
+		flags.PrintUsage()
 		os.Exit(-1)
 	}
 
-	// Get command
-	cmd := flags.GetCommand(flags.Arg(0))
-	match := strings.Join(flags.Args()[1:], " ")
+	// Get command set
+	cmd := flags.GetCommandSet(flags.Arg(0))
 	if cmd == nil {
 		fmt.Fprintf(os.Stderr, "Unknown command: %q\n", flags.Arg(0))
 		os.Exit(-1)
 	}
-	fn := cmd.Get(match)
-	if fn == nil {
-		fmt.Fprintf(os.Stderr, "Unknown command: %q\n", strings.TrimSpace(strings.Join([]string{flags.Name(), cmd.Name, match}, " ")))
+
+	fn := cmd.Get(flags.Args()[1:])
+	if fn != nil {
+		if err := Run(fn); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(-2)
+		}
+	}
+	if flags.NArg() == 1 {
+		flags.PrintCommandUsage(cmd)
+	} else {
+		fmt.Fprintf(os.Stderr, "Unknown command: %q\n", flags.Args()[1:])
 		os.Exit(-1)
 	}
+}
 
-	// Create a tablewriter
+func Run(fn *Fn) error {
 	writer := tablewriter.New(os.Stdout, tablewriter.OptOutputText(), tablewriter.OptHeader())
-	if err := fn.Call(writer); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(-2)
-	}
+	return fn.Call(writer)
 }