Simple enforcement that additional arguments are passed to a subcommand. If they are not then the subcommand's usage is displayed.

command.On("subcommand", "prints the version", &SubCommand{}, []string{"<requiredArg1>", "<requiredArg2"})

$ program -mainflags subcommand -subflags requiredArg1 requiredArg2

command.On("version", "prints the version", &VersionCommand{}, []string{"<detail-level>"})

$ program version full

• BC break in On() function.
• Arguments are fetched in cmd.Run() the same way as today (and there is no reference to the text passed to On() - that is currently used in usage output)
• Addition of more whitespace is usage output

It would be nice to be able to specify a prefix and if a subcommand is not found look for an executable in the PATH that matches prefix-subcommand and execute it if found, passing any args and flags to that executable. Like git and kubectl do.

Maybe this could be implemented through #4 .

This PR provides improvements to the original code:

• help.Usage:
  • This is necessary to match the behaviour of common Unix usage where programs can take: prog -h, prog --help, prog help, prog -help, prog --h. Otherwise fla.Parse exits upon encountering -h, could define flag.Usage but we need to maintain the behaviour or passing arguments to the help function.
• stdout is now the outfile descriptor instead of stderr: This is allow for users to pipe content into filters as well as to search for strings e.g using grep <a_prog_using_command> -h | grep -i keyword [keywords....]
• help: stable sort order for subcommands: Makes the program help output more familiar and more easily indexed without minimal differences in case it changes, otherwise everytime there will be changes.

The main interface is unchanged, but it is now possible to nest subcommands.

a nested subcommand is also a Cmd,

this package provides a help object "Commander", that you can use to write your own Cmd with nested subcommands.

for example

type myCmd struct { // anonymous field to use Commander.Run() method command.Commander }

func (cmd *myCmd) Flags(fs *flag.FlagSet) *flag.FlagSet { // to make a nested command, just build a new commander cmd.Commander = command.NewCommander("ci", fs) // and call the same methods as the usual top level ones cmd.On("log", "print remote log", &cicmd.LogCmd{}, nil) return fs }

to avoid duplicating the code, I've also replaced the top level On, Parse, and Run() function to use a Commander.

And I've also updated the Usage() to print subcommand in alphabetical order.