switched to go-mod, updated codegangsta/cli -> urfave/cli

vendor/github.com/fatih/structs/.travis.yml

@@ -1,11 +1,13 @@
 language: go
-go: 1.3
+go: 
+ - 1.7.x
+ - 1.8.x
+ - 1.9.x
+ - tip
+sudo: false
 before_install:
 - go get github.com/axw/gocov/gocov
 - go get github.com/mattn/goveralls
-- go get code.google.com/p/go.tools/cmd/cover
+- if ! go get github.com/golang/tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
 script:
-- $HOME/gopath/bin/goveralls -repotoken $COVERALLS_TOKEN
-env:
-  global:
-  - secure: hkc+92KPmMFqIH9n4yWdnH1JpZjahmOyDJwpTh8Yl0JieJNG0XEXpOqNao27eA0cLF+UHdyjFeGcPUJKNmgE46AoQjtovt+ICjCXKR2yF6S2kKJcUOz/Vd6boZF7qHV06jjxyxOebpID5iSoW6UfFr001bFxpd3jaSLFTzSHWRQ=
+- $HOME/gopath/bin/goveralls -service=travis-ci

vendor/github.com/fatih/structs/README.md

@@ -81,8 +81,8 @@ n := s.Names()            // Get a []string
 f := s.Field(name)        // Get a *Field based on the given field name
 f, ok := s.FieldOk(name)  // Get a *Field based on the given field name
 n := s.Name()             // Get the struct name
-h := s.HasZero()          // Check if any field is initialized
-z := s.IsZero()           // Check if all fields are initialized
+h := s.HasZero()          // Check if any field is uninitialized
+z := s.IsZero()           // Check if all fields are uninitialized
 ```
 
 ### Field methods
@@ -141,10 +141,9 @@ We can also get a slice of Fields from the Struct type to iterate over all
 fields. This is handy if you wish to examine all fields:
 
 ```go
-// Convert the fields of a struct to a []*Field
-fields := s.Fields()
+s := structs.New(server)
 
-for _, f := range fields {
+for _, f := range s.Fields() {
 	fmt.Printf("field name: %+v\n", f.Name())
 
 	if f.IsExported() {

vendor/github.com/fatih/structs/field.go

@@ -25,7 +25,7 @@ func (f *Field) Tag(key string) string {
 	return f.field.Tag.Get(key)
 }
 
-// Value returns the underlying value of of the field. It panics if the field
+// Value returns the underlying value of the field. It panics if the field
 // is not exported.
 func (f *Field) Value() interface{} {
 	return f.value.Interface()
@@ -41,7 +41,7 @@ func (f *Field) IsExported() bool {
 	return f.field.PkgPath == ""
 }
 
-// IsZero returns true if the given field is not initalized (has a zero value).
+// IsZero returns true if the given field is not initialized (has a zero value).
 // It panics if the field is not exported.
 func (f *Field) IsZero() bool {
 	zero := reflect.Zero(f.value.Type()).Interface()
@@ -60,8 +60,8 @@ func (f *Field) Kind() reflect.Kind {
 	return f.value.Kind()
 }
 
-// Set sets the field to given value v. It retuns an error if the field is not
-// settable (not addresable or not exported) or if the given value's type
+// Set sets the field to given value v. It returns an error if the field is not
+// settable (not addressable or not exported) or if the given value's type
 // doesn't match the fields type.
 func (f *Field) Set(val interface{}) error {
 	// we can't set unexported fields, so be sure this field is exported
@@ -84,6 +84,13 @@ func (f *Field) Set(val interface{}) error {
 	return nil
 }
 
+// Zero sets the field to its zero value. It returns an error if the field is not
+// settable (not addressable or not exported).
+func (f *Field) Zero() error {
+	zero := reflect.Zero(f.value.Type()).Interface()
+	return f.Set(zero)
+}
+
 // Fields returns a slice of Fields. This is particular handy to get the fields
 // of a nested struct . A struct tag with the content of "-" ignores the
 // checking of that particular field. Example:
@@ -107,11 +114,19 @@ func (f *Field) Field(name string) *Field {
 	return field
 }
 
-// Field returns the field from a nested struct. The boolean returns true if
-// the field was found. It panics if the nested struct is not exported or if
-// the field was not found.
+// FieldOk returns the field from a nested struct. The boolean returns whether
+// the field was found (true) or not (false).
 func (f *Field) FieldOk(name string) (*Field, bool) {
-	v := strctVal(f.value.Interface())
+	value := &f.value
+	// value must be settable so we need to make sure it holds the address of the
+	// variable and not a copy, so we can pass the pointer to strctVal instead of a
+	// copy (which is not assigned to any variable, hence not settable).
+	// see "https://blog.golang.org/laws-of-reflection#TOC_8."
+	if f.value.Kind() != reflect.Ptr {
+		a := f.value.Addr()
+		value = &a
+	}
+	v := strctVal(value.Interface())
 	t := v.Type()
 
 	field, ok := t.FieldByName(name)

vendor/github.com/fatih/structs/structs.go

@@ -1,7 +1,11 @@
 // Package structs contains various utilities functions to work with structs.
 package structs
 
-import "reflect"
+import (
+	"fmt"
+
+	"reflect"
+)
 
 var (
 	// DefaultTagName is the default tag name for struct fields which provides
@@ -42,6 +46,18 @@ func New(s interface{}) *Struct {
 //   // Field is ignored by this package.
 //   Field bool `structs:"-"`
 //
+// A tag value with the content of "string" uses the stringer to get the value. Example:
+//
+//   // The value will be output of Animal's String() func.
+//   // Map will panic if Animal does not implement String().
+//   Field *Animal `structs:"field,string"`
+//
+// A tag value with the option of "flatten" used in a struct field is to flatten its fields
+// in the output map. Example:
+//
+//   // The FieldStruct's fields will be flattened into the output map.
+//   FieldStruct time.Time `structs:",flatten"`
+//
 // A tag value with the option of "omitnested" stops iterating further if the type
 // is a struct. Example:
 //
@@ -64,13 +80,23 @@ func New(s interface{}) *Struct {
 // fields will be neglected.
 func (s *Struct) Map() map[string]interface{} {
 	out := make(map[string]interface{})
+	s.FillMap(out)
+	return out
+}
+
+// FillMap is the same as Map. Instead of returning the output, it fills the
+// given map.
+func (s *Struct) FillMap(out map[string]interface{}) {
+	if out == nil {
+		return
+	}
 
 	fields := s.structFields()
 
 	for _, field := range fields {
 		name := field.Name
 		val := s.value.FieldByName(name)
-
+		isSubStruct := false
 		var finalVal interface{}
 
 		tagName, tagOpts := parseTag(field.Tag.Get(s.TagName))
@@ -89,20 +115,38 @@ func (s *Struct) Map() map[string]interface{} {
 			}
 		}
 
-		if IsStruct(val.Interface()) && !tagOpts.Has("omitnested") {
-			// look out for embedded structs, and convert them to a
-			// map[string]interface{} too
-			n := New(val.Interface())
-			n.TagName = s.TagName
-			finalVal = n.Map()
+		if !tagOpts.Has("omitnested") {
+			finalVal = s.nested(val)
+
+			v := reflect.ValueOf(val.Interface())
+			if v.Kind() == reflect.Ptr {
+				v = v.Elem()
+			}
+
+			switch v.Kind() {
+			case reflect.Map, reflect.Struct:
+				isSubStruct = true
+			}
 		} else {
 			finalVal = val.Interface()
 		}
 
-		out[name] = finalVal
-	}
+		if tagOpts.Has("string") {
+			s, ok := val.Interface().(fmt.Stringer)
+			if ok {
+				out[name] = s.String()
+			}
+			continue
+		}
 
-	return out
+		if isSubStruct && (tagOpts.Has("flatten")) {
+			for k := range finalVal.(map[string]interface{}) {
+				out[k] = finalVal.(map[string]interface{})[k]
+			}
+		} else {
+			out[name] = finalVal
+		}
+	}
 }
 
 // Values converts the given s struct's field values to a []interface{}.  A
@@ -148,12 +192,18 @@ func (s *Struct) Values() []interface{} {
 			}
 		}
 
+		if tagOpts.Has("string") {
+			s, ok := val.Interface().(fmt.Stringer)
+			if ok {
+				t = append(t, s.String())
+			}
+			continue
+		}
+
 		if IsStruct(val.Interface()) && !tagOpts.Has("omitnested") {
 			// look out for embedded structs, and convert them to a
 			// []interface{} to be added to the final values slice
-			for _, embeddedVal := range Values(val.Interface()) {
-				t = append(t, embeddedVal)
-			}
+			t = append(t, Values(val.Interface())...)
 		} else {
 			t = append(t, val.Interface())
 		}
@@ -231,7 +281,7 @@ func (s *Struct) Field(name string) *Field {
 	return f
 }
 
-// Field returns a new Field struct that provides several high level functions
+// FieldOk returns a new Field struct that provides several high level functions
 // around a single struct field entity. The boolean returns true if the field
 // was found.
 func (s *Struct) FieldOk(name string) (*Field, bool) {
@@ -379,7 +429,7 @@ func strctVal(s interface{}) reflect.Value {
 	v := reflect.ValueOf(s)
 
 	// if pointer get the underlying element≤
-	if v.Kind() == reflect.Ptr {
+	for v.Kind() == reflect.Ptr {
 		v = v.Elem()
 	}
 
@@ -396,6 +446,12 @@ func Map(s interface{}) map[string]interface{} {
 	return New(s).Map()
 }
 
+// FillMap is the same as Map. Instead of returning the output, it fills the
+// given map.
+func FillMap(s interface{}, out map[string]interface{}) {
+	New(s).FillMap(out)
+}
+
 // Values converts the given struct to a []interface{}. For more info refer to
 // Struct types Values() method.  It panics if s's kind is not struct.
 func Values(s interface{}) []interface{} {
@@ -447,3 +503,82 @@ func IsStruct(s interface{}) bool {
 func Name(s interface{}) string {
 	return New(s).Name()
 }
+
+// nested retrieves recursively all types for the given value and returns the
+// nested value.
+func (s *Struct) nested(val reflect.Value) interface{} {
+	var finalVal interface{}
+
+	v := reflect.ValueOf(val.Interface())
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+
+	switch v.Kind() {
+	case reflect.Struct:
+		n := New(val.Interface())
+		n.TagName = s.TagName
+		m := n.Map()
+
+		// do not add the converted value if there are no exported fields, ie:
+		// time.Time
+		if len(m) == 0 {
+			finalVal = val.Interface()
+		} else {
+			finalVal = m
+		}
+	case reflect.Map:
+		// get the element type of the map
+		mapElem := val.Type()
+		switch val.Type().Kind() {
+		case reflect.Ptr, reflect.Array, reflect.Map,
+			reflect.Slice, reflect.Chan:
+			mapElem = val.Type().Elem()
+			if mapElem.Kind() == reflect.Ptr {
+				mapElem = mapElem.Elem()
+			}
+		}
+
+		// only iterate over struct types, ie: map[string]StructType,
+		// map[string][]StructType,
+		if mapElem.Kind() == reflect.Struct ||
+			(mapElem.Kind() == reflect.Slice &&
+				mapElem.Elem().Kind() == reflect.Struct) {
+			m := make(map[string]interface{}, val.Len())
+			for _, k := range val.MapKeys() {
+				m[k.String()] = s.nested(val.MapIndex(k))
+			}
+			finalVal = m
+			break
+		}
+
+		// TODO(arslan): should this be optional?
+		finalVal = val.Interface()
+	case reflect.Slice, reflect.Array:
+		if val.Type().Kind() == reflect.Interface {
+			finalVal = val.Interface()
+			break
+		}
+
+		// TODO(arslan): should this be optional?
+		// do not iterate of non struct types, just pass the value. Ie: []int,
+		// []string, co... We only iterate further if it's a struct.
+		// i.e []foo or []*foo
+		if val.Type().Elem().Kind() != reflect.Struct &&
+			!(val.Type().Elem().Kind() == reflect.Ptr &&
+				val.Type().Elem().Elem().Kind() == reflect.Struct) {
+			finalVal = val.Interface()
+			break
+		}
+
+		slices := make([]interface{}, val.Len())
+		for x := 0; x < val.Len(); x++ {
+			slices[x] = s.nested(val.Index(x))
+		}
+		finalVal = slices
+	default:
+		finalVal = val.Interface()
+	}
+
+	return finalVal
+}

vendor/github.com/fatih/structs/tags.go

@@ -5,7 +5,7 @@ import "strings"
 // tagOptions contains a slice of tag options
 type tagOptions []string
 
-// Has returns true if the given optiton is available in tagOptions
+// Has returns true if the given option is available in tagOptions
 func (t tagOptions) Has(opt string) bool {
 	for _, tagOpt := range t {
 		if tagOpt == opt {