diff options
Diffstat (limited to 'vendor/github.com/pborman/getopt/v2/getopt.go')
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/getopt.go | 636 |
1 files changed, 0 insertions, 636 deletions
diff --git a/vendor/github.com/pborman/getopt/v2/getopt.go b/vendor/github.com/pborman/getopt/v2/getopt.go deleted file mode 100644 index e5c52bf..0000000 --- a/vendor/github.com/pborman/getopt/v2/getopt.go +++ /dev/null @@ -1,636 +0,0 @@ -// Copyright 2017 Google Inc. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package getopt (v2) provides traditional getopt processing for implementing -// commands that use traditional command lines. The standard Go flag package -// cannot be used to write a program that parses flags the way ls or ssh does, -// for example. Version 2 of this package has a simplified API. -// -// See the github.com/pborman/options package for a simple structure based -// interface to this package. -// -// USAGE -// -// Getopt supports functionality found in both the standard BSD getopt as well -// as (one of the many versions of) the GNU getopt_long. Being a Go package, -// this package makes common usage easy, but still enables more controlled usage -// if needed. -// -// Typical usage: -// -// // Declare flags and have getopt return pointers to the values. -// helpFlag := getopt.Bool('?', "display help") -// cmdFlag := getopt.StringLong("command", 'c', "default", "the command") -// -// // Declare flags against existing variables. -// var { -// fileName = "/the/default/path" -// timeout = time.Second * 5 -// verbose bool -// } -// func init() { -// getopt.Flag(&verbose, 'v', "be verbose") -// getopt.FlagLong(&fileName, "path", 0, "the path") -// getopt.FlagLong(&timeout, "timeout", 't', "some timeout") -// } -// -// func main() { -// // Parse the program arguments -// getopt.Parse() -// // Get the remaining positional parameters -// args := getopt.Args() -// ... -// -// If you don't want the program to exit on error, use getopt.Getopt: -// -// err := getopt.Getopt(nil) -// if err != nil { -// // code to handle error -// fmt.Fprintln(os.Stderr, err) -// } -// -// FLAG SYNTAX -// -// Support is provided for both short (-f) and long (--flag) options. A single -// option may have both a short and a long name. Each option may be a flag or a -// value. A value takes an argument. -// -// Declaring no long names causes this package to process arguments like the -// traditional BSD getopt. -// -// Short flags may be combined into a single parameter. For example, "-a -b -c" -// may also be expressed "-abc". Long flags must stand on their own "--alpha -// --beta" -// -// Values require an argument. For short options the argument may either be -// immediately following the short name or as the next argument. Only one short -// value may be combined with short flags in a single argument; the short value -// must be after all short flags. For example, if f is a flag and v is a value, -// then: -// -// -vvalue (sets v to "value") -// -v value (sets v to "value") -// -fvvalue (sets f, and sets v to "value") -// -fv value (sets f, and sets v to "value") -// -vf value (set v to "f" and value is the first parameter) -// -// For the long value option val: -// -// --val value (sets val to "value") -// --val=value (sets val to "value") -// --valvalue (invalid option "valvalue") -// -// Values with an optional value only set the value if the value is part of the -// same argument. In any event, the option count is increased and the option is -// marked as seen. -// -// -v -f (sets v and f as being seen) -// -vvalue -f (sets v to "value" and sets f) -// --val -f (sets v and f as being seen) -// --val=value -f (sets v to "value" and sets f) -// -// There is no convenience function defined for making the value optional. The -// SetOptional method must be called on the actual Option. -// -// v := String("val", 'v', "", "the optional v") -// Lookup("v").SetOptional() -// -// var s string -// FlagLong(&s, "val", 'v', "the optional v).SetOptional() -// -// Parsing continues until the first non-option or "--" is encountered. -// -// The short name "-" can be used, but it either is specified as "-" or as part -// of a group of options, for example "-f-". If there are no long options -// specified then "--f" could also be used. If "-" is not declared as an option -// then the single "-" will also terminate the option processing but unlike -// "--", the "-" will be part of the remaining arguments. -// -// ADVANCED USAGE -// -// Normally the parsing is performed by calling the Parse function. If it is -// important to see the order of the options then the Getopt function should be -// used. The standard Parse function does the equivalent of: -// -// func Parse() { -// if err := getopt.Getopt(os.Args, nil); err != nil { -// fmt.Fprintln(os.Stderr, err) -// s.usage() -// os.Exit(1) -// } -// -// When calling Getopt it is the responsibility of the caller to print any -// errors. -// -// Normally the default option set, CommandLine, is used. Other option sets may -// be created with New. -// -// After parsing, the sets Args will contain the non-option arguments. If an -// error is encountered then Args will begin with argument that caused the -// error. -// -// It is valid to call a set's Parse a second time to amen flags or values. As -// an example: -// -// var a = getopt.Bool('a', "", "The a flag") -// var b = getopt.Bool('b', "", "The a flag") -// var cmd = "" -// -// var opts = getopt.CommandLine -// -// opts.Parse(os.Args) -// if opts.NArgs() > 0 { -// cmd = opts.Arg(0) -// opts.Parse(opts.Args()) -// } -// -// If called with set to { "prog", "-a", "cmd", "-b", "arg" } then both and and -// b would be set, cmd would be set to "cmd", and opts.Args() would return { -// "arg" }. -// -// Unless an option type explicitly prohibits it, an option may appear more than -// once in the arguments. The last value provided to the option is the value. -// -// MANDATORY OPTIONS -// -// An option marked as mandatory and not seen when parsing will cause an error -// to be reported such as: "program: --name is a mandatory option". An option -// is marked mandatory by using the Mandatory method: -// -// getopt.FlagLong(&fileName, "path", 0, "the path").Mandatory() -// -// Mandatory options have (required) appended to their help message: -// -// --path=value the path (required) -// -// MUTUALLY EXCLUSIVE OPTIONS -// -// Options can be marked as part of a mutually exclusive group. When two or -// more options in a mutually exclusive group are both seen while parsing then -// an error such as "program: options -a and -b are mutually exclusive" will be -// reported. Mutually exclusive groups are declared using the SetGroup method: -// -// getopt.Flag(&a, 'a', "use method A").SetGroup("method") -// getopt.Flag(&a, 'b', "use method B").SetGroup("method") -// -// A set can have multiple mutually exclusive groups. Mutually exclusive groups -// are identified with their group name in {}'s appeneded to their help message: -// -// -a use method A {method} -// -b use method B {method} -// -// BUILTIN TYPES -// -// The Flag and FlagLong functions support most standard Go types. For the -// list, see the description of FlagLong below for a list of supported types. -// -// There are also helper routines to allow single line flag declarations. These -// types are: Bool, Counter, Duration, Enum, Int16, Int32, Int64, Int, List, -// Signed, String, Uint16, Uint32, Uint64, Uint, and Unsigned. -// -// Each comes in a short and long flavor, e.g., Bool and BoolLong and include -// functions to set the flags on the standard command line or for a specific Set -// of flags. -// -// Except for the Counter, Enum, Signed and Unsigned types, all of these types -// can be declared using Flag and FlagLong by passing in a pointer to the -// appropriate type. -// -// DECLARING NEW FLAG TYPES -// -// A pointer to any type that implements the Value interface may be passed to -// Flag or FlagLong. -// -// VALUEHELP -// -// All non-flag options are created with a "valuehelp" as the last parameter. -// Valuehelp should be 0, 1, or 2 strings. The first string, if provided, is -// the usage message for the option. If the second string, if provided, is the -// name to use for the value when displaying the usage. If not provided the -// term "value" is assumed. -// -// The usage message for the option created with -// -// StringLong("option", 'o', "defval", "a string of letters") -// -// is -// -// -o, -option=value -// -// StringLong("option", 'o', "defval", "a string of letters", "string") -// -// is -// -// -o, -option=string -package getopt - -import ( - "fmt" - "io" - "os" - "path" - "sort" - "strings" - "time" -) - -// stderr allows tests to capture output to standard error. -var stderr io.Writer = os.Stderr - -// exit allows tests to capture an os.Exit call -var exit = os.Exit - -// DisplayWidth is used to determine where to split usage long lines. -var DisplayWidth = 80 - -// HelpColumn is the maximum column position that help strings start to display -// at. If the option usage is too long then the help string will be displayed -// on the next line. For example: -// -// -a this is the a flag -// -u, --under=location -// the u flag's usage is quite long -var HelpColumn = 20 - -// PrintUsage prints the usage line and set of options of set S to w. -func (s *Set) PrintUsage(w io.Writer) { - parts := make([]string, 2, 4) - parts[0] = "Usage:" - parts[1] = s.program - if usage := s.UsageLine(); usage != "" { - parts = append(parts, usage) - } - if s.parameters != "" { - parts = append(parts, s.parameters) - } - fmt.Fprintln(w, strings.Join(parts, " ")) - s.PrintOptions(w) -} - -// UsageLine returns the usage line for the set s. The set's program name and -// parameters, if any, are not included. -func (s *Set) UsageLine() string { - sort.Sort(s.options) - flags := "" - - // Build up the list of short flag names and also compute - // how to display the option in the longer help listing. - // We also keep track of the longest option usage string - // that is no more than HelpColumn-3 bytes (at which point - // we use two lines to display the help). The three - // is for the leading space and the two spaces before the - // help string. - for _, opt := range s.options { - if opt.name == "" { - opt.name = "value" - } - if opt.uname == "" { - opt.uname = opt.usageName() - } - if opt.flag && opt.short != 0 && opt.short != '-' { - flags += string(opt.short) - } - } - - var opts []string - - // The short option - is special - if s.shortOptions['-'] != nil { - opts = append(opts, "-") - } - - // If we have a bundle of flags, add them to the list - if flags != "" { - opts = append(opts, "-"+flags) - } - - // Now append all the long options and options that require - // values. - for _, opt := range s.options { - if opt.flag { - if opt.short != 0 { - continue - } - flags = "--" + opt.long - } else if opt.short != 0 { - flags = "-" + string(opt.short) + " " + opt.name - } else { - flags = "--" + string(opt.long) + " " + opt.name - } - opts = append(opts, flags) - } - flags = strings.Join(opts, "] [") - if flags != "" { - flags = "[" + flags + "]" - } - return flags -} - -// PrintOptions prints the list of options in s to w. -func (s *Set) PrintOptions(w io.Writer) { - sort.Sort(s.options) - max := 4 - for _, opt := range s.options { - if opt.name == "" { - opt.name = "value" - } - if opt.uname == "" { - opt.uname = opt.usageName() - } - if max < len(opt.uname) && len(opt.uname) <= HelpColumn-3 { - max = len(opt.uname) - } - } - // Now print one or more usage lines per option. - for _, opt := range s.options { - if opt.uname != "" { - opt.help = strings.TrimSpace(opt.help) - if len(opt.help) == 0 && !opt.mandatory && opt.group == "" { - fmt.Fprintf(w, " %s\n", opt.uname) - continue - } - helpMsg := opt.help - - // If the default value is the known zero value - // then don't display it. - def := opt.defval - switch genericValue(opt.value).(type) { - case *bool: - if def == "false" { - def = "" - } - case *int, *int8, *int16, *int32, *int64, - *uint, *uint8, *uint16, *uint32, *uint64, - *float32, *float64: - if def == "0" { - def = "" - } - case *time.Duration: - if def == "0s" { - def = "" - } - default: - if opt.flag && def == "false" { - def = "" - } - } - if def != "" { - helpMsg += " [" + def + "]" - } - if opt.group != "" { - helpMsg += " {" + opt.group + "}" - } - if opt.mandatory { - helpMsg += " (required)" - } - - help := strings.Split(helpMsg, "\n") - // If they did not put in newlines then we will insert - // them to keep the help messages from wrapping. - if len(help) == 1 { - help = breakup(help[0], DisplayWidth-HelpColumn) - } - if len(opt.uname) <= max { - fmt.Fprintf(w, " %-*s %s\n", max, opt.uname, help[0]) - help = help[1:] - } else { - fmt.Fprintf(w, " %s\n", opt.uname) - } - for _, s := range help { - fmt.Fprintf(w, " %-*s %s\n", max, " ", s) - } - } - } -} - -// breakup breaks s up into strings no longer than max bytes. -func breakup(s string, max int) []string { - var a []string - - for { - // strip leading spaces - for len(s) > 0 && s[0] == ' ' { - s = s[1:] - } - // If the option is no longer than the max just return it - if len(s) <= max { - if len(s) != 0 { - a = append(a, s) - } - return a - } - x := max - for s[x] != ' ' { - // the first word is too long?! - if x == 0 { - x = max - for x < len(s) && s[x] != ' ' { - x++ - } - if x == len(s) { - x-- - } - break - } - x-- - } - for s[x] == ' ' { - x-- - } - a = append(a, s[:x+1]) - s = s[x+1:] - } -} - -// Parse uses Getopt to parse args using the options set for s. The first -// element of args is used to assign the program for s if it is not yet set. On -// error, Parse displays the error message as well as a usage message on -// standard error and then exits the program. -func (s *Set) Parse(args []string) { - if err := s.Getopt(args, nil); err != nil { - fmt.Fprintln(stderr, err) - s.usage() - exit(1) - } -} - -// Parse uses Getopt to parse args using the options set for s. The first -// element of args is used to assign the program for s if it is not yet set. -// Getop calls fn, if not nil, for each option parsed. -// -// Getopt returns nil when all options have been processed (a non-option -// argument was encountered, "--" was encountered, or fn returned false). -// -// On error getopt returns a reference to an InvalidOption (which implements the -// error interface). -func (s *Set) Getopt(args []string, fn func(Option) bool) (err error) { - s.setState(InProgress) - defer func() { - if s.State() == InProgress { - switch { - case err != nil: - s.setState(Failure) - case len(s.args) == 0: - s.setState(EndOfArguments) - default: - s.setState(Unknown) - } - } - }() - - defer func() { - if err == nil { - err = s.checkOptions() - } - }() - if fn == nil { - fn = func(Option) bool { return true } - } - if len(args) == 0 { - return nil - } - - if s.program == "" { - s.program = path.Base(args[0]) - } - args = args[1:] -Parsing: - for len(args) > 0 { - arg := args[0] - s.args = args - args = args[1:] - - // end of options? - if arg == "" || arg[0] != '-' { - s.setState(EndOfOptions) - return nil - } - - if arg == "-" { - goto ShortParsing - } - - // explicitly request end of options? - if arg == "--" { - s.args = args - s.setState(DashDash) - return nil - } - - // Long option processing - if len(s.longOptions) > 0 && arg[1] == '-' { - e := strings.IndexRune(arg, '=') - var value string - if e > 0 { - value = arg[e+1:] - arg = arg[:e] - } - opt := s.longOptions[arg[2:]] - // If we are processing long options then --f is -f - // if f is not defined as a long option. - // This lets you say --f=false - if opt == nil && len(arg[2:]) == 1 { - opt = s.shortOptions[rune(arg[2])] - } - if opt == nil { - return unknownOption(arg[2:]) - } - opt.isLong = true - // If we require an option and did not have an = - // then use the next argument as an option. - if !opt.flag && e < 0 && !opt.optional { - if len(args) == 0 { - return missingArg(opt) - } - value = args[0] - args = args[1:] - } - opt.count++ - - if err := opt.value.Set(value, opt); err != nil { - return setError(opt, value, err) - } - - if !fn(opt) { - s.setState(Terminated) - return nil - } - continue Parsing - } - - // Short option processing - arg = arg[1:] // strip - - ShortParsing: - for i, c := range arg { - opt := s.shortOptions[c] - if opt == nil { - // In traditional getopt, if - is not registered - // as an option, a lone - is treated as - // if there were a -- in front of it. - if arg == "-" { - s.setState(Dash) - return nil - } - return unknownOption(c) - } - opt.isLong = false - opt.count++ - var value string - if !opt.flag { - value = arg[1+i:] - if value == "" && !opt.optional { - if len(args) == 0 { - return missingArg(opt) - } - value = args[0] - args = args[1:] - } - } - if err := opt.value.Set(value, opt); err != nil { - return setError(opt, value, err) - } - if !fn(opt) { - s.setState(Terminated) - return nil - } - if !opt.flag { - continue Parsing - } - } - } - s.args = []string{} - return nil -} - -func (s *Set) checkOptions() error { - groups := map[string]Option{} - for _, opt := range s.options { - if !opt.Seen() { - if opt.mandatory { - return fmt.Errorf("option %s is mandatory", opt.Name()) - } - continue - } - if opt.group == "" { - continue - } - if opt2 := groups[opt.group]; opt2 != nil { - return fmt.Errorf("options %s and %s are mutually exclusive", opt2.Name(), opt.Name()) - } - groups[opt.group] = opt - } - for _, group := range s.requiredGroups { - if groups[group] != nil { - continue - } - var flags []string - for _, opt := range s.options { - if opt.group == group { - flags = append(flags, opt.Name()) - } - } - return fmt.Errorf("exactly one of the following options must be specified: %s", strings.Join(flags, ", ")) - } - return nil -} |