diff options
Diffstat (limited to 'vendor/github.com/pborman')
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/LICENSE | 27 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/bool.go | 36 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/counter.go | 69 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/duration.go | 28 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/enum.go | 79 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/error.go | 93 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/generic.go | 247 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/getopt.go | 636 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/int.go | 157 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/list.go | 32 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/option.go | 224 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/set.go | 309 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/signed.go | 110 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/string.go | 27 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/unsigned.go | 111 | ||||
| -rw-r--r-- | vendor/github.com/pborman/getopt/v2/var.go | 100 |
16 files changed, 0 insertions, 2285 deletions
diff --git a/vendor/github.com/pborman/getopt/v2/LICENSE b/vendor/github.com/pborman/getopt/v2/LICENSE deleted file mode 100644 index a8181ec..0000000 --- a/vendor/github.com/pborman/getopt/v2/LICENSE +++ /dev/null @@ -1,27 +0,0 @@ -Copyright (c) 2017 Google Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google, nor the names of other -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/pborman/getopt/v2/bool.go b/vendor/github.com/pborman/getopt/v2/bool.go deleted file mode 100644 index 2899bee..0000000 --- a/vendor/github.com/pborman/getopt/v2/bool.go +++ /dev/null @@ -1,36 +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 - -// Bool creates a flag option that is a bool. Bools normally do not take a -// value however one can be assigned by using the long form of the option: -// -// --option=true -// --o=false -// -// The value is case insensitive and one of true, false, t, f, on, off, t and 0. -func Bool(name rune, helpvalue ...string) *bool { - var b bool - CommandLine.Flag(&b, name, helpvalue...) - return &b -} - -func BoolLong(name string, short rune, helpvalue ...string) *bool { - var p bool - CommandLine.FlagLong(&p, name, short, helpvalue...) - return &p -} - -func (s *Set) Bool(name rune, helpvalue ...string) *bool { - var b bool - s.Flag(&b, name, helpvalue...) - return &b -} - -func (s *Set) BoolLong(name string, short rune, helpvalue ...string) *bool { - var p bool - s.FlagLong(&p, name, short, helpvalue...) - return &p -} diff --git a/vendor/github.com/pborman/getopt/v2/counter.go b/vendor/github.com/pborman/getopt/v2/counter.go deleted file mode 100644 index ab10bc7..0000000 --- a/vendor/github.com/pborman/getopt/v2/counter.go +++ /dev/null @@ -1,69 +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 - -import ( - "fmt" - "strconv" -) - -type counterValue int - -func (b *counterValue) Set(value string, opt Option) error { - if value == "" { - *b++ - } else { - v, err := strconv.ParseInt(value, 0, strconv.IntSize) - if err != nil { - if e, ok := err.(*strconv.NumError); ok { - switch e.Err { - case strconv.ErrRange: - err = fmt.Errorf("value out of range: %s", value) - case strconv.ErrSyntax: - err = fmt.Errorf("not a valid number: %s", value) - } - } - return err - } - *b = counterValue(v) - } - return nil -} - -func (b *counterValue) String() string { - return strconv.Itoa(int(*b)) -} - -// Counter creates a counting flag stored as an int. Each time the option -// is seen while parsing the value is incremented. The value of the counter -// may be explicitly set by using the long form: -// -// --counter=5 -// --c=5 -// -// Further instances of the option will increment from the set value. -func Counter(name rune, helpvalue ...string) *int { - var p int - CommandLine.FlagLong((*counterValue)(&p), "", name, helpvalue...).SetFlag() - return &p -} - -func (s *Set) Counter(name rune, helpvalue ...string) *int { - var p int - s.FlagLong((*counterValue)(&p), "", name, helpvalue...).SetFlag() - return &p -} - -func CounterLong(name string, short rune, helpvalue ...string) *int { - var p int - CommandLine.FlagLong((*counterValue)(&p), name, short, helpvalue...).SetFlag() - return &p -} - -func (s *Set) CounterLong(name string, short rune, helpvalue ...string) *int { - var p int - s.FlagLong((*counterValue)(&p), name, short, helpvalue...).SetFlag() - return &p -} diff --git a/vendor/github.com/pborman/getopt/v2/duration.go b/vendor/github.com/pborman/getopt/v2/duration.go deleted file mode 100644 index 7607815..0000000 --- a/vendor/github.com/pborman/getopt/v2/duration.go +++ /dev/null @@ -1,28 +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 - -import "time" - -// Duration creates an option that parses its value as a time.Duration. -func Duration(name rune, value time.Duration, helpvalue ...string) *time.Duration { - CommandLine.FlagLong(&value, "", name, helpvalue...) - return &value -} - -func (s *Set) Duration(name rune, value time.Duration, helpvalue ...string) *time.Duration { - s.FlagLong(&value, "", name, helpvalue...) - return &value -} - -func DurationLong(name string, short rune, value time.Duration, helpvalue ...string) *time.Duration { - CommandLine.FlagLong(&value, name, short, helpvalue...) - return &value -} - -func (s *Set) DurationLong(name string, short rune, value time.Duration, helpvalue ...string) *time.Duration { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} diff --git a/vendor/github.com/pborman/getopt/v2/enum.go b/vendor/github.com/pborman/getopt/v2/enum.go deleted file mode 100644 index 1ca6ff9..0000000 --- a/vendor/github.com/pborman/getopt/v2/enum.go +++ /dev/null @@ -1,79 +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 - -import ( - "errors" - "fmt" - "sync" -) - -type enumValue string - -var ( - enumValuesMu sync.Mutex - enumValues = make(map[*enumValue]map[string]struct{}) -) - -func (s *enumValue) Set(value string, opt Option) error { - enumValuesMu.Lock() - es, ok := enumValues[s] - enumValuesMu.Unlock() - if !ok || es == nil { - return errors.New("this option has no values") - } - if _, ok := es[value]; !ok { - return errors.New("invalid value: " + value) - } - *s = enumValue(value) - return nil -} - -func (s *enumValue) String() string { - return string(*s) -} - -// Enum creates an option that can only be set to one of the enumerated strings -// passed in values. Passing nil or an empty slice results in an option that -// will always fail. If not "", value is the default value of the enum. If -// value is not listed in values then Enum will produce an error on standard -// error and then exit the program with a status of 1. -func Enum(name rune, values []string, value string, helpvalue ...string) *string { - return CommandLine.Enum(name, values, value, helpvalue...) -} - -func (s *Set) Enum(name rune, values []string, value string, helpvalue ...string) *string { - var p enumValue - p.define(values, value, &option{short: name}) - s.FlagLong(&p, "", name, helpvalue...) - return (*string)(&p) -} - -func EnumLong(name string, short rune, values []string, value string, helpvalue ...string) *string { - return CommandLine.EnumLong(name, short, values, value, helpvalue...) -} - -func (s *Set) EnumLong(name string, short rune, values []string, value string, helpvalue ...string) *string { - var p enumValue - p.define(values, value, &option{short: short, long: name}) - s.FlagLong(&p, name, short, helpvalue...) - return (*string)(&p) -} - -func (e *enumValue) define(values []string, def string, opt Option) { - m := make(map[string]struct{}) - for _, v := range values { - m[v] = struct{}{} - } - enumValuesMu.Lock() - enumValues[e] = m - enumValuesMu.Unlock() - if def != "" { - if err := e.Set(def, nil); err != nil { - fmt.Fprintf(stderr, "setting default for %s: %v\n", opt.Name(), err) - exit(1) - } - } -} diff --git a/vendor/github.com/pborman/getopt/v2/error.go b/vendor/github.com/pborman/getopt/v2/error.go deleted file mode 100644 index 6f668a3..0000000 --- a/vendor/github.com/pborman/getopt/v2/error.go +++ /dev/null @@ -1,93 +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 - -import "fmt" - -// An Error is returned by Getopt when it encounters an error. -type Error struct { - ErrorCode // General reason of failure. - Err error // The actual error. - Parameter string // Parameter passed to option, if any - Name string // Option that cause error, if any -} - -// Error returns the error message, implementing the error interface. -func (i *Error) Error() string { return i.Err.Error() } - -// An ErrorCode indicates what sort of error was encountered. -type ErrorCode int - -const ( - NoError = ErrorCode(iota) - UnknownOption // an invalid option was encountered - MissingParameter // the options parameter is missing - ExtraParameter // a value was set to a long flag - Invalid // attempt to set an invalid value -) - -func (e ErrorCode) String() string { - switch e { - case UnknownOption: - return "unknow option" - case MissingParameter: - return "missing argument" - case ExtraParameter: - return "unxpected value" - case Invalid: - return "error setting value" - } - return "unknown error" -} - -// unknownOption returns an Error indicating an unknown option was -// encountered. -func unknownOption(name interface{}) *Error { - i := &Error{ErrorCode: UnknownOption} - switch n := name.(type) { - case rune: - if n == '-' { - i.Name = "-" - } else { - i.Name = "-" + string(n) - } - case string: - i.Name = "--" + n - } - i.Err = fmt.Errorf("unknown option: %s", i.Name) - return i -} - -// missingArg returns an Error inidicating option o was not passed -// a required paramter. -func missingArg(o Option) *Error { - return &Error{ - ErrorCode: MissingParameter, - Name: o.Name(), - Err: fmt.Errorf("missing parameter for %s", o.Name()), - } -} - -// extraArg returns an Error inidicating option o was passed the -// unexpected paramter value. -func extraArg(o Option, value string) *Error { - return &Error{ - ErrorCode: ExtraParameter, - Name: o.Name(), - Parameter: value, - Err: fmt.Errorf("unexpected parameter passed to %s: %q", o.Name(), value), - } -} - -// setError returns an Error inidicating option o and the specified -// error while setting it to value. -func setError(o Option, value string, err error) *Error { - return &Error{ - ErrorCode: Invalid, - Name: o.Name(), - Parameter: value, - Err: err, - } -} diff --git a/vendor/github.com/pborman/getopt/v2/generic.go b/vendor/github.com/pborman/getopt/v2/generic.go deleted file mode 100644 index 2cead19..0000000 --- a/vendor/github.com/pborman/getopt/v2/generic.go +++ /dev/null @@ -1,247 +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 - -import ( - "fmt" - "strconv" - "strings" - "time" -) - -type generic struct { - p interface{} -} - -// Flag is shorthand for CommandLine.Flag. -func Flag(v interface{}, short rune, helpvalue ...string) Option { - return CommandLine.long(v, "", short, helpvalue...) -} - -// FlagLong is shorthand for CommandLine.LongFlag. -func FlagLong(v interface{}, long string, short rune, helpvalue ...string) Option { - return CommandLine.long(v, long, short, helpvalue...) -} - -// Flag calls FlagLong with only a short flag name. -func (s *Set) Flag(v interface{}, short rune, helpvalue ...string) Option { - return s.long(v, "", short, helpvalue...) -} - -// FlagLong returns an Option in Set s for setting v. If long is not "" then -// the option has a long name, and if short is not 0, the option has a short -// name. v must either be of type getopt.Value or a pointer to one of the -// supported builtin types: -// -// bool, string, []string -// int, int8, int16, int32, int64 -// uint, uint8, uint16, uint32, uint64 -// float32, float64 -// time.Duration -// -// FlagLong will panic if v is not a getopt.Value or one of the supported -// builtin types. -// -// The default value of the flag is the value of v at the time FlagLong is -// called. -func (s *Set) FlagLong(v interface{}, long string, short rune, helpvalue ...string) Option { - return s.long(v, long, short, helpvalue...) -} - -func (s *Set) long(v interface{}, long string, short rune, helpvalue ...string) (opt Option) { - // Fix up our location when we return. - if where := calledFrom(); where != "" { - defer func() { - if opt, ok := opt.(*option); ok { - opt.where = where - } - }() - } - switch p := v.(type) { - case Value: - return s.addFlag(p, long, short, helpvalue...) - case *bool: - return s.addFlag(&generic{v}, long, short, helpvalue...).SetFlag() - case *string, *[]string: - return s.addFlag(&generic{v}, long, short, helpvalue...) - case *int, *int8, *int16, *int32, *int64: - return s.addFlag(&generic{v}, long, short, helpvalue...) - case *uint, *uint8, *uint16, *uint32, *uint64: - return s.addFlag(&generic{v}, long, short, helpvalue...) - case *float32, *float64: - return s.addFlag(&generic{v}, long, short, helpvalue...) - case *time.Duration: - return s.addFlag(&generic{v}, long, short, helpvalue...) - default: - panic(fmt.Sprintf("unsupported flag type: %T", v)) - } -} - -// genericValue returns the object underlying the generic Value v, or nil if v -// is not a generic Value. -func genericValue(v Value) interface{} { - if g, ok := v.(*generic); ok { - return g.p - } - return nil -} - -func (g *generic) Set(value string, opt Option) error { - strconvErr := func(err error) error { - if e, ok := err.(*strconv.NumError); ok { - switch e.Err { - case strconv.ErrRange: - err = fmt.Errorf("value out of range: %s", value) - case strconv.ErrSyntax: - err = fmt.Errorf("not a valid number: %s", value) - } - } - return err - } - switch p := g.p.(type) { - case *bool: - switch strings.ToLower(value) { - case "", "1", "true", "on", "t": - *p = true - case "0", "false", "off", "f": - *p = false - default: - return fmt.Errorf("invalid value for bool %s: %q", opt.Name(), value) - } - return nil - case *string: - *p = value - return nil - case *[]string: - a := strings.Split(value, ",") - // If this is the first time we are seen then nil out the - // default value. - if opt.Count() <= 1 { - *p = nil - } - *p = append(*p, a...) - return nil - case *int: - i64, err := strconv.ParseInt(value, 0, strconv.IntSize) - if err == nil { - *p = int(i64) - } - return strconvErr(err) - case *int8: - i64, err := strconv.ParseInt(value, 0, 8) - if err == nil { - *p = int8(i64) - } - return strconvErr(err) - case *int16: - i64, err := strconv.ParseInt(value, 0, 16) - if err == nil { - *p = int16(i64) - } - return strconvErr(err) - case *int32: - i64, err := strconv.ParseInt(value, 0, 32) - if err == nil { - *p = int32(i64) - } - return strconvErr(err) - case *int64: - i64, err := strconv.ParseInt(value, 0, 64) - if err == nil { - *p = i64 - } - return strconvErr(err) - case *uint: - u64, err := strconv.ParseUint(value, 0, strconv.IntSize) - if err == nil { - *p = uint(u64) - } - return strconvErr(err) - case *uint8: - u64, err := strconv.ParseUint(value, 0, 8) - if err == nil { - *p = uint8(u64) - } - return strconvErr(err) - case *uint16: - u64, err := strconv.ParseUint(value, 0, 16) - if err == nil { - *p = uint16(u64) - } - return strconvErr(err) - case *uint32: - u64, err := strconv.ParseUint(value, 0, 32) - if err == nil { - *p = uint32(u64) - } - return strconvErr(err) - case *uint64: - u64, err := strconv.ParseUint(value, 0, 64) - if err == nil { - *p = u64 - } - return strconvErr(err) - case *float32: - f64, err := strconv.ParseFloat(value, 32) - if err == nil { - *p = float32(f64) - } - return strconvErr(err) - case *float64: - f64, err := strconv.ParseFloat(value, 64) - if err == nil { - *p = f64 - } - return strconvErr(err) - case *time.Duration: - v, err := time.ParseDuration(value) - if err == nil { - *p = v - } - return err - } - panic("internal error") -} - -func (g *generic) String() string { - switch p := g.p.(type) { - case *bool: - if *p { - return "true" - } - return "false" - case *string: - return *p - case *[]string: - return strings.Join([]string(*p), ",") - case *int: - return strconv.FormatInt(int64(*p), 10) - case *int8: - return strconv.FormatInt(int64(*p), 10) - case *int16: - return strconv.FormatInt(int64(*p), 10) - case *int32: - return strconv.FormatInt(int64(*p), 10) - case *int64: - return strconv.FormatInt(*p, 10) - case *uint: - return strconv.FormatUint(uint64(*p), 10) - case *uint8: - return strconv.FormatUint(uint64(*p), 10) - case *uint16: - return strconv.FormatUint(uint64(*p), 10) - case *uint32: - return strconv.FormatUint(uint64(*p), 10) - case *uint64: - return strconv.FormatUint(*p, 10) - case *float32: - return strconv.FormatFloat(float64(*p), 'g', -1, 32) - case *float64: - return strconv.FormatFloat(*p, 'g', -1, 64) - case *time.Duration: - return p.String() - } - panic("internal error") -} 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 -} diff --git a/vendor/github.com/pborman/getopt/v2/int.go b/vendor/github.com/pborman/getopt/v2/int.go deleted file mode 100644 index 42833c1..0000000 --- a/vendor/github.com/pborman/getopt/v2/int.go +++ /dev/null @@ -1,157 +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 - -// Int creates an option that parses its value as an integer. -func Int(name rune, value int, helpvalue ...string) *int { - return CommandLine.Int(name, value, helpvalue...) -} - -func (s *Set) Int(name rune, value int, helpvalue ...string) *int { - s.Flag(&value, name, helpvalue...) - return &value -} - -func IntLong(name string, short rune, value int, helpvalue ...string) *int { - return CommandLine.IntLong(name, short, value, helpvalue...) -} - -func (s *Set) IntLong(name string, short rune, value int, helpvalue ...string) *int { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Int16 creates an option that parses its value as a 16 bit integer. -func Int16(name rune, value int16, helpvalue ...string) *int16 { - return CommandLine.Int16(name, value, helpvalue...) -} - -func (s *Set) Int16(name rune, value int16, helpvalue ...string) *int16 { - s.Flag(&value, name, helpvalue...) - return &value -} - -func Int16Long(name string, short rune, value int16, helpvalue ...string) *int16 { - return CommandLine.Int16Long(name, short, value, helpvalue...) -} - -func (s *Set) Int16Long(name string, short rune, value int16, helpvalue ...string) *int16 { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Int32 creates an option that parses its value as a 32 bit integer. -func Int32(name rune, value int32, helpvalue ...string) *int32 { - return CommandLine.Int32(name, value, helpvalue...) -} - -func (s *Set) Int32(name rune, value int32, helpvalue ...string) *int32 { - s.Flag(&value, name, helpvalue...) - return &value -} - -func Int32Long(name string, short rune, value int32, helpvalue ...string) *int32 { - return CommandLine.Int32Long(name, short, value, helpvalue...) -} - -func (s *Set) Int32Long(name string, short rune, value int32, helpvalue ...string) *int32 { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Int64 creates an option that parses its value as a 64 bit integer. -func Int64(name rune, value int64, helpvalue ...string) *int64 { - return CommandLine.Int64(name, value, helpvalue...) -} - -func (s *Set) Int64(name rune, value int64, helpvalue ...string) *int64 { - s.Flag(&value, name, helpvalue...) - return &value -} - -func Int64Long(name string, short rune, value int64, helpvalue ...string) *int64 { - return CommandLine.Int64Long(name, short, value, helpvalue...) -} - -func (s *Set) Int64Long(name string, short rune, value int64, helpvalue ...string) *int64 { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Uint creates an option that parses its value as an unsigned integer. -func Uint(name rune, value uint, helpvalue ...string) *uint { - return CommandLine.Uint(name, value, helpvalue...) -} - -func (s *Set) Uint(name rune, value uint, helpvalue ...string) *uint { - s.Flag(&value, name, helpvalue...) - return &value -} - -func UintLong(name string, short rune, value uint, helpvalue ...string) *uint { - return CommandLine.UintLong(name, short, value, helpvalue...) -} - -func (s *Set) UintLong(name string, short rune, value uint, helpvalue ...string) *uint { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Uint16 creates an option that parses its value as a 16 bit unsigned integer. -func Uint16(name rune, value uint16, helpvalue ...string) *uint16 { - return CommandLine.Uint16(name, value, helpvalue...) -} - -func (s *Set) Uint16(name rune, value uint16, helpvalue ...string) *uint16 { - s.Flag(&value, name, helpvalue...) - return &value -} - -func Uint16Long(name string, short rune, value uint16, helpvalue ...string) *uint16 { - return CommandLine.Uint16Long(name, short, value, helpvalue...) -} - -func (s *Set) Uint16Long(name string, short rune, value uint16, helpvalue ...string) *uint16 { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Uint32 creates an option that parses its value as a 32 bit unsigned integer. -func Uint32(name rune, value uint32, helpvalue ...string) *uint32 { - return CommandLine.Uint32(name, value, helpvalue...) -} - -func (s *Set) Uint32(name rune, value uint32, helpvalue ...string) *uint32 { - s.Flag(&value, name, helpvalue...) - return &value -} - -func Uint32Long(name string, short rune, value uint32, helpvalue ...string) *uint32 { - return CommandLine.Uint32Long(name, short, value, helpvalue...) -} - -func (s *Set) Uint32Long(name string, short rune, value uint32, helpvalue ...string) *uint32 { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} - -// Uint64 creates an option that parses its value as a 64 bit unsigned integer. -func Uint64(name rune, value uint64, helpvalue ...string) *uint64 { - return CommandLine.Uint64(name, value, helpvalue...) -} - -func (s *Set) Uint64(name rune, value uint64, helpvalue ...string) *uint64 { - s.Flag(&value, name, helpvalue...) - return &value -} - -func Uint64Long(name string, short rune, value uint64, helpvalue ...string) *uint64 { - return CommandLine.Uint64Long(name, short, value, helpvalue...) -} - -func (s *Set) Uint64Long(name string, short rune, value uint64, helpvalue ...string) *uint64 { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} diff --git a/vendor/github.com/pborman/getopt/v2/list.go b/vendor/github.com/pborman/getopt/v2/list.go deleted file mode 100644 index 99a09ef..0000000 --- a/vendor/github.com/pborman/getopt/v2/list.go +++ /dev/null @@ -1,32 +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 - -// List creates an option that returns a slice of strings. The parameters -// passed are converted from a comma separated value list into a slice. -// Subsequent occurrences append to the list. -func List(name rune, helpvalue ...string) *[]string { - p := []string{} - CommandLine.Flag(&p, name, helpvalue...) - return &p -} - -func (s *Set) List(name rune, helpvalue ...string) *[]string { - p := []string{} - s.Flag(&p, name, helpvalue...) - return &p -} - -func ListLong(name string, short rune, helpvalue ...string) *[]string { - p := []string{} - CommandLine.FlagLong(&p, name, short, helpvalue...) - return &p -} - -func (s *Set) ListLong(name string, short rune, helpvalue ...string) *[]string { - p := []string{} - s.FlagLong(&p, name, short, helpvalue...) - return &p -} diff --git a/vendor/github.com/pborman/getopt/v2/option.go b/vendor/github.com/pborman/getopt/v2/option.go deleted file mode 100644 index c97bb29..0000000 --- a/vendor/github.com/pborman/getopt/v2/option.go +++ /dev/null @@ -1,224 +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 - -import ( - "fmt" - "strings" -) - -// An Option can be either a Flag or a Value -type Option interface { - // Name returns the name of the option. If the option has been seen - // then the last way it was referenced (short or long) is returned - // otherwise if there is a short name then this will be the short name - // as a string, else it will be the long name. - Name() string - - // ShortName always returns the short name of the option, or "" if there - // is no short name. The name does not include the "-". - ShortName() string - - // LongName always returns the long name of the option, or "" if there - // is no long name. The name does not include the "--". - LongName() string - - // IsFlag returns true if Option is a flag. - IsFlag() bool - - // Seen returns true if the flag was seen. - Seen() bool - - // Count returns the number of times the flag was seen. - Count() int - - // String returns the last value the option was set to. - String() string - - // Value returns the Value of the option. - Value() Value - - // SetOptional makes the value optional. The option and value are - // always a single argument. Either --option or --option=value. In - // the former case the value of the option does not change but the Set() - // will return true and the value returned by Count() is incremented. - // The short form is either -o or -ovalue. SetOptional returns - // the Option - SetOptional() Option - - // SetFlag makes the value a flag. Flags are boolean values and - // normally do not taken a value. They are set to true when seen. - // If a value is passed in the long form then it must be on, case - // insensitivinsensitive, one of "true", "false", "t", "f", "on", "off", "1", "0". - // SetFlag returns the Option - SetFlag() Option - - // Reset resets the state of the option so it appears it has not - // yet been seen, including resetting the value of the option - // to its original default state. - Reset() - - // Mandataory sets the mandatory flag of the option. Parse will - // fail if a mandatory option is missing. - Mandatory() Option - - // SetGroup sets the option as part of a radio group. Parse will - // fail if two options in the same group are seen. - SetGroup(string) Option -} - -type option struct { - short rune // 0 means no short name - long string // "" means no long name - isLong bool // True if they used the long name - flag bool // true if a boolean flag - defval string // default value - optional bool // true if we take an optional value - help string // help message - where string // file where the option was defined - value Value // current value of option - count int // number of times we have seen this option - name string // name of the value (for usage) - uname string // name of the option (for usage) - mandatory bool // this option must be specified - group string // mutual exclusion group -} - -// usageName returns the name of the option for printing usage lines in one -// of the following forms: -// -// -f -// --flag -// -f, --flag -// -s value -// --set=value -// -s, --set=value -func (o *option) usageName() string { - // Don't print help messages if we have none and there is only one - // way to specify the option. - if o.help == "" && (o.short == 0 || o.long == "") { - return "" - } - n := "" - - switch { - case o.short != 0 && o.long == "": - n = "-" + string(o.short) - case o.short == 0 && o.long != "": - n = " --" + o.long - case o.short != 0 && o.long != "": - n = "-" + string(o.short) + ", --" + o.long - } - - switch { - case o.flag: - return n - case o.optional: - return n + "[=" + o.name + "]" - case o.long != "": - return n + "=" + o.name - } - return n + " " + o.name -} - -// sortName returns the name to sort the option on. -func (o *option) sortName() string { - if o.short != 0 { - return string(o.short) + o.long - } - return o.long[:1] + o.long -} - -func (o *option) Seen() bool { return o.count > 0 } -func (o *option) Count() int { return o.count } -func (o *option) IsFlag() bool { return o.flag } -func (o *option) String() string { return o.value.String() } -func (o *option) SetOptional() Option { o.optional = true; return o } -func (o *option) SetFlag() Option { o.flag = true; return o } -func (o *option) Mandatory() Option { o.mandatory = true; return o } -func (o *option) SetGroup(g string) Option { o.group = g; return o } - -func (o *option) Value() Value { - if o == nil { - return nil - } - return o.value -} - -func (o *option) Name() string { - if !o.isLong && o.short != 0 { - return "-" + string(o.short) - } - return "--" + o.long -} - -func (o *option) ShortName() string { - if o.short != 0 { - return string(o.short) - } - return "" -} - -func (o *option) LongName() string { - return o.long -} - -// Reset rests an option so that it appears it has not yet been seen. -func (o *option) Reset() { - o.isLong = false - o.count = 0 - o.value.Set(o.defval, o) -} - -type optionList []*option - -func (ol optionList) Len() int { return len(ol) } -func (ol optionList) Swap(i, j int) { ol[i], ol[j] = ol[j], ol[i] } -func (ol optionList) Less(i, j int) bool { - // first check the short names (or the first letter of the long name) - // If they are not equal (case insensitive) then we have our answer - n1 := ol[i].sortName() - n2 := ol[j].sortName() - l1 := strings.ToLower(n1) - l2 := strings.ToLower(n2) - if l1 < l2 { - return true - } - if l2 < l1 { - return false - } - return n1 < n2 -} - -// AddOption add the option o to set CommandLine if o is not already in set -// CommandLine. -func AddOption(o Option) { - CommandLine.AddOption(o) -} - -// AddOption add the option o to set s if o is not already in set s. -func (s *Set) AddOption(o Option) { - opt := o.(*option) - for _, eopt := range s.options { - if opt == eopt { - return - } - } - if opt.short != 0 { - if oo, ok := s.shortOptions[opt.short]; ok { - fmt.Fprintf(stderr, "%s: -%c already declared at %s\n", opt.where, opt.short, oo.where) - exit(1) - } - s.shortOptions[opt.short] = opt - } - if opt.long != "" { - if oo, ok := s.longOptions[opt.long]; ok { - fmt.Fprintf(stderr, "%s: --%s already declared at %s\n", opt.where, opt.long, oo.where) - exit(1) - } - s.longOptions[opt.long] = opt - } - s.options = append(s.options, opt) -} diff --git a/vendor/github.com/pborman/getopt/v2/set.go b/vendor/github.com/pborman/getopt/v2/set.go deleted file mode 100644 index 9f73ede..0000000 --- a/vendor/github.com/pborman/getopt/v2/set.go +++ /dev/null @@ -1,309 +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 - -import ( - "io" - "os" - "sort" - "sync" -) - -// A State is why the Getopt returned. -type State int - -const ( - InProgress = State(iota) // Getopt is still running - Dash // Returned on "-" - DashDash // Returned on "--" - EndOfOptions // End of options reached - EndOfArguments // No more arguments - Terminated // Terminated by callback function - Failure // Terminated due to error - Unknown // Indicates internal error -) - -type Set struct { - stateMu sync.Mutex - state State - - // args are the parameters remaining after parsing the optoins. - args []string - - // program is the name of the program for usage and error messages. - // If not set it will automatically be set to the base name of the - // first argument passed to parse. - program string - - // parameters is what is displayed on the usage line after displaying - // the various options. - parameters string - - usage func() // usage should print the programs usage and exit. - - shortOptions map[rune]*option - longOptions map[string]*option - options optionList - requiredGroups []string -} - -// New returns a newly created option set. -func New() *Set { - s := &Set{ - shortOptions: make(map[rune]*option), - longOptions: make(map[string]*option), - parameters: "[parameters ...]", - } - - s.usage = func() { - s.PrintUsage(stderr) - } - return s -} - -func (s *Set) setState(state State) { - s.stateMu.Lock() - s.state = state - s.stateMu.Unlock() -} - -// State returns the current state of the Set s. The state is normally the -// reason the most recent call to Getopt returned. -func (s *Set) State() State { - s.stateMu.Lock() - defer s.stateMu.Unlock() - return s.state -} - -// The default set of command-line options. -var CommandLine = New() - -// PrintUsage calls PrintUsage in the default option set. -func PrintUsage(w io.Writer) { CommandLine.PrintUsage(w) } - -// Usage calls the usage function in the default option set. -func Usage() { CommandLine.usage() } - -// Parse calls Parse in the default option set with the command line arguments -// found in os.Args. -func Parse() { CommandLine.Parse(os.Args) } - -// Same as parse but not found in version 1 of getopt. -func ParseV2() { CommandLine.Parse(os.Args) } - -// Getops returns the result of calling Getop in the default option set with the -// command line arguments found in os.Args. The fn function, which may be nil, -// is passed to Getopt. -func Getopt(fn func(Option) bool) error { return CommandLine.Getopt(os.Args, fn) } - -// Arg returns the n'th command-line argument. Arg(0) is the first remaining -// argument after options have been processed. -func Arg(n int) string { - if n >= 0 && n < len(CommandLine.args) { - return CommandLine.args[n] - } - return "" -} - -// Arg returns the n'th argument. Arg(0) is the first remaining -// argument after options have been processed. -func (s *Set) Arg(n int) string { - if n >= 0 && n < len(s.args) { - return s.args[n] - } - return "" -} - -// Args returns the non-option command line arguments. -func Args() []string { - return CommandLine.args -} - -// Args returns the non-option arguments. -func (s *Set) Args() []string { - return s.args -} - -// NArgs returns the number of non-option command line arguments. -func NArgs() int { - return len(CommandLine.args) -} - -// NArgs returns the number of non-option arguments. -func (s *Set) NArgs() int { - return len(s.args) -} - -// SetParameters sets the parameters string for printing the command line -// usage. It defaults to "[parameters ...]" -func SetParameters(parameters string) { - CommandLine.parameters = parameters -} - -// SetParameters sets the parameters string for printing the s's usage. -// It defaults to "[parameters ...]" -func (s *Set) SetParameters(parameters string) { - s.parameters = parameters -} - -// Parameters returns the parameters set by SetParameters on s. -func (s *Set) Parameters() string { return s.parameters } - -// SetProgram sets the program name to program. Normally it is determined -// from the zeroth command line argument (see os.Args). -func SetProgram(program string) { - CommandLine.program = program -} - -// SetProgram sets s's program name to program. Normally it is determined -// from the zeroth argument passed to Getopt or Parse. -func (s *Set) SetProgram(program string) { - s.program = program -} - -// Program returns the program name associated with Set s. -func (s *Set) Program() string { return s.program } - -// SetUsage sets the function used by Parse to display the commands usage -// on error. It defaults to calling PrintUsage(os.Stderr). -func SetUsage(usage func()) { - CommandLine.usage = usage -} - -// SetUsage sets the function used by Parse to display usage on error. It -// defaults to calling f.PrintUsage(os.Stderr). -func (s *Set) SetUsage(usage func()) { - s.usage = usage -} - -// Lookup returns the Option associated with name. Name should either be -// a rune (the short name) or a string (the long name). -func Lookup(name interface{}) Option { - return CommandLine.Lookup(name) -} - -// Lookup returns the Option associated with name in s. Name should either be -// a rune (the short name) or a string (the long name). -func (s *Set) Lookup(name interface{}) Option { - switch v := name.(type) { - case rune: - return s.shortOptions[v] - case int: - return s.shortOptions[rune(v)] - case string: - return s.longOptions[v] - } - return nil -} - -// IsSet returns true if the Option associated with name was seen while -// parsing the command line arguments. Name should either be a rune (the -// short name) or a string (the long name). -func IsSet(name interface{}) bool { - return CommandLine.IsSet(name) -} - -// IsSet returns true if the Option associated with name was seen while -// parsing s. Name should either be a rune (the short name) or a string (the -// long name). -func (s *Set) IsSet(name interface{}) bool { - if opt := s.Lookup(name); opt != nil { - return opt.Seen() - } - return false -} - -// GetCount returns the number of times the Option associated with name has been -// seen while parsing the command line arguments. Name should either be a rune -// (the short name) or a string (the long name). -func GetCount(name interface{}) int { - return CommandLine.GetCount(name) -} - -// GetCount returns the number of times the Option associated with name has been -// seen while parsing s's arguments. Name should either be a rune (the short -// name) or a string (the long name). -func (s *Set) GetCount(name interface{}) int { - if opt := s.Lookup(name); opt != nil { - return opt.Count() - } - return 0 -} - -// GetValue returns the final value set to the command-line Option with name. -// If the option has not been seen while parsing s then the default value is -// returned. Name should either be a rune (the short name) or a string (the -// long name). -func GetValue(name interface{}) string { - return CommandLine.GetValue(name) -} - -// GetValue returns the final value set to the Option in s associated with name. -// If the option has not been seen while parsing s then the default value is -// returned. Name should either be a rune (the short name) or a string (the -// long name). -func (s *Set) GetValue(name interface{}) string { - if opt := s.Lookup(name); opt != nil { - return opt.String() - } - return "" -} - -// Visit visits the command-line options in lexicographical order, calling fn -// for each. It visits only those options that have been set. -func Visit(fn func(Option)) { CommandLine.Visit(fn) } - -// Visit visits the options in s in lexicographical order, calling fn -// for each. It visits only those options that have been set. -func (s *Set) Visit(fn func(Option)) { - sort.Sort(s.options) - for _, opt := range s.options { - if opt.count > 0 { - fn(opt) - } - } -} - -// VisitAll visits the options in s in lexicographical order, calling fn -// for each. It visits all options, even those not set. -func VisitAll(fn func(Option)) { CommandLine.VisitAll(fn) } - -// VisitAll visits the command-line flags in lexicographical order, calling fn -// for each. It visits all flags, even those not set. -func (s *Set) VisitAll(fn func(Option)) { - sort.Sort(s.options) - for _, opt := range s.options { - fn(opt) - } -} - -// Reset resets all the command line options to the initial state so it -// appears none of them have been seen. -func Reset() { - CommandLine.Reset() -} - -// Reset resets all the options in s to the initial state so it -// appears none of them have been seen. -func (s *Set) Reset() { - for _, opt := range s.options { - opt.Reset() - } -} - -// RequiredGroup marks the group set with Option.SetGroup as required. At least -// one option in the group must be seen by parse. Calling RequiredGroup with a -// group name that has no options will cause parsing to always fail. -func (s *Set) RequiredGroup(group string) { - s.requiredGroups = append(s.requiredGroups, group) -} - -// RequiredGroup marks the group set with Option.SetGroup as required on the -// command line. At least one option in the group must be seen by parse. -// Calling RequiredGroup with a group name that has no options will cause -// parsing to always fail. -func RequiredGroup(group string) { - CommandLine.requiredGroups = append(CommandLine.requiredGroups, group) -} diff --git a/vendor/github.com/pborman/getopt/v2/signed.go b/vendor/github.com/pborman/getopt/v2/signed.go deleted file mode 100644 index dc371a7..0000000 --- a/vendor/github.com/pborman/getopt/v2/signed.go +++ /dev/null @@ -1,110 +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 - -import ( - "fmt" - "strconv" - "sync" -) - -type signed int64 - -type SignedLimit struct { - Base int // Base for conversion as per strconv.ParseInt - Bits int // Number of bits as per strconv.ParseInt - Min int64 // Minimum allowed value if both Min and Max are not 0 - Max int64 // Maximum allowed value if both Min and Max are not 0 -} - -var ( - signedLimitsMu sync.Mutex - signedLimits = make(map[*signed]*SignedLimit) -) - -func (n *signed) Set(value string, opt Option) error { - signedLimitsMu.Lock() - l := signedLimits[n] - signedLimitsMu.Unlock() - if l == nil { - return fmt.Errorf("no limits defined for %s", opt.Name()) - } - v, err := strconv.ParseInt(value, l.Base, l.Bits) - if err != nil { - if e, ok := err.(*strconv.NumError); ok { - switch e.Err { - case strconv.ErrRange: - err = fmt.Errorf("value out of range: %s", value) - case strconv.ErrSyntax: - err = fmt.Errorf("not a valid number: %s", value) - } - } - return err - } - if l.Min != 0 || l.Max != 0 { - if v < l.Min { - return fmt.Errorf("value out of range (<%v): %s", l.Min, value) - } - if v > l.Max { - return fmt.Errorf("value out of range (>%v): %s", l.Max, value) - } - } - *n = signed(v) - return nil -} - -func (n *signed) String() string { - signedLimitsMu.Lock() - l := signedLimits[n] - signedLimitsMu.Unlock() - if l != nil && l.Base != 0 { - return strconv.FormatInt(int64(*n), l.Base) - } - return strconv.FormatInt(int64(*n), 10) -} - -// Signed creates an option that is stored in an int64 and is constrained -// by the limits pointed to by l. The Max and Min values are only used if -// at least one of the values are not 0. If Base is 0, the base is implied by -// the string's prefix: base 16 for "0x", base 8 for "0", and base 10 otherwise. -func Signed(name rune, value int64, l *SignedLimit, helpvalue ...string) *int64 { - CommandLine.signedOption(&value, "", name, l, helpvalue...) - return &value -} - -func (s *Set) Signed(name rune, value int64, l *SignedLimit, helpvalue ...string) *int64 { - s.signedOption(&value, "", name, l, helpvalue...) - return &value -} - -func SignedLong(name string, short rune, value int64, l *SignedLimit, helpvalue ...string) *int64 { - CommandLine.signedOption(&value, name, short, l, helpvalue...) - return &value -} - -func (s *Set) SignedLong(name string, short rune, value int64, l *SignedLimit, helpvalue ...string) *int64 { - s.signedOption(&value, name, short, l, helpvalue...) - return &value -} - -func (s *Set) signedOption(p *int64, name string, short rune, l *SignedLimit, helpvalue ...string) { - opt := s.FlagLong((*signed)(p), name, short, helpvalue...) - if l.Base > 36 || l.Base == 1 || l.Base < 0 { - fmt.Fprintf(stderr, "invalid base for %s: %d\n", opt.Name(), l.Base) - exit(1) - } - if l.Bits < 0 || l.Bits > 64 { - fmt.Fprintf(stderr, "invalid bit size for %s: %d\n", opt.Name(), l.Bits) - exit(1) - } - if l.Min > l.Max { - fmt.Fprintf(stderr, "min greater than max for %s\n", opt.Name()) - exit(1) - } - lim := *l - signedLimitsMu.Lock() - signedLimits[(*signed)(p)] = &lim - signedLimitsMu.Unlock() -} diff --git a/vendor/github.com/pborman/getopt/v2/string.go b/vendor/github.com/pborman/getopt/v2/string.go deleted file mode 100644 index cab5733..0000000 --- a/vendor/github.com/pborman/getopt/v2/string.go +++ /dev/null @@ -1,27 +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 - -// String returns a value option that stores is value as a string. The -// initial value of the string is passed in value. -func String(name rune, value string, helpvalue ...string) *string { - CommandLine.Flag(&value, name, helpvalue...) - return &value -} - -func (s *Set) String(name rune, value string, helpvalue ...string) *string { - s.Flag(&value, name, helpvalue...) - return &value -} - -func StringLong(name string, short rune, value string, helpvalue ...string) *string { - CommandLine.FlagLong(&value, name, short, helpvalue...) - return &value -} - -func (s *Set) StringLong(name string, short rune, value string, helpvalue ...string) *string { - s.FlagLong(&value, name, short, helpvalue...) - return &value -} diff --git a/vendor/github.com/pborman/getopt/v2/unsigned.go b/vendor/github.com/pborman/getopt/v2/unsigned.go deleted file mode 100644 index 5594660..0000000 --- a/vendor/github.com/pborman/getopt/v2/unsigned.go +++ /dev/null @@ -1,111 +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 - -import ( - "fmt" - "strconv" - "sync" -) - -type unsigned uint64 - -type UnsignedLimit struct { - Base int // Base for conversion as per strconv.ParseInt - Bits int // Number of bits as per strconv.ParseInt - Min uint64 // Minimum allowed value if both Min and Max are not 0 - Max uint64 // Maximum allowed value if both Min and Max are not 0 -} - -var ( - unsignedLimitsMu sync.Mutex - unsignedLimits = make(map[*unsigned]*UnsignedLimit) -) - -func (n *unsigned) Set(value string, opt Option) error { - unsignedLimitsMu.Lock() - l := unsignedLimits[n] - unsignedLimitsMu.Unlock() - if l == nil { - return fmt.Errorf("no limits defined for %s", opt.Name()) - } - v, err := strconv.ParseUint(value, l.Base, l.Bits) - if err != nil { - if e, ok := err.(*strconv.NumError); ok { - switch e.Err { - case strconv.ErrRange: - err = fmt.Errorf("value out of range: %s", value) - case strconv.ErrSyntax: - err = fmt.Errorf("not a valid number: %s", value) - } - } - return err - } - if l.Min != 0 || l.Max != 0 { - if v < l.Min { - return fmt.Errorf("value out of range (<%v): %s", l.Min, value) - } - if v > l.Max { - return fmt.Errorf("value out of range (>%v): %s", l.Max, value) - } - } - *n = unsigned(v) - return nil -} - -func (n *unsigned) String() string { - unsignedLimitsMu.Lock() - l := unsignedLimits[n] - unsignedLimitsMu.Unlock() - if l != nil && l.Base != 0 { - return strconv.FormatUint(uint64(*n), l.Base) - } - return strconv.FormatUint(uint64(*n), 10) -} - -// Unsigned creates an option that is stored in a uint64 and is -// constrained by the limits pointed to by l. The Max and Min values are only -// used if at least one of the values are not 0. If Base is 0, the base is -// implied by the string's prefix: base 16 for "0x", base 8 for "0", and base -// 10 otherwise. -func Unsigned(name rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 { - CommandLine.unsignedOption(&value, "", name, l, helpvalue...) - return &value -} - -func (s *Set) Unsigned(name rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 { - s.unsignedOption(&value, "", name, l, helpvalue...) - return &value -} - -func UnsignedLong(name string, short rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 { - CommandLine.unsignedOption(&value, name, short, l, helpvalue...) - return &value -} - -func (s *Set) UnsignedLong(name string, short rune, value uint64, l *UnsignedLimit, helpvalue ...string) *uint64 { - s.unsignedOption(&value, name, short, l, helpvalue...) - return &value -} - -func (s *Set) unsignedOption(p *uint64, name string, short rune, l *UnsignedLimit, helpvalue ...string) { - opt := s.FlagLong((*unsigned)(p), name, short, helpvalue...) - if l.Base > 36 || l.Base == 1 || l.Base < 0 { - fmt.Fprintf(stderr, "invalid base for %s: %d\n", opt.Name(), l.Base) - exit(1) - } - if l.Bits < 0 || l.Bits > 64 { - fmt.Fprintf(stderr, "invalid bit size for %s: %d\n", opt.Name(), l.Bits) - exit(1) - } - if l.Min > l.Max { - fmt.Fprintf(stderr, "min greater than max for %s\n", opt.Name()) - exit(1) - } - lim := *l - unsignedLimitsMu.Lock() - unsignedLimits[(*unsigned)(p)] = &lim - unsignedLimitsMu.Unlock() -} diff --git a/vendor/github.com/pborman/getopt/v2/var.go b/vendor/github.com/pborman/getopt/v2/var.go deleted file mode 100644 index c60a9d2..0000000 --- a/vendor/github.com/pborman/getopt/v2/var.go +++ /dev/null @@ -1,100 +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 - -import ( - "fmt" - "runtime" - "strings" -) - -// Value is the interface to the dynamic value stored in a flag. Flags of type -// Value are declared using the Flag and FlagLong functions. -type Value interface { - // Set converts value into the appropriate type and assigns it to the - // receiver value. Option details are provided via opt (such as the - // flags name). - // - // Set is used to reset the value of an option to its default value - // (which is stored in string form internally). - Set(value string, opt Option) error - - // String returns the value of the flag as a string. - String() string -} - -var thisPackage string - -// init initializes thisPackage to our full package with the trailing . -// included. -func init() { - pc, _, _, ok := runtime.Caller(0) - if !ok { - return - } - f := runtime.FuncForPC(pc) - if f == nil { - return - } - thisPackage = f.Name() - x := strings.LastIndex(thisPackage, "/") - if x < 0 { - return - } - y := strings.Index(thisPackage[x:], ".") - if y < 0 { - return - } - // thisPackage includes the trailing . after the package name. - thisPackage = thisPackage[:x+y+1] -} - -// calledFrom returns a string containing the file and linenumber of the first -// stack frame above us that is not part of this package and is not a test. -// This is used to determine where a flag was initialized. -func calledFrom() string { - for i := 2; ; i++ { - pc, file, line, ok := runtime.Caller(i) - if !ok { - return "" - } - if !strings.HasSuffix(file, "_test.go") { - f := runtime.FuncForPC(pc) - if f != nil && strings.HasPrefix(f.Name(), thisPackage) { - continue - } - } - return fmt.Sprintf("%s:%d", file, line) - } -} - -func (s *Set) addFlag(p Value, name string, short rune, helpvalue ...string) Option { - opt := &option{ - short: short, - long: name, - value: p, - defval: p.String(), - } - - switch len(helpvalue) { - case 2: - opt.name = helpvalue[1] - fallthrough - case 1: - opt.help = helpvalue[0] - case 0: - default: - panic("Too many strings for String helpvalue") - } - if where := calledFrom(); where != "" { - opt.where = where - } - if opt.short == 0 && opt.long == "" { - fmt.Fprintf(stderr, opt.where+": no short or long option given") - exit(1) - } - s.AddOption(opt) - return opt -} |