mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-24 21:34:36 -04:00
* Use vendored go-swagger * vendor go-swagger * revert un wanteed change * remove un-needed GO111MODULE * Update Makefile Co-Authored-By: techknowlogick <matti@mdranta.net>
701 lines
18 KiB
Go
701 lines
18 KiB
Go
// Copyright 2012 Jesse van den Kieboom. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package flags
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"os"
|
|
"path"
|
|
"sort"
|
|
"strings"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// A Parser provides command line option parsing. It can contain several
|
|
// option groups each with their own set of options.
|
|
type Parser struct {
|
|
// Embedded, see Command for more information
|
|
*Command
|
|
|
|
// A usage string to be displayed in the help message.
|
|
Usage string
|
|
|
|
// Option flags changing the behavior of the parser.
|
|
Options Options
|
|
|
|
// NamespaceDelimiter separates group namespaces and option long names
|
|
NamespaceDelimiter string
|
|
|
|
// UnknownOptionsHandler is a function which gets called when the parser
|
|
// encounters an unknown option. The function receives the unknown option
|
|
// name, a SplitArgument which specifies its value if set with an argument
|
|
// separator, and the remaining command line arguments.
|
|
// It should return a new list of remaining arguments to continue parsing,
|
|
// or an error to indicate a parse failure.
|
|
UnknownOptionHandler func(option string, arg SplitArgument, args []string) ([]string, error)
|
|
|
|
// CompletionHandler is a function gets called to handle the completion of
|
|
// items. By default, the items are printed and the application is exited.
|
|
// You can override this default behavior by specifying a custom CompletionHandler.
|
|
CompletionHandler func(items []Completion)
|
|
|
|
// CommandHandler is a function that gets called to handle execution of a
|
|
// command. By default, the command will simply be executed. This can be
|
|
// overridden to perform certain actions (such as applying global flags)
|
|
// just before the command is executed. Note that if you override the
|
|
// handler it is your responsibility to call the command.Execute function.
|
|
//
|
|
// The command passed into CommandHandler may be nil in case there is no
|
|
// command to be executed when parsing has finished.
|
|
CommandHandler func(command Commander, args []string) error
|
|
|
|
internalError error
|
|
}
|
|
|
|
// SplitArgument represents the argument value of an option that was passed using
|
|
// an argument separator.
|
|
type SplitArgument interface {
|
|
// String returns the option's value as a string, and a boolean indicating
|
|
// if the option was present.
|
|
Value() (string, bool)
|
|
}
|
|
|
|
type strArgument struct {
|
|
value *string
|
|
}
|
|
|
|
func (s strArgument) Value() (string, bool) {
|
|
if s.value == nil {
|
|
return "", false
|
|
}
|
|
|
|
return *s.value, true
|
|
}
|
|
|
|
// Options provides parser options that change the behavior of the option
|
|
// parser.
|
|
type Options uint
|
|
|
|
const (
|
|
// None indicates no options.
|
|
None Options = 0
|
|
|
|
// HelpFlag adds a default Help Options group to the parser containing
|
|
// -h and --help options. When either -h or --help is specified on the
|
|
// command line, the parser will return the special error of type
|
|
// ErrHelp. When PrintErrors is also specified, then the help message
|
|
// will also be automatically printed to os.Stdout.
|
|
HelpFlag = 1 << iota
|
|
|
|
// PassDoubleDash passes all arguments after a double dash, --, as
|
|
// remaining command line arguments (i.e. they will not be parsed for
|
|
// flags).
|
|
PassDoubleDash
|
|
|
|
// IgnoreUnknown ignores any unknown options and passes them as
|
|
// remaining command line arguments instead of generating an error.
|
|
IgnoreUnknown
|
|
|
|
// PrintErrors prints any errors which occurred during parsing to
|
|
// os.Stderr. In the special case of ErrHelp, the message will be printed
|
|
// to os.Stdout.
|
|
PrintErrors
|
|
|
|
// PassAfterNonOption passes all arguments after the first non option
|
|
// as remaining command line arguments. This is equivalent to strict
|
|
// POSIX processing.
|
|
PassAfterNonOption
|
|
|
|
// Default is a convenient default set of options which should cover
|
|
// most of the uses of the flags package.
|
|
Default = HelpFlag | PrintErrors | PassDoubleDash
|
|
)
|
|
|
|
type parseState struct {
|
|
arg string
|
|
args []string
|
|
retargs []string
|
|
positional []*Arg
|
|
err error
|
|
|
|
command *Command
|
|
lookup lookup
|
|
}
|
|
|
|
// Parse is a convenience function to parse command line options with default
|
|
// settings. The provided data is a pointer to a struct representing the
|
|
// default option group (named "Application Options"). For more control, use
|
|
// flags.NewParser.
|
|
func Parse(data interface{}) ([]string, error) {
|
|
return NewParser(data, Default).Parse()
|
|
}
|
|
|
|
// ParseArgs is a convenience function to parse command line options with default
|
|
// settings. The provided data is a pointer to a struct representing the
|
|
// default option group (named "Application Options"). The args argument is
|
|
// the list of command line arguments to parse. If you just want to parse the
|
|
// default program command line arguments (i.e. os.Args), then use flags.Parse
|
|
// instead. For more control, use flags.NewParser.
|
|
func ParseArgs(data interface{}, args []string) ([]string, error) {
|
|
return NewParser(data, Default).ParseArgs(args)
|
|
}
|
|
|
|
// NewParser creates a new parser. It uses os.Args[0] as the application
|
|
// name and then calls Parser.NewNamedParser (see Parser.NewNamedParser for
|
|
// more details). The provided data is a pointer to a struct representing the
|
|
// default option group (named "Application Options"), or nil if the default
|
|
// group should not be added. The options parameter specifies a set of options
|
|
// for the parser.
|
|
func NewParser(data interface{}, options Options) *Parser {
|
|
p := NewNamedParser(path.Base(os.Args[0]), options)
|
|
|
|
if data != nil {
|
|
g, err := p.AddGroup("Application Options", "", data)
|
|
|
|
if err == nil {
|
|
g.parent = p
|
|
}
|
|
|
|
p.internalError = err
|
|
}
|
|
|
|
return p
|
|
}
|
|
|
|
// NewNamedParser creates a new parser. The appname is used to display the
|
|
// executable name in the built-in help message. Option groups and commands can
|
|
// be added to this parser by using AddGroup and AddCommand.
|
|
func NewNamedParser(appname string, options Options) *Parser {
|
|
p := &Parser{
|
|
Command: newCommand(appname, "", "", nil),
|
|
Options: options,
|
|
NamespaceDelimiter: ".",
|
|
}
|
|
|
|
p.Command.parent = p
|
|
|
|
return p
|
|
}
|
|
|
|
// Parse parses the command line arguments from os.Args using Parser.ParseArgs.
|
|
// For more detailed information see ParseArgs.
|
|
func (p *Parser) Parse() ([]string, error) {
|
|
return p.ParseArgs(os.Args[1:])
|
|
}
|
|
|
|
// ParseArgs parses the command line arguments according to the option groups that
|
|
// were added to the parser. On successful parsing of the arguments, the
|
|
// remaining, non-option, arguments (if any) are returned. The returned error
|
|
// indicates a parsing error and can be used with PrintError to display
|
|
// contextual information on where the error occurred exactly.
|
|
//
|
|
// When the common help group has been added (AddHelp) and either -h or --help
|
|
// was specified in the command line arguments, a help message will be
|
|
// automatically printed if the PrintErrors option is enabled.
|
|
// Furthermore, the special error type ErrHelp is returned.
|
|
// It is up to the caller to exit the program if so desired.
|
|
func (p *Parser) ParseArgs(args []string) ([]string, error) {
|
|
if p.internalError != nil {
|
|
return nil, p.internalError
|
|
}
|
|
|
|
p.eachOption(func(c *Command, g *Group, option *Option) {
|
|
option.isSet = false
|
|
option.isSetDefault = false
|
|
option.updateDefaultLiteral()
|
|
})
|
|
|
|
// Add built-in help group to all commands if necessary
|
|
if (p.Options & HelpFlag) != None {
|
|
p.addHelpGroups(p.showBuiltinHelp)
|
|
}
|
|
|
|
compval := os.Getenv("GO_FLAGS_COMPLETION")
|
|
|
|
if len(compval) != 0 {
|
|
comp := &completion{parser: p}
|
|
items := comp.complete(args)
|
|
|
|
if p.CompletionHandler != nil {
|
|
p.CompletionHandler(items)
|
|
} else {
|
|
comp.print(items, compval == "verbose")
|
|
os.Exit(0)
|
|
}
|
|
|
|
return nil, nil
|
|
}
|
|
|
|
s := &parseState{
|
|
args: args,
|
|
retargs: make([]string, 0, len(args)),
|
|
}
|
|
|
|
p.fillParseState(s)
|
|
|
|
for !s.eof() {
|
|
arg := s.pop()
|
|
|
|
// When PassDoubleDash is set and we encounter a --, then
|
|
// simply append all the rest as arguments and break out
|
|
if (p.Options&PassDoubleDash) != None && arg == "--" {
|
|
s.addArgs(s.args...)
|
|
break
|
|
}
|
|
|
|
if !argumentIsOption(arg) {
|
|
// Note: this also sets s.err, so we can just check for
|
|
// nil here and use s.err later
|
|
if p.parseNonOption(s) != nil {
|
|
break
|
|
}
|
|
|
|
continue
|
|
}
|
|
|
|
var err error
|
|
|
|
prefix, optname, islong := stripOptionPrefix(arg)
|
|
optname, _, argument := splitOption(prefix, optname, islong)
|
|
|
|
if islong {
|
|
err = p.parseLong(s, optname, argument)
|
|
} else {
|
|
err = p.parseShort(s, optname, argument)
|
|
}
|
|
|
|
if err != nil {
|
|
ignoreUnknown := (p.Options & IgnoreUnknown) != None
|
|
parseErr := wrapError(err)
|
|
|
|
if parseErr.Type != ErrUnknownFlag || (!ignoreUnknown && p.UnknownOptionHandler == nil) {
|
|
s.err = parseErr
|
|
break
|
|
}
|
|
|
|
if ignoreUnknown {
|
|
s.addArgs(arg)
|
|
} else if p.UnknownOptionHandler != nil {
|
|
modifiedArgs, err := p.UnknownOptionHandler(optname, strArgument{argument}, s.args)
|
|
|
|
if err != nil {
|
|
s.err = err
|
|
break
|
|
}
|
|
|
|
s.args = modifiedArgs
|
|
}
|
|
}
|
|
}
|
|
|
|
if s.err == nil {
|
|
p.eachOption(func(c *Command, g *Group, option *Option) {
|
|
if option.preventDefault {
|
|
return
|
|
}
|
|
|
|
option.clearDefault()
|
|
})
|
|
|
|
s.checkRequired(p)
|
|
}
|
|
|
|
var reterr error
|
|
|
|
if s.err != nil {
|
|
reterr = s.err
|
|
} else if len(s.command.commands) != 0 && !s.command.SubcommandsOptional {
|
|
reterr = s.estimateCommand()
|
|
} else if cmd, ok := s.command.data.(Commander); ok {
|
|
if p.CommandHandler != nil {
|
|
reterr = p.CommandHandler(cmd, s.retargs)
|
|
} else {
|
|
reterr = cmd.Execute(s.retargs)
|
|
}
|
|
} else if p.CommandHandler != nil {
|
|
reterr = p.CommandHandler(nil, s.retargs)
|
|
}
|
|
|
|
if reterr != nil {
|
|
var retargs []string
|
|
|
|
if ourErr, ok := reterr.(*Error); !ok || ourErr.Type != ErrHelp {
|
|
retargs = append([]string{s.arg}, s.args...)
|
|
} else {
|
|
retargs = s.args
|
|
}
|
|
|
|
return retargs, p.printError(reterr)
|
|
}
|
|
|
|
return s.retargs, nil
|
|
}
|
|
|
|
func (p *parseState) eof() bool {
|
|
return len(p.args) == 0
|
|
}
|
|
|
|
func (p *parseState) pop() string {
|
|
if p.eof() {
|
|
return ""
|
|
}
|
|
|
|
p.arg = p.args[0]
|
|
p.args = p.args[1:]
|
|
|
|
return p.arg
|
|
}
|
|
|
|
func (p *parseState) peek() string {
|
|
if p.eof() {
|
|
return ""
|
|
}
|
|
|
|
return p.args[0]
|
|
}
|
|
|
|
func (p *parseState) checkRequired(parser *Parser) error {
|
|
c := parser.Command
|
|
|
|
var required []*Option
|
|
|
|
for c != nil {
|
|
c.eachGroup(func(g *Group) {
|
|
for _, option := range g.options {
|
|
if !option.isSet && option.Required {
|
|
required = append(required, option)
|
|
}
|
|
}
|
|
})
|
|
|
|
c = c.Active
|
|
}
|
|
|
|
if len(required) == 0 {
|
|
if len(p.positional) > 0 {
|
|
var reqnames []string
|
|
|
|
for _, arg := range p.positional {
|
|
argRequired := (!arg.isRemaining() && p.command.ArgsRequired) || arg.Required != -1 || arg.RequiredMaximum != -1
|
|
|
|
if !argRequired {
|
|
continue
|
|
}
|
|
|
|
if arg.isRemaining() {
|
|
if arg.value.Len() < arg.Required {
|
|
var arguments string
|
|
|
|
if arg.Required > 1 {
|
|
arguments = "arguments, but got only " + fmt.Sprintf("%d", arg.value.Len())
|
|
} else {
|
|
arguments = "argument"
|
|
}
|
|
|
|
reqnames = append(reqnames, "`"+arg.Name+" (at least "+fmt.Sprintf("%d", arg.Required)+" "+arguments+")`")
|
|
} else if arg.RequiredMaximum != -1 && arg.value.Len() > arg.RequiredMaximum {
|
|
if arg.RequiredMaximum == 0 {
|
|
reqnames = append(reqnames, "`"+arg.Name+" (zero arguments)`")
|
|
} else {
|
|
var arguments string
|
|
|
|
if arg.RequiredMaximum > 1 {
|
|
arguments = "arguments, but got " + fmt.Sprintf("%d", arg.value.Len())
|
|
} else {
|
|
arguments = "argument"
|
|
}
|
|
|
|
reqnames = append(reqnames, "`"+arg.Name+" (at most "+fmt.Sprintf("%d", arg.RequiredMaximum)+" "+arguments+")`")
|
|
}
|
|
}
|
|
} else {
|
|
reqnames = append(reqnames, "`"+arg.Name+"`")
|
|
}
|
|
}
|
|
|
|
if len(reqnames) == 0 {
|
|
return nil
|
|
}
|
|
|
|
var msg string
|
|
|
|
if len(reqnames) == 1 {
|
|
msg = fmt.Sprintf("the required argument %s was not provided", reqnames[0])
|
|
} else {
|
|
msg = fmt.Sprintf("the required arguments %s and %s were not provided",
|
|
strings.Join(reqnames[:len(reqnames)-1], ", "), reqnames[len(reqnames)-1])
|
|
}
|
|
|
|
p.err = newError(ErrRequired, msg)
|
|
return p.err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
names := make([]string, 0, len(required))
|
|
|
|
for _, k := range required {
|
|
names = append(names, "`"+k.String()+"'")
|
|
}
|
|
|
|
sort.Strings(names)
|
|
|
|
var msg string
|
|
|
|
if len(names) == 1 {
|
|
msg = fmt.Sprintf("the required flag %s was not specified", names[0])
|
|
} else {
|
|
msg = fmt.Sprintf("the required flags %s and %s were not specified",
|
|
strings.Join(names[:len(names)-1], ", "), names[len(names)-1])
|
|
}
|
|
|
|
p.err = newError(ErrRequired, msg)
|
|
return p.err
|
|
}
|
|
|
|
func (p *parseState) estimateCommand() error {
|
|
commands := p.command.sortedVisibleCommands()
|
|
cmdnames := make([]string, len(commands))
|
|
|
|
for i, v := range commands {
|
|
cmdnames[i] = v.Name
|
|
}
|
|
|
|
var msg string
|
|
var errtype ErrorType
|
|
|
|
if len(p.retargs) != 0 {
|
|
c, l := closestChoice(p.retargs[0], cmdnames)
|
|
msg = fmt.Sprintf("Unknown command `%s'", p.retargs[0])
|
|
errtype = ErrUnknownCommand
|
|
|
|
if float32(l)/float32(len(c)) < 0.5 {
|
|
msg = fmt.Sprintf("%s, did you mean `%s'?", msg, c)
|
|
} else if len(cmdnames) == 1 {
|
|
msg = fmt.Sprintf("%s. You should use the %s command",
|
|
msg,
|
|
cmdnames[0])
|
|
} else if len(cmdnames) > 1 {
|
|
msg = fmt.Sprintf("%s. Please specify one command of: %s or %s",
|
|
msg,
|
|
strings.Join(cmdnames[:len(cmdnames)-1], ", "),
|
|
cmdnames[len(cmdnames)-1])
|
|
}
|
|
} else {
|
|
errtype = ErrCommandRequired
|
|
|
|
if len(cmdnames) == 1 {
|
|
msg = fmt.Sprintf("Please specify the %s command", cmdnames[0])
|
|
} else if len(cmdnames) > 1 {
|
|
msg = fmt.Sprintf("Please specify one command of: %s or %s",
|
|
strings.Join(cmdnames[:len(cmdnames)-1], ", "),
|
|
cmdnames[len(cmdnames)-1])
|
|
}
|
|
}
|
|
|
|
return newError(errtype, msg)
|
|
}
|
|
|
|
func (p *Parser) parseOption(s *parseState, name string, option *Option, canarg bool, argument *string) (err error) {
|
|
if !option.canArgument() {
|
|
if argument != nil {
|
|
return newErrorf(ErrNoArgumentForBool, "bool flag `%s' cannot have an argument", option)
|
|
}
|
|
|
|
err = option.set(nil)
|
|
} else if argument != nil || (canarg && !s.eof()) {
|
|
var arg string
|
|
|
|
if argument != nil {
|
|
arg = *argument
|
|
} else {
|
|
arg = s.pop()
|
|
|
|
if argumentIsOption(arg) && !(option.isSignedNumber() && len(arg) > 1 && arg[0] == '-' && arg[1] >= '0' && arg[1] <= '9') {
|
|
return newErrorf(ErrExpectedArgument, "expected argument for flag `%s', but got option `%s'", option, arg)
|
|
} else if p.Options&PassDoubleDash != 0 && arg == "--" {
|
|
return newErrorf(ErrExpectedArgument, "expected argument for flag `%s', but got double dash `--'", option)
|
|
}
|
|
}
|
|
|
|
if option.tag.Get("unquote") != "false" {
|
|
arg, err = unquoteIfPossible(arg)
|
|
}
|
|
|
|
if err == nil {
|
|
err = option.set(&arg)
|
|
}
|
|
} else if option.OptionalArgument {
|
|
option.empty()
|
|
|
|
for _, v := range option.OptionalValue {
|
|
err = option.set(&v)
|
|
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
err = newErrorf(ErrExpectedArgument, "expected argument for flag `%s'", option)
|
|
}
|
|
|
|
if err != nil {
|
|
if _, ok := err.(*Error); !ok {
|
|
err = newErrorf(ErrMarshal, "invalid argument for flag `%s' (expected %s): %s",
|
|
option,
|
|
option.value.Type(),
|
|
err.Error())
|
|
}
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func (p *Parser) parseLong(s *parseState, name string, argument *string) error {
|
|
if option := s.lookup.longNames[name]; option != nil {
|
|
// Only long options that are required can consume an argument
|
|
// from the argument list
|
|
canarg := !option.OptionalArgument
|
|
|
|
return p.parseOption(s, name, option, canarg, argument)
|
|
}
|
|
|
|
return newErrorf(ErrUnknownFlag, "unknown flag `%s'", name)
|
|
}
|
|
|
|
func (p *Parser) splitShortConcatArg(s *parseState, optname string) (string, *string) {
|
|
c, n := utf8.DecodeRuneInString(optname)
|
|
|
|
if n == len(optname) {
|
|
return optname, nil
|
|
}
|
|
|
|
first := string(c)
|
|
|
|
if option := s.lookup.shortNames[first]; option != nil && option.canArgument() {
|
|
arg := optname[n:]
|
|
return first, &arg
|
|
}
|
|
|
|
return optname, nil
|
|
}
|
|
|
|
func (p *Parser) parseShort(s *parseState, optname string, argument *string) error {
|
|
if argument == nil {
|
|
optname, argument = p.splitShortConcatArg(s, optname)
|
|
}
|
|
|
|
for i, c := range optname {
|
|
shortname := string(c)
|
|
|
|
if option := s.lookup.shortNames[shortname]; option != nil {
|
|
// Only the last short argument can consume an argument from
|
|
// the arguments list, and only if it's non optional
|
|
canarg := (i+utf8.RuneLen(c) == len(optname)) && !option.OptionalArgument
|
|
|
|
if err := p.parseOption(s, shortname, option, canarg, argument); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
return newErrorf(ErrUnknownFlag, "unknown flag `%s'", shortname)
|
|
}
|
|
|
|
// Only the first option can have a concatted argument, so just
|
|
// clear argument here
|
|
argument = nil
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *parseState) addArgs(args ...string) error {
|
|
for len(p.positional) > 0 && len(args) > 0 {
|
|
arg := p.positional[0]
|
|
|
|
if err := convert(args[0], arg.value, arg.tag); err != nil {
|
|
p.err = err
|
|
return err
|
|
}
|
|
|
|
if !arg.isRemaining() {
|
|
p.positional = p.positional[1:]
|
|
}
|
|
|
|
args = args[1:]
|
|
}
|
|
|
|
p.retargs = append(p.retargs, args...)
|
|
return nil
|
|
}
|
|
|
|
func (p *Parser) parseNonOption(s *parseState) error {
|
|
if len(s.positional) > 0 {
|
|
return s.addArgs(s.arg)
|
|
}
|
|
|
|
if len(s.command.commands) > 0 && len(s.retargs) == 0 {
|
|
if cmd := s.lookup.commands[s.arg]; cmd != nil {
|
|
s.command.Active = cmd
|
|
cmd.fillParseState(s)
|
|
|
|
return nil
|
|
} else if !s.command.SubcommandsOptional {
|
|
s.addArgs(s.arg)
|
|
return newErrorf(ErrUnknownCommand, "Unknown command `%s'", s.arg)
|
|
}
|
|
}
|
|
|
|
if (p.Options & PassAfterNonOption) != None {
|
|
// If PassAfterNonOption is set then all remaining arguments
|
|
// are considered positional
|
|
if err := s.addArgs(s.arg); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := s.addArgs(s.args...); err != nil {
|
|
return err
|
|
}
|
|
|
|
s.args = []string{}
|
|
} else {
|
|
return s.addArgs(s.arg)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *Parser) showBuiltinHelp() error {
|
|
var b bytes.Buffer
|
|
|
|
p.WriteHelp(&b)
|
|
return newError(ErrHelp, b.String())
|
|
}
|
|
|
|
func (p *Parser) printError(err error) error {
|
|
if err != nil && (p.Options&PrintErrors) != None {
|
|
flagsErr, ok := err.(*Error)
|
|
|
|
if ok && flagsErr.Type == ErrHelp {
|
|
fmt.Fprintln(os.Stdout, err)
|
|
} else {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
}
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func (p *Parser) clearIsSet() {
|
|
p.eachCommand(func(c *Command) {
|
|
c.eachGroup(func(g *Group) {
|
|
for _, option := range g.options {
|
|
option.isSet = false
|
|
}
|
|
})
|
|
}, true)
|
|
}
|