Update go dependencies

vendor/github.com/mitchellh/mapstructure/.travis.yml

@@ -1,7 +1,8 @@
-language: go 
+language: go
+
+go:
+  - 1.9.x
+  - tip
 
-go: 
-  - 1.8.1
-  
 script:
-  - go test 
+  - go test

vendor/github.com/mitchellh/mapstructure/README.md

@@ -1,4 +1,4 @@
-# mapstructure
+# mapstructure [![Godoc](https://godoc.org/github.com/mitchellh/mapstructure?status.svg)](https://godoc.org/github.com/mitchellh/mapstructure)
 
 mapstructure is a Go library for decoding generic map values to structures
 and vice versa, while providing helpful error handling.

vendor/github.com/mitchellh/mapstructure/decode_hooks.go

@@ -115,6 +115,25 @@ func StringToTimeDurationHookFunc() DecodeHookFunc {
 	}
 }
 
+// StringToTimeHookFunc returns a DecodeHookFunc that converts
+// strings to time.Time.
+func StringToTimeHookFunc(layout string) DecodeHookFunc {
+	return func(
+		f reflect.Type,
+		t reflect.Type,
+		data interface{}) (interface{}, error) {
+		if f.Kind() != reflect.String {
+			return data, nil
+		}
+		if t != reflect.TypeOf(time.Time{}) {
+			return data, nil
+		}
+
+		// Convert it by parsing
+		return time.Parse(layout, data.(string))
+	}
+}
+
 // WeaklyTypedHook is a DecodeHookFunc which adds support for weak typing to
 // the decoder.
 //

vendor/github.com/mitchellh/mapstructure/decode_hooks_test.go

@@ -1,229 +0,0 @@
-package mapstructure
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestComposeDecodeHookFunc(t *testing.T) {
-	f1 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		return data.(string) + "foo", nil
-	}
-
-	f2 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		return data.(string) + "bar", nil
-	}
-
-	f := ComposeDecodeHookFunc(f1, f2)
-
-	result, err := DecodeHookExec(
-		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-	if result.(string) != "foobar" {
-		t.Fatalf("bad: %#v", result)
-	}
-}
-
-func TestComposeDecodeHookFunc_err(t *testing.T) {
-	f1 := func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error) {
-		return nil, errors.New("foo")
-	}
-
-	f2 := func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error) {
-		panic("NOPE")
-	}
-
-	f := ComposeDecodeHookFunc(f1, f2)
-
-	_, err := DecodeHookExec(
-		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), 42)
-	if err.Error() != "foo" {
-		t.Fatalf("bad: %s", err)
-	}
-}
-
-func TestComposeDecodeHookFunc_kinds(t *testing.T) {
-	var f2From reflect.Kind
-
-	f1 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		return int(42), nil
-	}
-
-	f2 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		f2From = f
-		return data, nil
-	}
-
-	f := ComposeDecodeHookFunc(f1, f2)
-
-	_, err := DecodeHookExec(
-		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-	if f2From != reflect.Int {
-		t.Fatalf("bad: %#v", f2From)
-	}
-}
-
-func TestStringToSliceHookFunc(t *testing.T) {
-	f := StringToSliceHookFunc(",")
-
-	strType := reflect.TypeOf("")
-	sliceType := reflect.TypeOf([]byte(""))
-	cases := []struct {
-		f, t   reflect.Type
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		{sliceType, sliceType, 42, 42, false},
-		{strType, strType, 42, 42, false},
-		{
-			strType,
-			sliceType,
-			"foo,bar,baz",
-			[]string{"foo", "bar", "baz"},
-			false,
-		},
-		{
-			strType,
-			sliceType,
-			"",
-			[]string{},
-			false,
-		},
-	}
-
-	for i, tc := range cases {
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}
-
-func TestStringToTimeDurationHookFunc(t *testing.T) {
-	f := StringToTimeDurationHookFunc()
-
-	strType := reflect.TypeOf("")
-	timeType := reflect.TypeOf(time.Duration(5))
-	cases := []struct {
-		f, t   reflect.Type
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		{strType, timeType, "5s", 5 * time.Second, false},
-		{strType, timeType, "5", time.Duration(0), true},
-		{strType, strType, "5", "5", false},
-	}
-
-	for i, tc := range cases {
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}
-
-func TestWeaklyTypedHook(t *testing.T) {
-	var f DecodeHookFunc = WeaklyTypedHook
-
-	boolType := reflect.TypeOf(true)
-	strType := reflect.TypeOf("")
-	sliceType := reflect.TypeOf([]byte(""))
-	cases := []struct {
-		f, t   reflect.Type
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		// TO STRING
-		{
-			boolType,
-			strType,
-			false,
-			"0",
-			false,
-		},
-
-		{
-			boolType,
-			strType,
-			true,
-			"1",
-			false,
-		},
-
-		{
-			reflect.TypeOf(float32(1)),
-			strType,
-			float32(7),
-			"7",
-			false,
-		},
-
-		{
-			reflect.TypeOf(int(1)),
-			strType,
-			int(7),
-			"7",
-			false,
-		},
-
-		{
-			sliceType,
-			strType,
-			[]uint8("foo"),
-			"foo",
-			false,
-		},
-
-		{
-			reflect.TypeOf(uint(1)),
-			strType,
-			uint(7),
-			"7",
-			false,
-		},
-	}
-
-	for i, tc := range cases {
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}

vendor/github.com/mitchellh/mapstructure/mapstructure.go

@@ -114,12 +114,12 @@ type Metadata struct {
 	Unused []string
 }
 
-// Decode takes a map and uses reflection to convert it into the
-// given Go native structure. val must be a pointer to a struct.
-func Decode(m interface{}, rawVal interface{}) error {
+// Decode takes an input structure and uses reflection to translate it to
+// the output structure. output must be a pointer to a map or struct.
+func Decode(input interface{}, output interface{}) error {
 	config := &DecoderConfig{
 		Metadata: nil,
-		Result:   rawVal,
+		Result:   output,
 	}
 
 	decoder, err := NewDecoder(config)
@@ -127,7 +127,7 @@ func Decode(m interface{}, rawVal interface{}) error {
 		return err
 	}
 
-	return decoder.Decode(m)
+	return decoder.Decode(input)
 }
 
 // WeakDecode is the same as Decode but is shorthand to enable
@@ -147,6 +147,40 @@ func WeakDecode(input, output interface{}) error {
 	return decoder.Decode(input)
 }
 
+// DecodeMetadata is the same as Decode, but is shorthand to
+// enable metadata collection. See DecoderConfig for more info.
+func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
+	config := &DecoderConfig{
+		Metadata: metadata,
+		Result:   output,
+	}
+
+	decoder, err := NewDecoder(config)
+	if err != nil {
+		return err
+	}
+
+	return decoder.Decode(input)
+}
+
+// WeakDecodeMetadata is the same as Decode, but is shorthand to
+// enable both WeaklyTypedInput and metadata collection. See
+// DecoderConfig for more info.
+func WeakDecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
+	config := &DecoderConfig{
+		Metadata:         metadata,
+		Result:           output,
+		WeaklyTypedInput: true,
+	}
+
+	decoder, err := NewDecoder(config)
+	if err != nil {
+		return err
+	}
+
+	return decoder.Decode(input)
+}
+
 // NewDecoder returns a new decoder for the given configuration. Once
 // a decoder has been returned, the same configuration must not be used
 // again.
@@ -184,68 +218,81 @@ func NewDecoder(config *DecoderConfig) (*Decoder, error) {
 
 // Decode decodes the given raw interface to the target pointer specified
 // by the configuration.
-func (d *Decoder) Decode(raw interface{}) error {
-	return d.decode("", raw, reflect.ValueOf(d.config.Result).Elem())
+func (d *Decoder) Decode(input interface{}) error {
+	return d.decode("", input, reflect.ValueOf(d.config.Result).Elem())
 }
 
 // Decodes an unknown data type into a specific reflection value.
-func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error {
-	if data == nil {
-		// If the data is nil, then we don't set anything.
+func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {
+	if input == nil {
+		// If the data is nil, then we don't set anything, unless ZeroFields is set
+		// to true.
+		if d.config.ZeroFields {
+			outVal.Set(reflect.Zero(outVal.Type()))
+
+			if d.config.Metadata != nil && name != "" {
+				d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+			}
+		}
 		return nil
 	}
 
-	dataVal := reflect.ValueOf(data)
-	if !dataVal.IsValid() {
-		// If the data value is invalid, then we just set the value
+	inputVal := reflect.ValueOf(input)
+	if !inputVal.IsValid() {
+		// If the input value is invalid, then we just set the value
 		// to be the zero value.
-		val.Set(reflect.Zero(val.Type()))
+		outVal.Set(reflect.Zero(outVal.Type()))
+		if d.config.Metadata != nil && name != "" {
+			d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+		}
 		return nil
 	}
 
 	if d.config.DecodeHook != nil {
-		// We have a DecodeHook, so let's pre-process the data.
+		// We have a DecodeHook, so let's pre-process the input.
 		var err error
-		data, err = DecodeHookExec(
+		input, err = DecodeHookExec(
 			d.config.DecodeHook,
-			dataVal.Type(), val.Type(), data)
+			inputVal.Type(), outVal.Type(), input)
 		if err != nil {
 			return fmt.Errorf("error decoding '%s': %s", name, err)
 		}
 	}
 
 	var err error
-	dataKind := getKind(val)
-	switch dataKind {
+	inputKind := getKind(outVal)
+	switch inputKind {
 	case reflect.Bool:
-		err = d.decodeBool(name, data, val)
+		err = d.decodeBool(name, input, outVal)
 	case reflect.Interface:
-		err = d.decodeBasic(name, data, val)
+		err = d.decodeBasic(name, input, outVal)
 	case reflect.String:
-		err = d.decodeString(name, data, val)
+		err = d.decodeString(name, input, outVal)
 	case reflect.Int:
-		err = d.decodeInt(name, data, val)
+		err = d.decodeInt(name, input, outVal)
 	case reflect.Uint:
-		err = d.decodeUint(name, data, val)
+		err = d.decodeUint(name, input, outVal)
 	case reflect.Float32:
-		err = d.decodeFloat(name, data, val)
+		err = d.decodeFloat(name, input, outVal)
 	case reflect.Struct:
-		err = d.decodeStruct(name, data, val)
+		err = d.decodeStruct(name, input, outVal)
 	case reflect.Map:
-		err = d.decodeMap(name, data, val)
+		err = d.decodeMap(name, input, outVal)
 	case reflect.Ptr:
-		err = d.decodePtr(name, data, val)
+		err = d.decodePtr(name, input, outVal)
 	case reflect.Slice:
-		err = d.decodeSlice(name, data, val)
+		err = d.decodeSlice(name, input, outVal)
+	case reflect.Array:
+		err = d.decodeArray(name, input, outVal)
 	case reflect.Func:
-		err = d.decodeFunc(name, data, val)
+		err = d.decodeFunc(name, input, outVal)
 	default:
 		// If we reached this point then we weren't able to decode it
-		return fmt.Errorf("%s: unsupported type: %s", name, dataKind)
+		return fmt.Errorf("%s: unsupported type: %s", name, inputKind)
 	}
 
 	// If we reached here, then we successfully decoded SOMETHING, so
-	// mark the key as used if we're tracking metadata.
+	// mark the key as used if we're tracking metainput.
 	if d.config.Metadata != nil && name != "" {
 		d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
 	}
@@ -256,6 +303,9 @@ func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error
 // This decodes a basic type (bool, int, string, etc.) and sets the
 // value to "data" of that type.
 func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
+	if val.IsValid() && val.Elem().IsValid() {
+		return d.decode(name, data, val.Elem())
+	}
 	dataVal := reflect.ValueOf(data)
 	if !dataVal.IsValid() {
 		dataVal = reflect.Zero(val.Type())
@@ -292,12 +342,22 @@ func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value)
 		val.SetString(strconv.FormatUint(dataVal.Uint(), 10))
 	case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
 		val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))
-	case dataKind == reflect.Slice && d.config.WeaklyTypedInput:
+	case dataKind == reflect.Slice && d.config.WeaklyTypedInput,
+		dataKind == reflect.Array && d.config.WeaklyTypedInput:
 		dataType := dataVal.Type()
 		elemKind := dataType.Elem().Kind()
-		switch {
-		case elemKind == reflect.Uint8:
-			val.SetString(string(dataVal.Interface().([]uint8)))
+		switch elemKind {
+		case reflect.Uint8:
+			var uints []uint8
+			if dataKind == reflect.Array {
+				uints = make([]uint8, dataVal.Len(), dataVal.Len())
+				for i := range uints {
+					uints[i] = dataVal.Index(i).Interface().(uint8)
+				}
+			} else {
+				uints = dataVal.Interface().([]uint8)
+			}
+			val.SetString(string(uints))
 		default:
 			converted = false
 		}
@@ -487,34 +547,50 @@ func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) er
 		valMap = reflect.MakeMap(mapType)
 	}
 
-	// Check input type
+	// Check input type and based on the input type jump to the proper func
 	dataVal := reflect.Indirect(reflect.ValueOf(data))
-	if dataVal.Kind() != reflect.Map {
-		// In weak mode, we accept a slice of maps as an input...
+	switch dataVal.Kind() {
+	case reflect.Map:
+		return d.decodeMapFromMap(name, dataVal, val, valMap)
+
+	case reflect.Struct:
+		return d.decodeMapFromStruct(name, dataVal, val, valMap)
+
+	case reflect.Array, reflect.Slice:
 		if d.config.WeaklyTypedInput {
-			switch dataVal.Kind() {
-			case reflect.Array, reflect.Slice:
-				// Special case for BC reasons (covered by tests)
-				if dataVal.Len() == 0 {
-					val.Set(valMap)
-					return nil
-				}
-
-				for i := 0; i < dataVal.Len(); i++ {
-					err := d.decode(
-						fmt.Sprintf("%s[%d]", name, i),
-						dataVal.Index(i).Interface(), val)
-					if err != nil {
-						return err
-					}
-				}
-
-				return nil
-			}
+			return d.decodeMapFromSlice(name, dataVal, val, valMap)
 		}
 
+		fallthrough
+
+	default:
 		return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
 	}
+}
+
+func (d *Decoder) decodeMapFromSlice(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+	// Special case for BC reasons (covered by tests)
+	if dataVal.Len() == 0 {
+		val.Set(valMap)
+		return nil
+	}
+
+	for i := 0; i < dataVal.Len(); i++ {
+		err := d.decode(
+			fmt.Sprintf("%s[%d]", name, i),
+			dataVal.Index(i).Interface(), val)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+	valType := val.Type()
+	valKeyType := valType.Key()
+	valElemType := valType.Elem()
 
 	// Accumulate errors
 	errors := make([]string, 0)
@@ -551,22 +627,106 @@ func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) er
 	return nil
 }
 
+func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+	typ := dataVal.Type()
+	for i := 0; i < typ.NumField(); i++ {
+		// Get the StructField first since this is a cheap operation. If the
+		// field is unexported, then ignore it.
+		f := typ.Field(i)
+		if f.PkgPath != "" {
+			continue
+		}
+
+		// Next get the actual value of this field and verify it is assignable
+		// to the map value.
+		v := dataVal.Field(i)
+		if !v.Type().AssignableTo(valMap.Type().Elem()) {
+			return fmt.Errorf("cannot assign type '%s' to map value field of type '%s'", v.Type(), valMap.Type().Elem())
+		}
+
+		tagValue := f.Tag.Get(d.config.TagName)
+		tagParts := strings.Split(tagValue, ",")
+
+		// Determine the name of the key in the map
+		keyName := f.Name
+		if tagParts[0] != "" {
+			if tagParts[0] == "-" {
+				continue
+			}
+			keyName = tagParts[0]
+		}
+
+		// If "squash" is specified in the tag, we squash the field down.
+		squash := false
+		for _, tag := range tagParts[1:] {
+			if tag == "squash" {
+				squash = true
+				break
+			}
+		}
+		if squash && v.Kind() != reflect.Struct {
+			return fmt.Errorf("cannot squash non-struct type '%s'", v.Type())
+		}
+
+		switch v.Kind() {
+		// this is an embedded struct, so handle it differently
+		case reflect.Struct:
+			x := reflect.New(v.Type())
+			x.Elem().Set(v)
+
+			vType := valMap.Type()
+			vKeyType := vType.Key()
+			vElemType := vType.Elem()
+			mType := reflect.MapOf(vKeyType, vElemType)
+			vMap := reflect.MakeMap(mType)
+
+			err := d.decode(keyName, x.Interface(), vMap)
+			if err != nil {
+				return err
+			}
+
+			if squash {
+				for _, k := range vMap.MapKeys() {
+					valMap.SetMapIndex(k, vMap.MapIndex(k))
+				}
+			} else {
+				valMap.SetMapIndex(reflect.ValueOf(keyName), vMap)
+			}
+
+		default:
+			valMap.SetMapIndex(reflect.ValueOf(keyName), v)
+		}
+	}
+
+	if val.CanAddr() {
+		val.Set(valMap)
+	}
+
+	return nil
+}
+
 func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) error {
 	// Create an element of the concrete (non pointer) type and decode
 	// into that. Then set the value of the pointer to this type.
 	valType := val.Type()
 	valElemType := valType.Elem()
 
-	realVal := val
-	if realVal.IsNil() || d.config.ZeroFields {
-		realVal = reflect.New(valElemType)
-	}
+	if val.CanSet() {
+		realVal := val
+		if realVal.IsNil() || d.config.ZeroFields {
+			realVal = reflect.New(valElemType)
+		}
 
-	if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
-		return err
-	}
+		if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
+			return err
+		}
 
-	val.Set(realVal)
+		val.Set(realVal)
+	} else {
+		if err := d.decode(name, data, reflect.Indirect(val)); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -602,7 +762,8 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
 						val.Set(reflect.MakeSlice(sliceType, 0, 0))
 						return nil
 					}
-
+				case dataValKind == reflect.String && valElemType.Kind() == reflect.Uint8:
+					return d.decodeSlice(name, []byte(dataVal.String()), val)
 				// All other types we try to convert to the slice type
 				// and "lift" it into it. i.e. a string becomes a string slice.
 				default:
@@ -610,7 +771,6 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
 					return d.decodeSlice(name, []interface{}{data}, val)
 				}
 			}
-
 			return fmt.Errorf(
 				"'%s': source data must be an array or slice, got %s", name, dataValKind)
 
@@ -647,6 +807,73 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
 	return nil
 }
 
+func (d *Decoder) decodeArray(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.Indirect(reflect.ValueOf(data))
+	dataValKind := dataVal.Kind()
+	valType := val.Type()
+	valElemType := valType.Elem()
+	arrayType := reflect.ArrayOf(valType.Len(), valElemType)
+
+	valArray := val
+
+	if valArray.Interface() == reflect.Zero(valArray.Type()).Interface() || d.config.ZeroFields {
+		// Check input type
+		if dataValKind != reflect.Array && dataValKind != reflect.Slice {
+			if d.config.WeaklyTypedInput {
+				switch {
+				// Empty maps turn into empty arrays
+				case dataValKind == reflect.Map:
+					if dataVal.Len() == 0 {
+						val.Set(reflect.Zero(arrayType))
+						return nil
+					}
+
+				// All other types we try to convert to the array type
+				// and "lift" it into it. i.e. a string becomes a string array.
+				default:
+					// Just re-try this function with data as a slice.
+					return d.decodeArray(name, []interface{}{data}, val)
+				}
+			}
+
+			return fmt.Errorf(
+				"'%s': source data must be an array or slice, got %s", name, dataValKind)
+
+		}
+		if dataVal.Len() > arrayType.Len() {
+			return fmt.Errorf(
+				"'%s': expected source data to have length less or equal to %d, got %d", name, arrayType.Len(), dataVal.Len())
+
+		}
+
+		// Make a new array to hold our result, same size as the original data.
+		valArray = reflect.New(arrayType).Elem()
+	}
+
+	// Accumulate any errors
+	errors := make([]string, 0)
+
+	for i := 0; i < dataVal.Len(); i++ {
+		currentData := dataVal.Index(i).Interface()
+		currentField := valArray.Index(i)
+
+		fieldName := fmt.Sprintf("%s[%d]", name, i)
+		if err := d.decode(fieldName, currentData, currentField); err != nil {
+			errors = appendErrors(errors, err)
+		}
+	}
+
+	// Finally, set the value to the array we built up
+	val.Set(valArray)
+
+	// If there were errors, we return those
+	if len(errors) > 0 {
+		return &Error{errors}
+	}
+
+	return nil
+}
+
 func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {
 	dataVal := reflect.Indirect(reflect.ValueOf(data))
 
@@ -716,7 +943,7 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
 					errors = appendErrors(errors,
 						fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldKind))
 				} else {
-					structs = append(structs, val.FieldByName(fieldType.Name))
+					structs = append(structs, structVal.FieldByName(fieldType.Name))
 				}
 				continue
 			}

vendor/github.com/mitchellh/mapstructure/mapstructure_benchmark_test.go

@@ -1,279 +0,0 @@
-package mapstructure
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func Benchmark_Decode(b *testing.B) {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	input := map[string]interface{}{
-		"name":   "Mitchell",
-		"age":    91,
-		"emails": []string{"one", "two", "three"},
-		"extra": map[string]string{
-			"twitter": "mitchellh",
-		},
-	}
-
-	var result Person
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-// decodeViaJSON takes the map data and passes it through encoding/json to convert it into the
-// given Go native structure pointed to by v. v must be a pointer to a struct.
-func decodeViaJSON(data interface{}, v interface{}) error {
-	// Perform the task by simply marshalling the input into JSON,
-	// then unmarshalling it into target native Go struct.
-	b, err := json.Marshal(data)
-	if err != nil {
-		return err
-	}
-	return json.Unmarshal(b, v)
-}
-
-func Benchmark_DecodeViaJSON(b *testing.B) {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	input := map[string]interface{}{
-		"name":   "Mitchell",
-		"age":    91,
-		"emails": []string{"one", "two", "three"},
-		"extra": map[string]string{
-			"twitter": "mitchellh",
-		},
-	}
-
-	var result Person
-	for i := 0; i < b.N; i++ {
-		decodeViaJSON(input, &result)
-	}
-}
-
-func Benchmark_DecodeBasic(b *testing.B) {
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"vint":    42,
-		"Vuint":   42,
-		"vbool":   true,
-		"Vfloat":  42.42,
-		"vsilent": true,
-		"vdata":   42,
-	}
-
-	var result Basic
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeEmbedded(b *testing.B) {
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"Basic": map[string]interface{}{
-			"vstring": "innerfoo",
-		},
-		"vunique": "bar",
-	}
-
-	var result Embedded
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeTypeConversion(b *testing.B) {
-	input := map[string]interface{}{
-		"IntToFloat":    42,
-		"IntToUint":     42,
-		"IntToBool":     1,
-		"IntToString":   42,
-		"UintToInt":     42,
-		"UintToFloat":   42,
-		"UintToBool":    42,
-		"UintToString":  42,
-		"BoolToInt":     true,
-		"BoolToUint":    true,
-		"BoolToFloat":   true,
-		"BoolToString":  true,
-		"FloatToInt":    42.42,
-		"FloatToUint":   42.42,
-		"FloatToBool":   42.42,
-		"FloatToString": 42.42,
-		"StringToInt":   "42",
-		"StringToUint":  "42",
-		"StringToBool":  "1",
-		"StringToFloat": "42.42",
-		"SliceToMap":    []interface{}{},
-		"MapToSlice":    map[string]interface{}{},
-	}
-
-	var resultStrict TypeConversionResult
-	for i := 0; i < b.N; i++ {
-		Decode(input, &resultStrict)
-	}
-}
-
-func Benchmark_DecodeMap(b *testing.B) {
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vother": map[interface{}]interface{}{
-			"foo": "foo",
-			"bar": "bar",
-		},
-	}
-
-	var result Map
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeMapOfStruct(b *testing.B) {
-	input := map[string]interface{}{
-		"value": map[string]interface{}{
-			"foo": map[string]string{"vstring": "one"},
-			"bar": map[string]string{"vstring": "two"},
-		},
-	}
-
-	var result MapOfStruct
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeSlice(b *testing.B) {
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": []string{"foo", "bar", "baz"},
-	}
-
-	var result Slice
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeSliceOfStruct(b *testing.B) {
-	input := map[string]interface{}{
-		"value": []map[string]interface{}{
-			{"vstring": "one"},
-			{"vstring": "two"},
-		},
-	}
-
-	var result SliceOfStruct
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeWeaklyTypedInput(b *testing.B) {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON, generated by a weakly typed language
-	// such as PHP.
-	input := map[string]interface{}{
-		"name":   123,                      // number => string
-		"age":    "42",                     // string => number
-		"emails": map[string]interface{}{}, // empty map => empty array
-	}
-
-	var result Person
-	config := &DecoderConfig{
-		WeaklyTypedInput: true,
-		Result:           &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		decoder.Decode(input)
-	}
-}
-
-func Benchmark_DecodeMetadata(b *testing.B) {
-	type Person struct {
-		Name string
-		Age  int
-	}
-
-	input := map[string]interface{}{
-		"name":  "Mitchell",
-		"age":   91,
-		"email": "foo@bar.com",
-	}
-
-	var md Metadata
-	var result Person
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		decoder.Decode(input)
-	}
-}
-
-func Benchmark_DecodeMetadataEmbedded(b *testing.B) {
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"vunique": "bar",
-	}
-
-	var md Metadata
-	var result EmbeddedSquash
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		b.Fatalf("err: %s", err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		decoder.Decode(input)
-	}
-}
-
-func Benchmark_DecodeTagged(b *testing.B) {
-	input := map[string]interface{}{
-		"foo": "bar",
-		"bar": "value",
-	}
-
-	var result Tagged
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}

vendor/github.com/mitchellh/mapstructure/mapstructure_bugs_test.go

@@ -1,260 +0,0 @@
-package mapstructure
-
-import "testing"
-
-// GH-1
-func TestDecode_NilValue(t *testing.T) {
-	input := map[string]interface{}{
-		"vfoo":   nil,
-		"vother": nil,
-	}
-
-	var result Map
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("should not error: %s", err)
-	}
-
-	if result.Vfoo != "" {
-		t.Fatalf("value should be default: %s", result.Vfoo)
-	}
-
-	if result.Vother != nil {
-		t.Fatalf("Vother should be nil: %s", result.Vother)
-	}
-}
-
-// GH-10
-func TestDecode_mapInterfaceInterface(t *testing.T) {
-	input := map[interface{}]interface{}{
-		"vfoo":   nil,
-		"vother": nil,
-	}
-
-	var result Map
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("should not error: %s", err)
-	}
-
-	if result.Vfoo != "" {
-		t.Fatalf("value should be default: %s", result.Vfoo)
-	}
-
-	if result.Vother != nil {
-		t.Fatalf("Vother should be nil: %s", result.Vother)
-	}
-}
-
-// #48
-func TestNestedTypePointerWithDefaults(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-		},
-	}
-
-	result := NestedPointer{
-		Vbar: &Basic{
-			Vuint: 42,
-		},
-	}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-
-	// this is the error
-	if result.Vbar.Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vbar.Vuint)
-	}
-
-}
-
-type NestedSlice struct {
-	Vfoo   string
-	Vbars  []Basic
-	Vempty []Basic
-}
-
-// #48
-func TestNestedTypeSliceWithDefaults(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbars": []map[string]interface{}{
-			{"vstring": "foo", "vint": 42, "vbool": true},
-			{"vint": 42, "vbool": true},
-		},
-		"vempty": []map[string]interface{}{
-			{"vstring": "foo", "vint": 42, "vbool": true},
-			{"vint": 42, "vbool": true},
-		},
-	}
-
-	result := NestedSlice{
-		Vbars: []Basic{
-			{Vuint: 42},
-			{Vstring: "foo"},
-		},
-	}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbars[0].Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbars[0].Vstring)
-	}
-	// this is the error
-	if result.Vbars[0].Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vbars[0].Vuint)
-	}
-}
-
-// #48 workaround
-func TestNestedTypeWithDefaults(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-		},
-	}
-
-	result := Nested{
-		Vbar: Basic{
-			Vuint: 42,
-		},
-	}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-
-	// this is the error
-	if result.Vbar.Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vbar.Vuint)
-	}
-
-}
-
-// #67 panic() on extending slices (decodeSlice with disabled ZeroValues)
-func TestDecodeSliceToEmptySliceWOZeroing(t *testing.T) {
-	t.Parallel()
-
-	type TestStruct struct {
-		Vfoo []string
-	}
-
-	decode := func(m interface{}, rawVal interface{}) error {
-		config := &DecoderConfig{
-			Metadata:   nil,
-			Result:     rawVal,
-			ZeroFields: false,
-		}
-
-		decoder, err := NewDecoder(config)
-		if err != nil {
-			return err
-		}
-
-		return decoder.Decode(m)
-	}
-
-	{
-		input := map[string]interface{}{
-			"vfoo": []string{"1"},
-		}
-
-		result := &TestStruct{}
-
-		err := decode(input, &result)
-		if err != nil {
-			t.Fatalf("got an err: %s", err.Error())
-		}
-	}
-
-	{
-		input := map[string]interface{}{
-			"vfoo": []string{"1"},
-		}
-
-		result := &TestStruct{
-			Vfoo: []string{},
-		}
-
-		err := decode(input, &result)
-		if err != nil {
-			t.Fatalf("got an err: %s", err.Error())
-		}
-	}
-
-	{
-		input := map[string]interface{}{
-			"vfoo": []string{"2", "3"},
-		}
-
-		result := &TestStruct{
-			Vfoo: []string{"1"},
-		}
-
-		err := decode(input, &result)
-		if err != nil {
-			t.Fatalf("got an err: %s", err.Error())
-		}
-	}
-}

vendor/github.com/mitchellh/mapstructure/mapstructure_examples_test.go

@@ -1,203 +0,0 @@
-package mapstructure
-
-import (
-	"fmt"
-)
-
-func ExampleDecode() {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON where we're not quite sure of the
-	// struct initially.
-	input := map[string]interface{}{
-		"name":   "Mitchell",
-		"age":    91,
-		"emails": []string{"one", "two", "three"},
-		"extra": map[string]string{
-			"twitter": "mitchellh",
-		},
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%#v", result)
-	// Output:
-	// mapstructure.Person{Name:"Mitchell", Age:91, Emails:[]string{"one", "two", "three"}, Extra:map[string]string{"twitter":"mitchellh"}}
-}
-
-func ExampleDecode_errors() {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON where we're not quite sure of the
-	// struct initially.
-	input := map[string]interface{}{
-		"name":   123,
-		"age":    "bad value",
-		"emails": []int{1, 2, 3},
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err == nil {
-		panic("should have an error")
-	}
-
-	fmt.Println(err.Error())
-	// Output:
-	// 5 error(s) decoding:
-	//
-	// * 'Age' expected type 'int', got unconvertible type 'string'
-	// * 'Emails[0]' expected type 'string', got unconvertible type 'int'
-	// * 'Emails[1]' expected type 'string', got unconvertible type 'int'
-	// * 'Emails[2]' expected type 'string', got unconvertible type 'int'
-	// * 'Name' expected type 'string', got unconvertible type 'int'
-}
-
-func ExampleDecode_metadata() {
-	type Person struct {
-		Name string
-		Age  int
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON where we're not quite sure of the
-	// struct initially.
-	input := map[string]interface{}{
-		"name":  "Mitchell",
-		"age":   91,
-		"email": "foo@bar.com",
-	}
-
-	// For metadata, we make a more advanced DecoderConfig so we can
-	// more finely configure the decoder that is used. In this case, we
-	// just tell the decoder we want to track metadata.
-	var md Metadata
-	var result Person
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	if err := decoder.Decode(input); err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("Unused keys: %#v", md.Unused)
-	// Output:
-	// Unused keys: []string{"email"}
-}
-
-func ExampleDecode_weaklyTypedInput() {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON, generated by a weakly typed language
-	// such as PHP.
-	input := map[string]interface{}{
-		"name":   123,                      // number => string
-		"age":    "42",                     // string => number
-		"emails": map[string]interface{}{}, // empty map => empty array
-	}
-
-	var result Person
-	config := &DecoderConfig{
-		WeaklyTypedInput: true,
-		Result:           &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%#v", result)
-	// Output: mapstructure.Person{Name:"123", Age:42, Emails:[]string{}}
-}
-
-func ExampleDecode_tags() {
-	// Note that the mapstructure tags defined in the struct type
-	// can indicate which fields the values are mapped to.
-	type Person struct {
-		Name string `mapstructure:"person_name"`
-		Age  int    `mapstructure:"person_age"`
-	}
-
-	input := map[string]interface{}{
-		"person_name": "Mitchell",
-		"person_age":  91,
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%#v", result)
-	// Output:
-	// mapstructure.Person{Name:"Mitchell", Age:91}
-}
-
-func ExampleDecode_embeddedStruct() {
-	// Squashing multiple embedded structs is allowed using the squash tag.
-	// This is demonstrated by creating a composite struct of multiple types
-	// and decoding into it. In this case, a person can carry with it both
-	// a Family and a Location, as well as their own FirstName.
-	type Family struct {
-		LastName string
-	}
-	type Location struct {
-		City string
-	}
-	type Person struct {
-		Family    `mapstructure:",squash"`
-		Location  `mapstructure:",squash"`
-		FirstName string
-	}
-
-	input := map[string]interface{}{
-		"FirstName": "Mitchell",
-		"LastName":  "Hashimoto",
-		"City":      "San Francisco",
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%s %s, %s", result.FirstName, result.LastName, result.City)
-	// Output:
-	// Mitchell Hashimoto, San Francisco
-}