handle rest args

cli_test.go

@@ -194,6 +194,21 @@ func Test_git(t *testing.T) {
 				}
 			},
 		},
+		"rest args": {
+			rawArgs: []string{"checkout", "some-branch", "--", "more", "tokens", "here"},
+			checkoutHandler: func(t *testing.T) Handler {
+				called := ensureCalled(t)
+
+				return func(ctx context.Context) error {
+					called()
+
+					rest, err := Rest(ctx)
+					test.NoError(t, err)
+					test.DeepEqual(t, rest, []string{"more", "tokens", "here"})
+					return nil
+				}
+			},
+		},
 	}
 
 	for name, testCase := range testCases {

command.go

@@ -21,6 +21,7 @@ type Command struct {
 	subCommands []*Command
 	flags       []*Flag
 	arguments   []*Argument
+	rest        []string
 	handler     Handler
 }
 

command_config_validation.go

@@ -5,6 +5,7 @@ import "github.com/bobg/errors"
 func (c *Command) validateConfig() error {
 	validations := []func() error{
 		c.validateNoDuplicateFlags,
+		c.validateNoDuplicateShortFlags,
 		c.validateNoDuplicateArguments,
 		c.validateNoDuplicateSubCommands,
 		c.validateEitherCommandsOrArguments,
@@ -35,6 +36,23 @@ func (c *Command) validateNoDuplicateFlags() error {
 	return errors.Join(errs...)
 }
 
+func (c *Command) validateNoDuplicateShortFlags() error {
+	flags := make(map[rune]bool)
+
+	var errs []error
+	for _, flag := range c.flags {
+		for _, short := range flag.shorts {
+			if flags[short] {
+				errs = append(errs, errors.Errorf("duplicate short flag %q", short))
+			}
+
+			flags[short] = true
+		}
+	}
+
+	return errors.Join(errs...)
+}
+
 func (c *Command) validateNoDuplicateArguments() error {
 	arguments := make(map[string]bool)
 

command_config_validation_test.go

@@ -21,6 +21,13 @@ func TestCommand_config_validations(t *testing.T) {
 			),
 			expectedError: `invalid command "test": duplicate flag "some-flag"`,
 		},
+		"validateNoDuplicateShortFlags": {
+			commandOptions: option.NewOptions(
+				AddFlag("some-flag", "some flag", AddFlagShort('s')),
+				AddFlag("some-other-flag", "some other flag", AddFlagShort('s')),
+			),
+			expectedError: `invalid command "test": duplicate short flag 's'`,
+		},
 		"validateNoDuplicateArguments": {
 			commandOptions: option.NewOptions(
 				AddArg("some-arg", "some arg"),

context.go

@@ -7,23 +7,19 @@
 	"github.com/bobg/errors"
 )
 
-var (
-	NotACommandContextError = errors.New("not a command context")
-	FlagNotFoundError       = errors.New("flag not found")
-	ArgumentNotFoundError   = errors.New("argument not found")
-)
+var HandleExecutionError = errors.New("executing handler")
 
 func FlagValue[T any](ctx context.Context, name string) (T, error) {
 	var zero T
 
 	command, err := commandFromContext(ctx)
 	if err != nil {
-		return zero, errors.Wrapf(err, "finding flag %q", name)
+		return zero, err
 	}
 
 	flag, found := command.findFlag(name)
 	if !found {
-		return zero, errors.Wrapf(FlagNotFoundError, "finding flag %q", name)
+		return zero, errors.Wrapf(HandleExecutionError, "finding flag %q", name)
 	}
 
 	if flag.value != nil {
@@ -33,7 +29,7 @@
 	if flag.defaultEnvName != "" {
 		value, err := flag.parser.Parse(os.Getenv(flag.defaultEnvName))
 		if err != nil {
-			return zero, err
+			return zero, errors.Wrapf(errors.Join(HandleExecutionError, err), "parsing env for flag %q", name)
 		}
 
 		return value.(T), nil
@@ -52,7 +48,7 @@
 
 	arg, found := command.findArg(name)
 	if !found {
-		return zero, errors.Wrapf(ArgumentNotFoundError, "finding argument %q", name)
+		return zero, errors.Wrapf(HandleExecutionError, "finding argument %q", name)
 	}
 
 	if arg.value != nil {
@@ -62,6 +58,15 @@
 	return arg.defaultValue.(T), nil
 }
 
+func Rest(ctx context.Context) ([]string, error) {
+	command, err := commandFromContext(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "getting remaining args")
+	}
+
+	return command.rest, nil
+}
+
 type commandContextKeyType struct{}
 
 var commandContextKey = commandContextKeyType{}
@@ -73,7 +78,7 @@
 func commandFromContext(ctx context.Context) (*Command, error) {
 	command, ok := ctx.Value(commandContextKey).(*Command)
 	if !ok {
-		return nil, NotACommandContextError
+		return nil, errors.Wrap(HandleExecutionError, "not a command context")
 	}
 
 	return command, nil

parser.go

@@ -9,6 +9,7 @@ import (
 )
 
 const (
+	restToken      = "--"
 	flagPrefix     = "-"
 	longFlagPrefix = "--"
 )
@@ -41,9 +42,10 @@ func (c *Command) newParser(tokens []string) *parser {
 
 func (p *parser) parse(ctx context.Context) (bool, error) {
 	for p.index < len(p.tokens) {
-		commandProcessed, err := p.parseArg(ctx)
-		if err != nil || commandProcessed {
+		if commandProcessed, err := p.parseArg(ctx); err != nil {
 			return true, err
+		} else if commandProcessed {
+			return true, nil
 		}
 	}
 
@@ -53,7 +55,10 @@ func (p *parser) parse(ctx context.Context) (bool, error) {
 func (p *parser) parseArg(ctx context.Context) (bool, error) {
 	current, _ := p.current()
 
-	if strings.HasPrefix(current, flagPrefix) {
+	if current == restToken {
+		p.processRest()
+		return false, nil
+	} else if strings.HasPrefix(current, flagPrefix) {
 		return false, p.processFlag()
 	} else if command, found := lo.Find(p.command.subCommands, func(subCommand *Command) bool { return subCommand.name == current }); found {
 		return true, p.processCommand(ctx, command)
@@ -62,6 +67,11 @@ func (p *parser) parseArg(ctx context.Context) (bool, error) {
 	return false, p.processArg()
 }
 
+func (p *parser) processRest() {
+	p.command.rest = p.unprocessed()
+	p.index = len(p.tokens)
+}
+
 func (p *parser) processFlag() error {
 	current, _ := p.current()