Added vendor lock on depsHEADmaster

1 files changed, 729 insertions, 0 deletions

diff --git a/vendor/github.com/alexflint/go-arg/parse.go b/vendor/github.com/alexflint/go-arg/parse.go
new file mode 100644
index 0000000..7588dfb
--- /dev/null
+++ b/vendor/github.com/alexflint/go-arg/parse.go
@@ -0,0 +1,729 @@
+package arg
+
+import (
+	"encoding"
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	scalar "github.com/alexflint/go-scalar"
+)
+
+// path represents a sequence of steps to find the output location for an
+// argument or subcommand in the final destination struct
+type path struct {
+	root   int                   // index of the destination struct
+	fields []reflect.StructField // sequence of struct fields to traverse
+}
+
+// String gets a string representation of the given path
+func (p path) String() string {
+	s := "args"
+	for _, f := range p.fields {
+		s += "." + f.Name
+	}
+	return s
+}
+
+// Child gets a new path representing a child of this path.
+func (p path) Child(f reflect.StructField) path {
+	// copy the entire slice of fields to avoid possible slice overwrite
+	subfields := make([]reflect.StructField, len(p.fields)+1)
+	copy(subfields, p.fields)
+	subfields[len(subfields)-1] = f
+	return path{
+		root:   p.root,
+		fields: subfields,
+	}
+}
+
+// spec represents a command line option
+type spec struct {
+	dest        path
+	field       reflect.StructField // the struct field from which this option was created
+	long        string              // the --long form for this option, or empty if none
+	short       string              // the -s short form for this option, or empty if none
+	cardinality cardinality         // determines how many tokens will be present (possible values: zero, one, multiple)
+	required    bool                // if true, this option must be present on the command line
+	positional  bool                // if true, this option will be looked for in the positional flags
+	separate    bool                // if true, each slice and map entry will have its own --flag
+	help        string              // the help text for this option
+	env         string              // the name of the environment variable for this option, or empty for none
+	defaultVal  string              // default value for this option
+	placeholder string              // name of the data in help
+}
+
+// command represents a named subcommand, or the top-level command
+type command struct {
+	name        string
+	help        string
+	dest        path
+	specs       []*spec
+	subcommands []*command
+	parent      *command
+}
+
+// ErrHelp indicates that -h or --help were provided
+var ErrHelp = errors.New("help requested by user")
+
+// ErrVersion indicates that --version was provided
+var ErrVersion = errors.New("version requested by user")
+
+// MustParse processes command line arguments and exits upon failure
+func MustParse(dest ...interface{}) *Parser {
+	p, err := NewParser(Config{}, dest...)
+	if err != nil {
+		fmt.Fprintln(stdout, err)
+		osExit(-1)
+		return nil // just in case osExit was monkey-patched
+	}
+
+	err = p.Parse(flags())
+	switch {
+	case err == ErrHelp:
+		p.writeHelpForSubcommand(stdout, p.lastCmd)
+		osExit(0)
+	case err == ErrVersion:
+		fmt.Fprintln(stdout, p.version)
+		osExit(0)
+	case err != nil:
+		p.failWithSubcommand(err.Error(), p.lastCmd)
+	}
+
+	return p
+}
+
+// Parse processes command line arguments and stores them in dest
+func Parse(dest ...interface{}) error {
+	p, err := NewParser(Config{}, dest...)
+	if err != nil {
+		return err
+	}
+	return p.Parse(flags())
+}
+
+// flags gets all command line arguments other than the first (program name)
+func flags() []string {
+	if len(os.Args) == 0 { // os.Args could be empty
+		return nil
+	}
+	return os.Args[1:]
+}
+
+// Config represents configuration options for an argument parser
+type Config struct {
+	// Program is the name of the program used in the help text
+	Program string
+
+	// IgnoreEnv instructs the library not to read environment variables
+	IgnoreEnv bool
+}
+
+// Parser represents a set of command line options with destination values
+type Parser struct {
+	cmd         *command
+	roots       []reflect.Value
+	config      Config
+	version     string
+	description string
+
+	// the following field changes during processing of command line arguments
+	lastCmd *command
+}
+
+// Versioned is the interface that the destination struct should implement to
+// make a version string appear at the top of the help message.
+type Versioned interface {
+	// Version returns the version string that will be printed on a line by itself
+	// at the top of the help message.
+	Version() string
+}
+
+// Described is the interface that the destination struct should implement to
+// make a description string appear at the top of the help message.
+type Described interface {
+	// Description returns the string that will be printed on a line by itself
+	// at the top of the help message.
+	Description() string
+}
+
+// walkFields calls a function for each field of a struct, recursively expanding struct fields.
+func walkFields(t reflect.Type, visit func(field reflect.StructField, owner reflect.Type) bool) {
+	walkFieldsImpl(t, visit, nil)
+}
+
+func walkFieldsImpl(t reflect.Type, visit func(field reflect.StructField, owner reflect.Type) bool, path []int) {
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		field.Index = make([]int, len(path)+1)
+		copy(field.Index, append(path, i))
+		expand := visit(field, t)
+		if expand && field.Type.Kind() == reflect.Struct {
+			var subpath []int
+			if field.Anonymous {
+				subpath = append(path, i)
+			}
+			walkFieldsImpl(field.Type, visit, subpath)
+		}
+	}
+}
+
+// NewParser constructs a parser from a list of destination structs
+func NewParser(config Config, dests ...interface{}) (*Parser, error) {
+	// first pick a name for the command for use in the usage text
+	var name string
+	switch {
+	case config.Program != "":
+		name = config.Program
+	case len(os.Args) > 0:
+		name = filepath.Base(os.Args[0])
+	default:
+		name = "program"
+	}
+
+	// construct a parser
+	p := Parser{
+		cmd:    &command{name: name},
+		config: config,
+	}
+
+	// make a list of roots
+	for _, dest := range dests {
+		p.roots = append(p.roots, reflect.ValueOf(dest))
+	}
+
+	// process each of the destination values
+	for i, dest := range dests {
+		t := reflect.TypeOf(dest)
+		if t.Kind() != reflect.Ptr {
+			panic(fmt.Sprintf("%s is not a pointer (did you forget an ampersand?)", t))
+		}
+
+		cmd, err := cmdFromStruct(name, path{root: i}, t)
+		if err != nil {
+			return nil, err
+		}
+
+		// add nonzero field values as defaults
+		for _, spec := range cmd.specs {
+			if v := p.val(spec.dest); v.IsValid() && !isZero(v) {
+				if defaultVal, ok := v.Interface().(encoding.TextMarshaler); ok {
+					str, err := defaultVal.MarshalText()
+					if err != nil {
+						return nil, fmt.Errorf("%v: error marshaling default value to string: %v", spec.dest, err)
+					}
+					spec.defaultVal = string(str)
+				} else {
+					spec.defaultVal = fmt.Sprintf("%v", v)
+				}
+			}
+		}
+
+		p.cmd.specs = append(p.cmd.specs, cmd.specs...)
+		p.cmd.subcommands = append(p.cmd.subcommands, cmd.subcommands...)
+
+		if dest, ok := dest.(Versioned); ok {
+			p.version = dest.Version()
+		}
+		if dest, ok := dest.(Described); ok {
+			p.description = dest.Description()
+		}
+	}
+
+	return &p, nil
+}
+
+func cmdFromStruct(name string, dest path, t reflect.Type) (*command, error) {
+	// commands can only be created from pointers to structs
+	if t.Kind() != reflect.Ptr {
+		return nil, fmt.Errorf("subcommands must be pointers to structs but %s is a %s",
+			dest, t.Kind())
+	}
+
+	t = t.Elem()
+	if t.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("subcommands must be pointers to structs but %s is a pointer to %s",
+			dest, t.Kind())
+	}
+
+	cmd := command{
+		name: name,
+		dest: dest,
+	}
+
+	var errs []string
+	walkFields(t, func(field reflect.StructField, t reflect.Type) bool {
+		// check for the ignore switch in the tag
+		tag := field.Tag.Get("arg")
+		if tag == "-" {
+			return false
+		}
+
+		// if this is an embedded struct then recurse into its fields, even if
+		// it is unexported, because exported fields on unexported embedded
+		// structs are still writable
+		if field.Anonymous && field.Type.Kind() == reflect.Struct {
+			return true
+		}
+
+		// ignore any other unexported field
+		if !isExported(field.Name) {
+			return false
+		}
+
+		// duplicate the entire path to avoid slice overwrites
+		subdest := dest.Child(field)
+		spec := spec{
+			dest:  subdest,
+			field: field,
+			long:  strings.ToLower(field.Name),
+		}
+
+		help, exists := field.Tag.Lookup("help")
+		if exists {
+			spec.help = help
+		}
+
+		defaultVal, hasDefault := field.Tag.Lookup("default")
+		if hasDefault {
+			spec.defaultVal = defaultVal
+		}
+
+		// Look at the tag
+		var isSubcommand bool // tracks whether this field is a subcommand
+		for _, key := range strings.Split(tag, ",") {
+			if key == "" {
+				continue
+			}
+			key = strings.TrimLeft(key, " ")
+			var value string
+			if pos := strings.Index(key, ":"); pos != -1 {
+				value = key[pos+1:]
+				key = key[:pos]
+			}
+
+			switch {
+			case strings.HasPrefix(key, "---"):
+				errs = append(errs, fmt.Sprintf("%s.%s: too many hyphens", t.Name(), field.Name))
+			case strings.HasPrefix(key, "--"):
+				spec.long = key[2:]
+			case strings.HasPrefix(key, "-"):
+				if len(key) != 2 {
+					errs = append(errs, fmt.Sprintf("%s.%s: short arguments must be one character only",
+						t.Name(), field.Name))
+					return false
+				}
+				spec.short = key[1:]
+			case key == "required":
+				if hasDefault {
+					errs = append(errs, fmt.Sprintf("%s.%s: 'required' cannot be used when a default value is specified",
+						t.Name(), field.Name))
+					return false
+				}
+				spec.required = true
+			case key == "positional":
+				spec.positional = true
+			case key == "separate":
+				spec.separate = true
+			case key == "help": // deprecated
+				spec.help = value
+			case key == "env":
+				// Use override name if provided
+				if value != "" {
+					spec.env = value
+				} else {
+					spec.env = strings.ToUpper(field.Name)
+				}
+			case key == "subcommand":
+				// decide on a name for the subcommand
+				cmdname := value
+				if cmdname == "" {
+					cmdname = strings.ToLower(field.Name)
+				}
+
+				// parse the subcommand recursively
+				subcmd, err := cmdFromStruct(cmdname, subdest, field.Type)
+				if err != nil {
+					errs = append(errs, err.Error())
+					return false
+				}
+
+				subcmd.parent = &cmd
+				subcmd.help = field.Tag.Get("help")
+
+				cmd.subcommands = append(cmd.subcommands, subcmd)
+				isSubcommand = true
+			default:
+				errs = append(errs, fmt.Sprintf("unrecognized tag '%s' on field %s", key, tag))
+				return false
+			}
+		}
+
+		placeholder, hasPlaceholder := field.Tag.Lookup("placeholder")
+		if hasPlaceholder {
+			spec.placeholder = placeholder
+		} else if spec.long != "" {
+			spec.placeholder = strings.ToUpper(spec.long)
+		} else {
+			spec.placeholder = strings.ToUpper(spec.field.Name)
+		}
+
+		// Check whether this field is supported. It's good to do this here rather than
+		// wait until ParseValue because it means that a program with invalid argument
+		// fields will always fail regardless of whether the arguments it received
+		// exercised those fields.
+		if !isSubcommand {
+			cmd.specs = append(cmd.specs, &spec)
+
+			var err error
+			spec.cardinality, err = cardinalityOf(field.Type)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("%s.%s: %s fields are not supported",
+					t.Name(), field.Name, field.Type.String()))
+				return false
+			}
+			if spec.cardinality == multiple && hasDefault {
+				errs = append(errs, fmt.Sprintf("%s.%s: default values are not supported for slice or map fields",
+					t.Name(), field.Name))
+				return false
+			}
+		}
+
+		// if this was an embedded field then we already returned true up above
+		return false
+	})
+
+	if len(errs) > 0 {
+		return nil, errors.New(strings.Join(errs, "\n"))
+	}
+
+	// check that we don't have both positionals and subcommands
+	var hasPositional bool
+	for _, spec := range cmd.specs {
+		if spec.positional {
+			hasPositional = true
+		}
+	}
+	if hasPositional && len(cmd.subcommands) > 0 {
+		return nil, fmt.Errorf("%s cannot have both subcommands and positional arguments", dest)
+	}
+
+	return &cmd, nil
+}
+
+// Parse processes the given command line option, storing the results in the field
+// of the structs from which NewParser was constructed
+func (p *Parser) Parse(args []string) error {
+	err := p.process(args)
+	if err != nil {
+		// If -h or --help were specified then make sure help text supercedes other errors
+		for _, arg := range args {
+			if arg == "-h" || arg == "--help" {
+				return ErrHelp
+			}
+			if arg == "--" {
+				break
+			}
+		}
+	}
+	return err
+}
+
+// process environment vars for the given arguments
+func (p *Parser) captureEnvVars(specs []*spec, wasPresent map[*spec]bool) error {
+	for _, spec := range specs {
+		if spec.env == "" {
+			continue
+		}
+
+		value, found := os.LookupEnv(spec.env)
+		if !found {
+			continue
+		}
+
+		if spec.cardinality == multiple {
+			// expect a CSV string in an environment
+			// variable in the case of multiple values
+			var values []string
+			var err error
+			if len(strings.TrimSpace(value)) > 0 {
+				values, err = csv.NewReader(strings.NewReader(value)).Read()
+				if err != nil {
+					return fmt.Errorf(
+						"error reading a CSV string from environment variable %s with multiple values: %v",
+						spec.env,
+						err,
+					)
+				}
+			}
+			if err = setSliceOrMap(p.val(spec.dest), values, !spec.separate); err != nil {
+				return fmt.Errorf(
+					"error processing environment variable %s with multiple values: %v",
+					spec.env,
+					err,
+				)
+			}
+		} else {
+			if err := scalar.ParseValue(p.val(spec.dest), value); err != nil {
+				return fmt.Errorf("error processing environment variable %s: %v", spec.env, err)
+			}
+		}
+		wasPresent[spec] = true
+	}
+
+	return nil
+}
+
+// process goes through arguments one-by-one, parses them, and assigns the result to
+// the underlying struct field
+func (p *Parser) process(args []string) error {
+	// track the options we have seen
+	wasPresent := make(map[*spec]bool)
+
+	// union of specs for the chain of subcommands encountered so far
+	curCmd := p.cmd
+	p.lastCmd = curCmd
+
+	// make a copy of the specs because we will add to this list each time we expand a subcommand
+	specs := make([]*spec, len(curCmd.specs))
+	copy(specs, curCmd.specs)
+
+	// deal with environment vars
+	if !p.config.IgnoreEnv {
+		err := p.captureEnvVars(specs, wasPresent)
+		if err != nil {
+			return err
+		}
+	}
+
+	// process each string from the command line
+	var allpositional bool
+	var positionals []string
+
+	// must use explicit for loop, not range, because we manipulate i inside the loop
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		if arg == "--" {
+			allpositional = true
+			continue
+		}
+
+		if !isFlag(arg) || allpositional {
+			// each subcommand can have either subcommands or positionals, but not both
+			if len(curCmd.subcommands) == 0 {
+				positionals = append(positionals, arg)
+				continue
+			}
+
+			// if we have a subcommand then make sure it is valid for the current context
+			subcmd := findSubcommand(curCmd.subcommands, arg)
+			if subcmd == nil {
+				return fmt.Errorf("invalid subcommand: %s", arg)
+			}
+
+			// instantiate the field to point to a new struct
+			v := p.val(subcmd.dest)
+			v.Set(reflect.New(v.Type().Elem())) // we already checked that all subcommands are struct pointers
+
+			// add the new options to the set of allowed options
+			specs = append(specs, subcmd.specs...)
+
+			// capture environment vars for these new options
+			if !p.config.IgnoreEnv {
+				err := p.captureEnvVars(subcmd.specs, wasPresent)
+				if err != nil {
+					return err
+				}
+			}
+
+			curCmd = subcmd
+			p.lastCmd = curCmd
+			continue
+		}
+
+		// check for special --help and --version flags
+		switch arg {
+		case "-h", "--help":
+			return ErrHelp
+		case "--version":
+			return ErrVersion
+		}
+
+		// check for an equals sign, as in "--foo=bar"
+		var value string
+		opt := strings.TrimLeft(arg, "-")
+		if pos := strings.Index(opt, "="); pos != -1 {
+			value = opt[pos+1:]
+			opt = opt[:pos]
+		}
+
+		// lookup the spec for this option (note that the "specs" slice changes as
+		// we expand subcommands so it is better not to use a map)
+		spec := findOption(specs, opt)
+		if spec == nil {
+			return fmt.Errorf("unknown argument %s", arg)
+		}
+		wasPresent[spec] = true
+
+		// deal with the case of multiple values
+		if spec.cardinality == multiple {
+			var values []string
+			if value == "" {
+				for i+1 < len(args) && !isFlag(args[i+1]) && args[i+1] != "--" {
+					values = append(values, args[i+1])
+					i++
+					if spec.separate {
+						break
+					}
+				}
+			} else {
+				values = append(values, value)
+			}
+			err := setSliceOrMap(p.val(spec.dest), values, !spec.separate)
+			if err != nil {
+				return fmt.Errorf("error processing %s: %v", arg, err)
+			}
+			continue
+		}
+
+		// if it's a flag and it has no value then set the value to true
+		// use boolean because this takes account of TextUnmarshaler
+		if spec.cardinality == zero && value == "" {
+			value = "true"
+		}
+
+		// if we have something like "--foo" then the value is the next argument
+		if value == "" {
+			if i+1 == len(args) {
+				return fmt.Errorf("missing value for %s", arg)
+			}
+			if !nextIsNumeric(spec.field.Type, args[i+1]) && isFlag(args[i+1]) {
+				return fmt.Errorf("missing value for %s", arg)
+			}
+			value = args[i+1]
+			i++
+		}
+
+		err := scalar.ParseValue(p.val(spec.dest), value)
+		if err != nil {
+			return fmt.Errorf("error processing %s: %v", arg, err)
+		}
+	}
+
+	// process positionals
+	for _, spec := range specs {
+		if !spec.positional {
+			continue
+		}
+		if len(positionals) == 0 {
+			break
+		}
+		wasPresent[spec] = true
+		if spec.cardinality == multiple {
+			err := setSliceOrMap(p.val(spec.dest), positionals, true)
+			if err != nil {
+				return fmt.Errorf("error processing %s: %v", spec.field.Name, err)
+			}
+			positionals = nil
+		} else {
+			err := scalar.ParseValue(p.val(spec.dest), positionals[0])
+			if err != nil {
+				return fmt.Errorf("error processing %s: %v", spec.field.Name, err)
+			}
+			positionals = positionals[1:]
+		}
+	}
+	if len(positionals) > 0 {
+		return fmt.Errorf("too many positional arguments at '%s'", positionals[0])
+	}
+
+	// fill in defaults and check that all the required args were provided
+	for _, spec := range specs {
+		if wasPresent[spec] {
+			continue
+		}
+
+		name := strings.ToLower(spec.field.Name)
+		if spec.long != "" && !spec.positional {
+			name = "--" + spec.long
+		}
+
+		if spec.required {
+			msg := fmt.Sprintf("%s is required", name)
+			if spec.env != "" {
+				msg += " (or environment variable " + spec.env + ")"
+			}
+			return errors.New(msg)
+		}
+		if spec.defaultVal != "" {
+			err := scalar.ParseValue(p.val(spec.dest), spec.defaultVal)
+			if err != nil {
+				return fmt.Errorf("error processing default value for %s: %v", name, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func nextIsNumeric(t reflect.Type, s string) bool {
+	switch t.Kind() {
+	case reflect.Ptr:
+		return nextIsNumeric(t.Elem(), s)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Float32, reflect.Float64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		v := reflect.New(t)
+		err := scalar.ParseValue(v, s)
+		return err == nil
+	default:
+		return false
+	}
+}
+
+// isFlag returns true if a token is a flag such as "-v" or "--user" but not "-" or "--"
+func isFlag(s string) bool {
+	return strings.HasPrefix(s, "-") && strings.TrimLeft(s, "-") != ""
+}
+
+// val returns a reflect.Value corresponding to the current value for the
+// given path
+func (p *Parser) val(dest path) reflect.Value {
+	v := p.roots[dest.root]
+	for _, field := range dest.fields {
+		if v.Kind() == reflect.Ptr {
+			if v.IsNil() {
+				return reflect.Value{}
+			}
+			v = v.Elem()
+		}
+
+		v = v.FieldByIndex(field.Index)
+	}
+	return v
+}
+
+// findOption finds an option from its name, or returns null if no spec is found
+func findOption(specs []*spec, name string) *spec {
+	for _, spec := range specs {
+		if spec.positional {
+			continue
+		}
+		if spec.long == name || spec.short == name {
+			return spec
+		}
+	}
+	return nil
+}
+
+// findSubcommand finds a subcommand using its name, or returns null if no subcommand is found
+func findSubcommand(cmds []*command, name string) *command {
+	for _, cmd := range cmds {
+		if cmd.name == name {
+			return cmd
+		}
+	}
+	return nil
+}