cmd/opts/parser.go

package opts

import (
	"errors"
	"fmt"
	"strings"
)

var (
	ErrUnknownOption      = errors.New("unknown option")
	ErrInvalidShortOption = errors.New("invalid short option")
	ErrCannotChainOption  = errors.New("cannot chain option as it takes an argument")
)

type Parser struct {
	opts Set
	args []string
	curr int

	ignoreUnknown bool
}

func NewParser(args []string, opts []Option, ignoreUnknown bool) *Parser {
	return &Parser{
		opts: append(opts, globalOpts...),
		args: args,
		curr: -1,

		ignoreUnknown: ignoreUnknown,
	}
}

func (p *Parser) Parse() (restArgs []string, err error) {
	for p.hasNext() {
		arg := p.next()

		if !strings.HasPrefix(arg, "-") { // Regular argument
			restArgs = append(restArgs, arg)
		} else if arg == "--" { // Options terminator
			restArgs = append(restArgs, p.restArgs()...)
			return
		} else if strings.HasPrefix(arg, "--") { // Long option
			longName := arg[2:]
			if err = p.parseLongOption(longName); err != nil {
				return
			}
		} else { // Short option
			shortNames := arg[1:]
			if err = p.parseShortOption(shortNames); err != nil {
				return
			}
		}
	}

	return
}

func (p *Parser) hasNext() bool {
	return (p.curr + 1) < len(p.args)
}

func (p *Parser) next() string {
	p.curr++

	if p.curr >= len(p.args) {
		return ""
	}

	return p.args[p.curr]
}

func (p *Parser) value() string {
	p.curr++

	if p.curr >= len(p.args) {
		return ""
	}

	arg := p.args[p.curr]
	return arg
}

func (p *Parser) restArgs() []string {
	rest := p.args[p.curr+1:]
	p.curr = len(p.args)

	return rest
}

func (p *Parser) parseLongOption(longName string) error {
	value := ""

	equals := strings.Index(longName, "=")
	if equals >= 0 {
		longName = longName[:equals]
		value = longName[equals+1:]
	} else {
		value = p.value()
	}

	opt, ok := p.opts.GetByLongName(longName)
	if !ok {
		if !p.ignoreUnknown {
			return fmt.Errorf("%w: %s", ErrUnknownOption, "--"+longName)
		}

		return nil // Ignore unknown option. Continue parsing.
	}

	if err := opt.Parse(value); err != nil {
		return err
	}

	return nil
}

func (p *Parser) parseShortOption(shortNames string) error {
	if len(shortNames) == 0 {
		return ErrInvalidShortOption
	} else if len(shortNames) == 1 {
		value := p.value()

		opt, ok := p.opts.GetByShortName(shortNames)
		if !ok {
			if !p.ignoreUnknown {
				return fmt.Errorf("%w: %s", ErrUnknownOption, "-"+shortNames)
			}

			return nil // Ignore unknown option. Continue parsing.
		}

		if err := opt.Parse(value); err != nil {
			return err
		}
	} else {
		for j := 0; j < len(shortNames); j++ {
			shortName := shortNames[j]
			value := ""

			opt, ok := p.opts.GetByShortName(string(shortName))
			if !ok {
				if !p.ignoreUnknown {
					return fmt.Errorf("%w: %s", ErrUnknownOption, "-"+string(shortName))
				}

				continue // Ignore unknown option. Continue parsing.
			}

			if opt.TakesArg() {
				if j > 0 {
					return ErrCannotChainOption
				}

				value = shortNames[1:]
				value = strings.TrimPrefix(value, "=")
				if len(value) == 0 {
					value = p.value()
				}
				j = len(shortNames)
			}

			if err := opt.Parse(value); err != nil {
				return err
			}
		}
	}

	return nil
}