179 lines
3.4 KiB
Go
179 lines
3.4 KiB
Go
package opt
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
ErrUnknownOption = errors.New("unknown option")
|
|
ErrCannotChainOption = errors.New("cannot chain option")
|
|
ErrOptionRequiresValue = errors.New("option requires value")
|
|
)
|
|
|
|
type Parser struct {
|
|
opts Set
|
|
args []string
|
|
curr int
|
|
|
|
ignoreUnknown bool
|
|
}
|
|
|
|
func NewParser(args []string, opts Set, 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, "-") || 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) peek() string {
|
|
if p.curr+1 >= len(p.args) {
|
|
return ""
|
|
}
|
|
|
|
return p.args[p.curr+1]
|
|
}
|
|
|
|
func (p *Parser) value() (string, bool) {
|
|
if !p.hasNext() || (p.peek() != "-" && strings.HasPrefix(p.peek(), "-")) {
|
|
return "", false
|
|
}
|
|
|
|
return p.next(), true
|
|
}
|
|
|
|
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 {
|
|
value = longName[equals+1:]
|
|
longName = longName[:equals]
|
|
}
|
|
|
|
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 value == "" && opt.RequiresVal() {
|
|
var ok bool
|
|
value, ok = p.value()
|
|
if !ok {
|
|
return fmt.Errorf("%w: %s", ErrOptionRequiresValue, "--"+longName)
|
|
}
|
|
}
|
|
|
|
if err := opt.Parse(value); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *Parser) parseShortOption(shortNames string) error {
|
|
if len(shortNames) == 1 {
|
|
value, valOk := 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 !valOk && opt.RequiresVal() {
|
|
return fmt.Errorf("%w: %s", ErrOptionRequiresValue, "-"+shortNames)
|
|
}
|
|
|
|
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.RequiresVal() {
|
|
if j > 0 {
|
|
return fmt.Errorf("%w: %s", ErrCannotChainOption, "-"+string(shortName))
|
|
}
|
|
|
|
value = shortNames[1:]
|
|
value = strings.TrimPrefix(value, "=")
|
|
j = len(shortNames)
|
|
}
|
|
|
|
if err := opt.Parse(value); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|