Vendor main dependencies.

vendor/github.com/containous/flaeg/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Containous SAS, Emile Vauge, emile@vauge.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/containous/flaeg/flaeg.go

@@ -0,0 +1,752 @@
+package flaeg
+
+import (
+	"errors"
+	"fmt"
+	flag "github.com/ogier/pflag"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"reflect"
+	"sort"
+	"strings"
+	"text/tabwriter"
+	"text/template"
+	"time"
+)
+
+// ErrParserNotFound is thrown when a field is flaged but not parser match its type
+var ErrParserNotFound = errors.New("Parser not found or custom parser missing")
+
+// GetTypesRecursive links in flagmap a flag with its reflect.StructField
+// You can whether provide objValue on a structure or a pointer to structure as first argument
+// Flags are genereted from field name or from StructTag
+func getTypesRecursive(objValue reflect.Value, flagmap map[string]reflect.StructField, key string) error {
+	name := key
+	switch objValue.Kind() {
+	case reflect.Struct:
+
+		for i := 0; i < objValue.NumField(); i++ {
+			if objValue.Type().Field(i).Anonymous {
+				if err := getTypesRecursive(objValue.Field(i), flagmap, name); err != nil {
+					return err
+				}
+			} else if len(objValue.Type().Field(i).Tag.Get("description")) > 0 {
+				fieldName := objValue.Type().Field(i).Name
+				if !isExported(fieldName) {
+					return fmt.Errorf("Field %s is an unexported field", fieldName)
+				}
+
+				name += objValue.Type().Name()
+				if tag := objValue.Type().Field(i).Tag.Get("long"); len(tag) > 0 {
+					fieldName = tag
+				}
+				if len(key) == 0 {
+					//Lower Camel Case
+					//name = strings.ToLower(string(fieldName[0])) + fieldName[1:]
+					name = strings.ToLower(fieldName)
+				} else {
+					name = key + "." + strings.ToLower(fieldName)
+				}
+				if _, ok := flagmap[name]; ok {
+					return errors.New("Tag already exists: " + name)
+				}
+				flagmap[name] = objValue.Type().Field(i)
+
+				if err := getTypesRecursive(objValue.Field(i), flagmap, name); err != nil {
+					return err
+				}
+			}
+
+		}
+	case reflect.Ptr:
+		if len(key) > 0 {
+			field := flagmap[name]
+			field.Type = reflect.TypeOf(false)
+			flagmap[name] = field
+		}
+		typ := objValue.Type().Elem()
+		inst := reflect.New(typ).Elem()
+		if err := getTypesRecursive(inst, flagmap, name); err != nil {
+			return err
+		}
+	default:
+		return nil
+	}
+	return nil
+}
+
+//GetPointerFlags returns flags on pointers
+func GetBoolFlags(config interface{}) ([]string, error) {
+	flagmap := make(map[string]reflect.StructField)
+	if err := getTypesRecursive(reflect.ValueOf(config), flagmap, ""); err != nil {
+		return []string{}, err
+	}
+	flags := make([]string, 0, len(flagmap))
+	for f, structField := range flagmap {
+		if structField.Type.Kind() == reflect.Bool {
+			flags = append(flags, f)
+		}
+	}
+	return flags, nil
+}
+
+//GetFlags returns flags
+func GetFlags(config interface{}) ([]string, error) {
+	flagmap := make(map[string]reflect.StructField)
+	if err := getTypesRecursive(reflect.ValueOf(config), flagmap, ""); err != nil {
+		return []string{}, err
+	}
+	flags := make([]string, 0, len(flagmap))
+	for f := range flagmap {
+		flags = append(flags, f)
+	}
+	return flags, nil
+}
+
+//loadParsers loads default parsers and custom parsers given as parameter. Return a map [reflect.Type]parsers
+// bool, int, int64, uint, uint64, float64,
+func loadParsers(customParsers map[reflect.Type]Parser) (map[reflect.Type]Parser, error) {
+	parsers := map[reflect.Type]Parser{}
+
+	var boolParser boolValue
+	parsers[reflect.TypeOf(true)] = &boolParser
+
+	var intParser intValue
+	parsers[reflect.TypeOf(1)] = &intParser
+
+	var int64Parser int64Value
+	parsers[reflect.TypeOf(int64(1))] = &int64Parser
+
+	var uintParser uintValue
+	parsers[reflect.TypeOf(uint(1))] = &uintParser
+
+	var uint64Parser uint64Value
+	parsers[reflect.TypeOf(uint64(1))] = &uint64Parser
+
+	var stringParser stringValue
+	parsers[reflect.TypeOf("")] = &stringParser
+
+	var float64Parser float64Value
+	parsers[reflect.TypeOf(float64(1.5))] = &float64Parser
+
+	var durationParser durationValue
+	parsers[reflect.TypeOf(time.Second)] = &durationParser
+
+	var timeParser timeValue
+	parsers[reflect.TypeOf(time.Now())] = &timeParser
+
+	for rType, parser := range customParsers {
+		parsers[rType] = parser
+	}
+	return parsers, nil
+}
+
+//ParseArgs : parses args return valmap map[flag]Getter, using parsers map[type]Getter
+//args must be formated as like as flag documentation. See https://golang.org/pkg/flag
+func parseArgs(args []string, flagmap map[string]reflect.StructField, parsers map[reflect.Type]Parser) (map[string]Parser, error) {
+	//Return var
+	valmap := make(map[string]Parser)
+	//Visitor in flag.Parse
+	flagList := []*flag.Flag{}
+	visitor := func(fl *flag.Flag) {
+		flagList = append(flagList, fl)
+	}
+	newParsers := map[string]Parser{}
+	flagSet := flag.NewFlagSet("flaeg.Load", flag.ContinueOnError)
+	//Disable output
+	flagSet.SetOutput(ioutil.Discard)
+	var err error
+	for flag, structField := range flagmap {
+		//for _, flag := range flags {
+		//structField := flagmap[flag]
+		if parser, ok := parsers[structField.Type]; ok {
+			newparserValue := reflect.New(reflect.TypeOf(parser).Elem())
+			newparserValue.Elem().Set(reflect.ValueOf(parser).Elem())
+			newparser := newparserValue.Interface().(Parser)
+			if short := structField.Tag.Get("short"); len(short) == 1 {
+				// fmt.Printf("short : %s long : %s\n", short, flag)
+				flagSet.VarP(newparser, flag, short, structField.Tag.Get("description"))
+			} else {
+				flagSet.Var(newparser, flag, structField.Tag.Get("description"))
+			}
+			newParsers[flag] = newparser
+		} else {
+			err = ErrParserNotFound
+		}
+	}
+
+	// prevents case sensitivity issue
+	args = argsToLower(args)
+	if err := flagSet.Parse(args); err != nil {
+		return nil, err
+	}
+
+	//Fill flagList with parsed flags
+	flagSet.Visit(visitor)
+	//Return parsers on parsed flag
+	for _, flag := range flagList {
+		valmap[flag.Name] = newParsers[flag.Name]
+	}
+
+	return valmap, err
+}
+
+func getDefaultValue(defaultValue reflect.Value, defaultPointersValue reflect.Value, defaultValmap map[string]reflect.Value, key string) error {
+	if defaultValue.Type() != defaultPointersValue.Type() {
+		return fmt.Errorf("Parameters defaultValue and defaultPointersValue must be the same struct. defaultValue type : %s is not defaultPointersValue type : %s", defaultValue.Type().String(), defaultPointersValue.Type().String())
+	}
+	name := key
+	switch defaultValue.Kind() {
+	case reflect.Struct:
+		for i := 0; i < defaultValue.NumField(); i++ {
+			if defaultValue.Type().Field(i).Anonymous {
+				if err := getDefaultValue(defaultValue.Field(i), defaultPointersValue.Field(i), defaultValmap, name); err != nil {
+					return err
+				}
+			} else if len(defaultValue.Type().Field(i).Tag.Get("description")) > 0 {
+				name += defaultValue.Type().Name()
+				fieldName := defaultValue.Type().Field(i).Name
+				if tag := defaultValue.Type().Field(i).Tag.Get("long"); len(tag) > 0 {
+					fieldName = tag
+				}
+				if len(key) == 0 {
+					name = strings.ToLower(fieldName)
+				} else {
+					name = key + "." + strings.ToLower(fieldName)
+				}
+				if defaultValue.Field(i).Kind() != reflect.Ptr {
+					// if _, ok := defaultValmap[name]; ok {
+					// 	return errors.New("Tag already exists: " + name)
+					// }
+					defaultValmap[name] = defaultValue.Field(i)
+					// fmt.Printf("%s: got default value %+v\n", name, defaultValue.Field(i))
+				}
+				if err := getDefaultValue(defaultValue.Field(i), defaultPointersValue.Field(i), defaultValmap, name); err != nil {
+					return err
+				}
+			}
+		}
+	case reflect.Ptr:
+		if !defaultPointersValue.IsNil() {
+			if len(key) != 0 {
+				//turn ptr fields to nil
+				defaultPointersNilValue, err := setPointersNil(defaultPointersValue)
+				if err != nil {
+					return err
+				}
+				defaultValmap[name] = defaultPointersNilValue
+				// fmt.Printf("%s: got default value %+v\n", name, defaultPointersNilValue)
+			}
+			if !defaultValue.IsNil() {
+				if err := getDefaultValue(defaultValue.Elem(), defaultPointersValue.Elem(), defaultValmap, name); err != nil {
+					return err
+				}
+			} else {
+				if err := getDefaultValue(defaultPointersValue.Elem(), defaultPointersValue.Elem(), defaultValmap, name); err != nil {
+					return err
+				}
+			}
+		} else {
+			instValue := reflect.New(defaultPointersValue.Type().Elem())
+			if len(key) != 0 {
+				defaultValmap[name] = instValue
+				// fmt.Printf("%s: got default value %+v\n", name, instValue)
+			}
+			if !defaultValue.IsNil() {
+				if err := getDefaultValue(defaultValue.Elem(), instValue.Elem(), defaultValmap, name); err != nil {
+					return err
+				}
+			} else {
+				if err := getDefaultValue(instValue.Elem(), instValue.Elem(), defaultValmap, name); err != nil {
+					return err
+				}
+			}
+		}
+	default:
+		return nil
+	}
+	return nil
+}
+
+//objValue a reflect.Value of a not-nil pointer on a struct
+func setPointersNil(objValue reflect.Value) (reflect.Value, error) {
+	if objValue.Kind() != reflect.Ptr {
+		return objValue, fmt.Errorf("Parameters objValue must be a not-nil pointer on a struct, not a %s", objValue.Kind().String())
+	} else if objValue.IsNil() {
+		return objValue, fmt.Errorf("Parameters objValue must be a not-nil pointer")
+	} else if objValue.Elem().Kind() != reflect.Struct {
+		// fmt.Printf("Parameters objValue must be a not-nil pointer on a struct, not a pointer on a %s\n", objValue.Elem().Kind().String())
+		return objValue, nil
+	}
+	//Clone
+	starObjValue := objValue.Elem()
+	nilPointersObjVal := reflect.New(starObjValue.Type())
+	starNilPointersObjVal := nilPointersObjVal.Elem()
+	starNilPointersObjVal.Set(starObjValue)
+
+	for i := 0; i < nilPointersObjVal.Elem().NumField(); i++ {
+		if field := nilPointersObjVal.Elem().Field(i); field.Kind() == reflect.Ptr && field.CanSet() {
+			field.Set(reflect.Zero(field.Type()))
+		}
+	}
+	return nilPointersObjVal, nil
+}
+
+//FillStructRecursive initialize a value of any taged Struct given by reference
+func fillStructRecursive(objValue reflect.Value, defaultPointerValmap map[string]reflect.Value, valmap map[string]Parser, key string) error {
+	name := key
+	switch objValue.Kind() {
+	case reflect.Struct:
+
+		for i := 0; i < objValue.Type().NumField(); i++ {
+			if objValue.Type().Field(i).Anonymous {
+				if err := fillStructRecursive(objValue.Field(i), defaultPointerValmap, valmap, name); err != nil {
+					return err
+				}
+			} else if len(objValue.Type().Field(i).Tag.Get("description")) > 0 {
+				name += objValue.Type().Name()
+				fieldName := objValue.Type().Field(i).Name
+				if tag := objValue.Type().Field(i).Tag.Get("long"); len(tag) > 0 {
+					fieldName = tag
+				}
+				if len(key) == 0 {
+					name = strings.ToLower(fieldName)
+				} else {
+					name = key + "." + strings.ToLower(fieldName)
+				}
+				// fmt.Println(name)
+				if objValue.Field(i).Kind() != reflect.Ptr {
+
+					if val, ok := valmap[name]; ok {
+						// fmt.Printf("%s : set def val\n", name)
+						if err := setFields(objValue.Field(i), val); err != nil {
+							return err
+						}
+					}
+				}
+				if err := fillStructRecursive(objValue.Field(i), defaultPointerValmap, valmap, name); err != nil {
+					return err
+				}
+			}
+		}
+
+	case reflect.Ptr:
+		if len(key) == 0 && !objValue.IsNil() {
+			if err := fillStructRecursive(objValue.Elem(), defaultPointerValmap, valmap, name); err != nil {
+				return err
+			}
+			return nil
+		}
+		contains := false
+		for flag := range valmap {
+			// TODO replace by regexp
+			if strings.Contains(flag, name+".") {
+				contains = true
+				break
+			}
+		}
+		needDefault := false
+		if _, ok := valmap[name]; ok {
+			needDefault = valmap[name].Get().(bool)
+		}
+		if contains && objValue.IsNil() {
+			needDefault = true
+		}
+
+		if needDefault {
+			if defVal, ok := defaultPointerValmap[name]; ok {
+				//set default pointer value
+				// fmt.Printf("%s  : set default value %+v\n", name, defVal)
+				objValue.Set(defVal)
+			} else {
+				return fmt.Errorf("flag %s default value not provided", name)
+			}
+		}
+		if !objValue.IsNil() && contains {
+			if objValue.Type().Elem().Kind() == reflect.Struct {
+				if err := fillStructRecursive(objValue.Elem(), defaultPointerValmap, valmap, name); err != nil {
+					return err
+				}
+			}
+		}
+	default:
+		return nil
+	}
+	return nil
+}
+
+// SetFields sets value to fieldValue using tag as key in valmap
+func setFields(fieldValue reflect.Value, val Parser) error {
+	if fieldValue.CanSet() {
+		fieldValue.Set(reflect.ValueOf(val).Elem().Convert(fieldValue.Type()))
+	} else {
+		return errors.New(fieldValue.Type().String() + " is not settable.")
+	}
+	return nil
+}
+
+//PrintHelp generates and prints command line help
+func PrintHelp(flagmap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]Parser) error {
+	return PrintHelpWithCommand(flagmap, defaultValmap, parsers, nil, nil)
+}
+
+//PrintError takes a not nil error and prints command line help
+func PrintError(err error, flagmap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]Parser) error {
+	if err != flag.ErrHelp {
+		fmt.Printf("Error : %s\n", err)
+	}
+	if !strings.Contains(err.Error(), ":No parser for type") {
+		PrintHelp(flagmap, defaultValmap, parsers)
+	}
+	return err
+}
+
+//LoadWithParsers initializes config : struct fields given by reference, with args : arguments.
+//Some custom parsers may be given.
+func LoadWithParsers(config interface{}, defaultValue interface{}, args []string, customParsers map[reflect.Type]Parser) error {
+	cmd := &Command{
+		Config:                config,
+		DefaultPointersConfig: defaultValue,
+	}
+	_, cmd.Name = path.Split(os.Args[0])
+	return LoadWithCommand(cmd, args, customParsers, nil)
+}
+
+//Load initializes config : struct fields given by reference, with args : arguments.
+//Some custom parsers may be given.
+func Load(config interface{}, defaultValue interface{}, args []string) error {
+	return LoadWithParsers(config, defaultValue, args, nil)
+}
+
+// Command structure contains program/command information (command name and description)
+// Config must be a pointer on the configuration struct to parse (it contains default values of field)
+// DefaultPointersConfig contains default pointers values: those values are set on pointers fields if their flags are called
+// It must be the same type(struct) as Config
+// Run is the func which launch the program using initialized configuration structure
+type Command struct {
+	Name                  string
+	Description           string
+	Config                interface{}
+	DefaultPointersConfig interface{} //TODO:case DefaultPointersConfig is nil
+	Run                   func() error
+	Metadata              map[string]string
+}
+
+//LoadWithCommand initializes config : struct fields given by reference, with args : arguments.
+//Some custom parsers and some subCommand may be given.
+func LoadWithCommand(cmd *Command, cmdArgs []string, customParsers map[reflect.Type]Parser, subCommand []*Command) error {
+
+	parsers, err := loadParsers(customParsers)
+	if err != nil {
+		return err
+	}
+
+	tagsmap := make(map[string]reflect.StructField)
+	if err := getTypesRecursive(reflect.ValueOf(cmd.Config), tagsmap, ""); err != nil {
+		return err
+	}
+	defaultValmap := make(map[string]reflect.Value)
+	if err := getDefaultValue(reflect.ValueOf(cmd.Config), reflect.ValueOf(cmd.DefaultPointersConfig), defaultValmap, ""); err != nil {
+		return err
+	}
+
+	valmap, errParseArgs := parseArgs(cmdArgs, tagsmap, parsers)
+	if errParseArgs != nil && errParseArgs != ErrParserNotFound {
+		return PrintErrorWithCommand(errParseArgs, tagsmap, defaultValmap, parsers, cmd, subCommand)
+	}
+
+	if err := fillStructRecursive(reflect.ValueOf(cmd.Config), defaultValmap, valmap, ""); err != nil {
+		return err
+	}
+
+	if errParseArgs == ErrParserNotFound {
+		return errParseArgs
+	}
+
+	return nil
+}
+
+//PrintHelpWithCommand generates and prints command line help for a Command
+func PrintHelpWithCommand(flagmap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]Parser, cmd *Command, subCmd []*Command) error {
+	// Define a templates
+	// Using POSXE STD : http://pubs.opengroup.org/onlinepubs/9699919799/
+	const helper = `{{if .ProgDescription}}{{.ProgDescription}}
+	
+{{end}}Usage: {{.ProgName}} [--flag=flag_argument] [-f[flag_argument]] ...     set flag_argument to flag(s)
+   or: {{.ProgName}} [--flag[=true|false| ]] [-f[true|false| ]] ...     set true/false to boolean flag(s)
+{{if .SubCommands}}
+Available Commands:{{range $subCmdName, $subCmdDesc := .SubCommands}}
+{{printf "\t%-50s %s" $subCmdName $subCmdDesc}}{{end}}
+Use "{{.ProgName}} [command] --help" for more information about a command.
+{{end}}
+Flags:
+`
+	// Use a struct to give data to template
+	type TempStruct struct {
+		ProgName        string
+		ProgDescription string
+		SubCommands     map[string]string
+	}
+	tempStruct := TempStruct{}
+	if cmd != nil {
+		tempStruct.ProgName = cmd.Name
+		tempStruct.ProgDescription = cmd.Description
+		tempStruct.SubCommands = map[string]string{}
+		if len(subCmd) > 1 && cmd == subCmd[0] {
+			for _, c := range subCmd[1:] {
+				tempStruct.SubCommands[c.Name] = c.Description
+			}
+		}
+	} else {
+		_, tempStruct.ProgName = path.Split(os.Args[0])
+	}
+
+	//Run Template
+	tmplHelper, err := template.New("helper").Parse(helper)
+	if err != nil {
+		return err
+	}
+	err = tmplHelper.Execute(os.Stdout, tempStruct)
+	if err != nil {
+		return err
+	}
+
+	return printFlagsDescriptionsDefaultValues(flagmap, defaultValmap, parsers, os.Stdout)
+}
+
+func printFlagsDescriptionsDefaultValues(flagmap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]Parser, output io.Writer) error {
+	// Sort alphabetically & Delete unparsable flags in a slice
+	flags := []string{}
+	for flag, field := range flagmap {
+		if _, ok := parsers[field.Type]; ok {
+			flags = append(flags, flag)
+		}
+	}
+	sort.Strings(flags)
+
+	// Process data
+	descriptions := []string{}
+	defaultValues := []string{}
+	flagsWithDashs := []string{}
+	shortFlagsWithDash := []string{}
+	for _, flag := range flags {
+		field := flagmap[flag]
+		if short := field.Tag.Get("short"); len(short) == 1 {
+			shortFlagsWithDash = append(shortFlagsWithDash, "-"+short+",")
+		} else {
+			shortFlagsWithDash = append(shortFlagsWithDash, "")
+		}
+		flagsWithDashs = append(flagsWithDashs, "--"+flag)
+
+		//flag on pointer ?
+		if defVal, ok := defaultValmap[flag]; ok {
+			if defVal.Kind() != reflect.Ptr {
+				// Set defaultValue on parsers
+				parsers[field.Type].SetValue(defaultValmap[flag].Interface())
+			}
+
+			if defVal := parsers[field.Type].String(); len(defVal) > 0 {
+				defaultValues = append(defaultValues, fmt.Sprintf("(default \"%s\")", defVal))
+			} else {
+				defaultValues = append(defaultValues, "")
+			}
+		}
+
+		splittedDescriptions := split(field.Tag.Get("description"), 80)
+		for i, description := range splittedDescriptions {
+			descriptions = append(descriptions, description)
+			if i != 0 {
+				defaultValues = append(defaultValues, "")
+				flagsWithDashs = append(flagsWithDashs, "")
+				shortFlagsWithDash = append(shortFlagsWithDash, "")
+			}
+		}
+	}
+	//add help flag
+	shortFlagsWithDash = append(shortFlagsWithDash, "-h,")
+	flagsWithDashs = append(flagsWithDashs, "--help")
+	descriptions = append(descriptions, "Print Help (this message) and exit")
+	defaultValues = append(defaultValues, "")
+	return displayTab(output, shortFlagsWithDash, flagsWithDashs, descriptions, defaultValues)
+}
+func split(str string, width int) []string {
+	if len(str) > width {
+		index := strings.LastIndex(str[:width], " ")
+		if index == -1 {
+			index = width
+		}
+		return append([]string{strings.TrimSpace(str[:index])}, split(strings.TrimSpace(str[index:]), width)...)
+	}
+	return []string{str}
+}
+
+func displayTab(output io.Writer, columns ...[]string) error {
+	nbRow := len(columns[0])
+	nbCol := len(columns)
+	w := new(tabwriter.Writer)
+	w.Init(output, 0, 4, 1, ' ', 0)
+	for i := 0; i < nbRow; i++ {
+		row := ""
+		for j, col := range columns {
+			row += col[i]
+			if j != nbCol-1 {
+				row += "\t"
+			}
+		}
+		fmt.Fprintln(w, row)
+	}
+	w.Flush()
+	return nil
+}
+
+//PrintErrorWithCommand takes a not nil error and prints command line help
+func PrintErrorWithCommand(err error, flagmap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]Parser, cmd *Command, subCmd []*Command) error {
+	if err != flag.ErrHelp {
+		fmt.Printf("Error here : %s\n", err)
+	}
+	PrintHelpWithCommand(flagmap, defaultValmap, parsers, cmd, subCmd)
+	return err
+}
+
+//Flaeg struct contains commands (at least the root one)
+//and row arguments (command and/or flags)
+//a map of custom parsers could be use
+type Flaeg struct {
+	calledCommand *Command
+	commands      []*Command ///rootCommand is th fist one in this slice
+	args          []string
+	commmandArgs  []string
+	customParsers map[reflect.Type]Parser
+}
+
+//New creats and initialize a pointer on Flaeg
+func New(rootCommand *Command, args []string) *Flaeg {
+	var f Flaeg
+	f.commands = []*Command{rootCommand}
+	f.args = args
+	f.customParsers = map[reflect.Type]Parser{}
+	return &f
+}
+
+//AddCommand adds sub-command to the root command
+func (f *Flaeg) AddCommand(command *Command) {
+	f.commands = append(f.commands, command)
+}
+
+//AddParser adds custom parser for a type to the map of custom parsers
+func (f *Flaeg) AddParser(typ reflect.Type, parser Parser) {
+	f.customParsers[typ] = parser
+}
+
+// Run calls the command with flags given as agruments
+func (f *Flaeg) Run() error {
+	if f.calledCommand == nil {
+		if _, _, err := f.findCommandWithCommandArgs(); err != nil {
+			return err
+		}
+	}
+	if _, err := f.Parse(f.calledCommand); err != nil {
+		return err
+	}
+	return f.calledCommand.Run()
+}
+
+// Parse calls Flaeg Load Function end returns the parsed command structure (by reference)
+// It returns nil and a not nil error if it fails
+func (f *Flaeg) Parse(cmd *Command) (*Command, error) {
+	if f.calledCommand == nil {
+		f.commmandArgs = f.args
+	}
+	if err := LoadWithCommand(cmd, f.commmandArgs, f.customParsers, f.commands); err != nil {
+		return cmd, err
+	}
+	return cmd, nil
+}
+
+//splitArgs takes args (type []string) and return command ("" if rootCommand) and command's args
+func splitArgs(args []string) (string, []string) {
+	if len(args) >= 1 && len(args[0]) >= 1 && string(args[0][0]) != "-" {
+		if len(args) == 1 {
+			return strings.ToLower(args[0]), []string{}
+		}
+		return strings.ToLower(args[0]), args[1:]
+	}
+	return "", args
+}
+
+// findCommandWithCommandArgs returns the called command (by reference) and command's args
+// the error returned is not nil if it fails
+func (f *Flaeg) findCommandWithCommandArgs() (*Command, []string, error) {
+	commandName := ""
+	commandName, f.commmandArgs = splitArgs(f.args)
+	if len(commandName) > 0 {
+		for _, command := range f.commands {
+			if commandName == command.Name {
+				f.calledCommand = command
+				return f.calledCommand, f.commmandArgs, nil
+			}
+		}
+		return nil, []string{}, fmt.Errorf("Command %s not found", commandName)
+	}
+
+	f.calledCommand = f.commands[0]
+	return f.calledCommand, f.commmandArgs, nil
+}
+
+// GetCommand splits args and returns the called command (by reference)
+// It returns nil and a not nil error if it fails
+func (f *Flaeg) GetCommand() (*Command, error) {
+	if f.calledCommand == nil {
+		_, _, err := f.findCommandWithCommandArgs()
+		return f.calledCommand, err
+	}
+	return f.calledCommand, nil
+}
+
+//isExported return true is the field (from fieldName) is exported,
+//else false
+func isExported(fieldName string) bool {
+	if len(fieldName) < 1 {
+		return false
+	}
+	if string(fieldName[0]) == strings.ToUpper(string(fieldName[0])) {
+		return true
+	}
+	return false
+}
+
+func argToLower(inArg string) string {
+	if len(inArg) < 2 {
+		return strings.ToLower(inArg)
+	}
+	var outArg string
+	dashIndex := strings.Index(inArg, "--")
+	if dashIndex == -1 {
+		if dashIndex = strings.Index(inArg, "-"); dashIndex == -1 {
+			return inArg
+		}
+		//-fValue
+		outArg = strings.ToLower(inArg[dashIndex:dashIndex+2]) + inArg[dashIndex+2:]
+		return outArg
+	}
+	//--flag
+	if equalIndex := strings.Index(inArg, "="); equalIndex != -1 {
+		//--flag=value
+		outArg = strings.ToLower(inArg[dashIndex:equalIndex]) + inArg[equalIndex:]
+	} else {
+		//--boolflag
+		outArg = strings.ToLower(inArg[dashIndex:])
+	}
+
+	return outArg
+}
+
+func argsToLower(inArgs []string) []string {
+	outArgs := make([]string, len(inArgs), len(inArgs))
+	for i, inArg := range inArgs {
+		outArgs[i] = argToLower(inArg)
+	}
+	return outArgs
+}

vendor/github.com/containous/flaeg/parsers.go

@@ -0,0 +1,204 @@
+package flaeg
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+//TODO : add parsers on all types in https://golang.org/pkg/builtin/
+
+// Parser is an interface that allows the contents of a flag.Getter to be set.
+type Parser interface {
+	flag.Getter
+	SetValue(interface{})
+}
+
+// -- bool Value
+type boolValue bool
+
+func (b *boolValue) Set(s string) error {
+	v, err := strconv.ParseBool(s)
+	*b = boolValue(v)
+	return err
+}
+
+func (b *boolValue) Get() interface{} { return bool(*b) }
+
+func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) }
+
+func (b *boolValue) IsBoolFlag() bool { return true }
+
+func (b *boolValue) SetValue(val interface{}) {
+	*b = boolValue(val.(bool))
+}
+
+// optional interface to indicate boolean flags that can be
+// supplied without "=value" text
+type boolFlag interface {
+	flag.Value
+	IsBoolFlag() bool
+}
+
+// -- int Value
+type intValue int
+
+func (i *intValue) Set(s string) error {
+	v, err := strconv.ParseInt(s, 0, 64)
+	*i = intValue(v)
+	return err
+}
+
+func (i *intValue) Get() interface{} { return int(*i) }
+
+func (i *intValue) String() string { return fmt.Sprintf("%v", *i) }
+
+func (i *intValue) SetValue(val interface{}) {
+	*i = intValue(val.(int))
+}
+
+// -- int64 Value
+type int64Value int64
+
+func (i *int64Value) Set(s string) error {
+	v, err := strconv.ParseInt(s, 0, 64)
+	*i = int64Value(v)
+	return err
+}
+
+func (i *int64Value) Get() interface{} { return int64(*i) }
+
+func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) }
+
+func (i *int64Value) SetValue(val interface{}) {
+	*i = int64Value(val.(int64))
+}
+
+// -- uint Value
+type uintValue uint
+
+func (i *uintValue) Set(s string) error {
+	v, err := strconv.ParseUint(s, 0, 64)
+	*i = uintValue(v)
+	return err
+}
+
+func (i *uintValue) Get() interface{} { return uint(*i) }
+
+func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) }
+
+func (i *uintValue) SetValue(val interface{}) {
+	*i = uintValue(val.(uint))
+}
+
+// -- uint64 Value
+type uint64Value uint64
+
+func (i *uint64Value) Set(s string) error {
+	v, err := strconv.ParseUint(s, 0, 64)
+	*i = uint64Value(v)
+	return err
+}
+
+func (i *uint64Value) Get() interface{} { return uint64(*i) }
+
+func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) }
+
+func (i *uint64Value) SetValue(val interface{}) {
+	*i = uint64Value(val.(uint64))
+}
+
+// -- string Value
+type stringValue string
+
+func (s *stringValue) Set(val string) error {
+	*s = stringValue(val)
+	return nil
+}
+
+func (s *stringValue) Get() interface{} { return string(*s) }
+
+func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) }
+
+func (s *stringValue) SetValue(val interface{}) {
+	*s = stringValue(val.(string))
+}
+
+// -- float64 Value
+type float64Value float64
+
+func (f *float64Value) Set(s string) error {
+	v, err := strconv.ParseFloat(s, 64)
+	*f = float64Value(v)
+	return err
+}
+
+func (f *float64Value) Get() interface{} { return float64(*f) }
+
+func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) }
+
+func (f *float64Value) SetValue(val interface{}) {
+	*f = float64Value(val.(float64))
+}
+
+// -- time.Duration Value
+type durationValue time.Duration
+
+func (d *durationValue) Set(s string) error {
+	v, err := time.ParseDuration(s)
+	*d = durationValue(v)
+	return err
+}
+
+func (d *durationValue) Get() interface{} { return time.Duration(*d) }
+
+func (d *durationValue) String() string { return (*time.Duration)(d).String() }
+
+func (d *durationValue) SetValue(val interface{}) {
+	*d = durationValue(val.(time.Duration))
+}
+
+// -- time.Time Value
+type timeValue time.Time
+
+func (t *timeValue) Set(s string) error {
+	v, err := time.Parse(time.RFC3339, s)
+	*t = timeValue(v)
+	return err
+}
+
+func (t *timeValue) Get() interface{} { return time.Time(*t) }
+
+func (t *timeValue) String() string { return (*time.Time)(t).String() }
+
+func (t *timeValue) SetValue(val interface{}) {
+	*t = timeValue(val.(time.Time))
+}
+
+//SliceStrings parse slice of strings
+type SliceStrings []string
+
+//Set adds strings elem into the the parser
+//it splits str on , and ;
+func (s *SliceStrings) Set(str string) error {
+	fargs := func(c rune) bool {
+		return c == ',' || c == ';'
+	}
+	// get function
+	slice := strings.FieldsFunc(str, fargs)
+	*s = append(*s, slice...)
+	return nil
+}
+
+//Get []string
+func (s *SliceStrings) Get() interface{} { return []string(*s) }
+
+//String return slice in a string
+func (s *SliceStrings) String() string { return fmt.Sprintf("%v", *s) }
+
+//SetValue sets []string into the parser
+func (s *SliceStrings) SetValue(val interface{}) {
+	*s = SliceStrings(val.([]string))
+}