argparse: add handling for positional arguments

Add the ability to specify single- or multi-item positional arguments,
represented as 'string's and '[]string's, respectively. These arguments are
processes in order of specification, and multi-item positional args are only
allowed as the *last* positional argument specified.

Signed-off-by: Victoria Dye <[email protected]>

Author: vdye

internal/argparse/argparse.go

@@ -7,14 +7,21 @@ import (
 	"strings"
 )
 
+type positionalArg struct {
+	name        string
+	description string
+	value       interface{}
+}
+
 type argParser struct {
 	// State
 	isTopLevel bool
 	parsed     bool
 	argOffset  int
 
 	// Pre-parsing
-	subcommands map[string]Subcommand
+	subcommands    map[string]Subcommand
+	positionalArgs []*positionalArg
 
 	// Post-parsing
 	selectedSubcommand Subcommand
@@ -37,6 +44,15 @@ func NewArgParser(usageString string) *argParser {
 		out := a.FlagSet.Output()
 		fmt.Fprintf(out, "usage: %s\n\n", usageString)
 
+		// Print flags (if any)
+		flagCount := 0
+		a.FlagSet.VisitAll(func(f *flag.Flag) { flagCount++ })
+		if flagCount > 0 {
+			fmt.Fprintln(out, "Flags:")
+			a.FlagSet.PrintDefaults()
+			fmt.Fprint(out, "\n")
+		}
+
 		// Print subcommands (if any)
 		if len(a.subcommands) > 0 {
 			if a.isTopLevel {
@@ -70,12 +86,54 @@ func (a *argParser) Subcommand(subcommand Subcommand) {
 	a.subcommands[subcommand.Name()] = subcommand
 }
 
+func (a *argParser) PositionalStringVar(name string, description string, arg *string) {
+	a.positionalArgs = append(a.positionalArgs, &positionalArg{
+		name:        name,
+		description: description,
+		value:       arg,
+	})
+}
+
+func (a *argParser) PositionalString(name string, description string) *string {
+	arg := new(string)
+	a.PositionalStringVar(name, description, arg)
+	return arg
+}
+
+func (a *argParser) PositionalListVar(name string, description string, arg *[]string) {
+	a.positionalArgs = append(a.positionalArgs, &positionalArg{
+		name:        name,
+		description: description,
+		value:       arg,
+	})
+}
+
+func (a *argParser) PositionalList(name string, description string) *[]string {
+	arg := &[]string{}
+	a.PositionalListVar(name, description, arg)
+	return arg
+}
+
 func (a *argParser) Parse(args []string) {
 	if a.parsed {
 		// Do nothing if we've already parsed args
 		return
 	}
 
+	// Validate
+	if len(a.subcommands) > 0 && len(a.positionalArgs) > 0 {
+		panic("cannot mix subcommands and positional args")
+	}
+	for i, positionalArg := range a.positionalArgs {
+		if i < len(a.positionalArgs)-1 {
+			// Only the last positional arg can be a list
+			_, isList := positionalArg.value.(*[]string)
+			if isList {
+				panic("only the last positional arg can be a list type")
+			}
+		}
+	}
+
 	err := a.FlagSet.Parse(args)
 	if err != nil {
 		panic("argParser FlagSet error handling should be 'ExitOnError', but error encountered")
@@ -95,6 +153,27 @@ func (a *argParser) Parse(args []string) {
 			a.argOffset++
 		}
 	} else {
+		// Handle positional args
+		for _, arg := range a.positionalArgs {
+			// First, try single string case
+			sPtr, isStr := arg.value.(*string)
+			if isStr {
+				*sPtr = a.Arg(0)
+				a.argOffset++
+				continue
+			}
+
+			// Next, try list case
+			lPtr, isList := arg.value.(*[]string)
+			if isList {
+				*lPtr = a.Args()
+				a.argOffset += a.NArg()
+				break
+			}
+
+			panic("Positional arg has invalid type")
+		}
+
 		if a.NArg() != 0 {
 			// If not using subcommands, all args should be accounted for
 			// Exit with usage if not