Update vendoring

This updates the libcompose vendoring as well as a general update to
vendoring (adds the latest git commit of libcompose).

Closes https://github.com/kubernetes-incubator/kompose/issues/426
Closes https://github.com/kubernetes-incubator/kompose/issues/471

vendor/github.com/spf13/cast/cast.go

@@ -3,80 +3,150 @@
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
 
+// Package cast provides easy and safe casting in Go.
 package cast
 
 import "time"
 
+// ToBool casts an interface to a bool type.
 func ToBool(i interface{}) bool {
 	v, _ := ToBoolE(i)
 	return v
 }
 
+// ToTime casts an interface to a time.Time type.
 func ToTime(i interface{}) time.Time {
 	v, _ := ToTimeE(i)
 	return v
 }
 
+// ToDuration casts an interface to a time.Duration type.
 func ToDuration(i interface{}) time.Duration {
 	v, _ := ToDurationE(i)
 	return v
 }
 
+// ToFloat64 casts an interface to a float64 type.
 func ToFloat64(i interface{}) float64 {
 	v, _ := ToFloat64E(i)
 	return v
 }
 
+// ToFloat32 casts an interface to a float32 type.
+func ToFloat32(i interface{}) float32 {
+	v, _ := ToFloat32E(i)
+	return v
+}
+
+// ToInt64 casts an interface to an int64 type.
 func ToInt64(i interface{}) int64 {
 	v, _ := ToInt64E(i)
 	return v
 }
 
+// ToInt32 casts an interface to an int32 type.
+func ToInt32(i interface{}) int32 {
+	v, _ := ToInt32E(i)
+	return v
+}
+
+// ToInt16 casts an interface to an int16 type.
+func ToInt16(i interface{}) int16 {
+	v, _ := ToInt16E(i)
+	return v
+}
+
+// ToInt8 casts an interface to an int8 type.
+func ToInt8(i interface{}) int8 {
+	v, _ := ToInt8E(i)
+	return v
+}
+
+// ToInt casts an interface to an int type.
 func ToInt(i interface{}) int {
 	v, _ := ToIntE(i)
 	return v
 }
 
+// ToUint casts an interface to a uint type.
+func ToUint(i interface{}) uint {
+	v, _ := ToUintE(i)
+	return v
+}
+
+// ToUint64 casts an interface to a uint64 type.
+func ToUint64(i interface{}) uint64 {
+	v, _ := ToUint64E(i)
+	return v
+}
+
+// ToUint32 casts an interface to a uint32 type.
+func ToUint32(i interface{}) uint32 {
+	v, _ := ToUint32E(i)
+	return v
+}
+
+// ToUint16 casts an interface to a uint16 type.
+func ToUint16(i interface{}) uint16 {
+	v, _ := ToUint16E(i)
+	return v
+}
+
+// ToUint8 casts an interface to a uint8 type.
+func ToUint8(i interface{}) uint8 {
+	v, _ := ToUint8E(i)
+	return v
+}
+
+// ToString casts an interface to a string type.
 func ToString(i interface{}) string {
 	v, _ := ToStringE(i)
 	return v
 }
 
+// ToStringMapString casts an interface to a map[string]string type.
 func ToStringMapString(i interface{}) map[string]string {
 	v, _ := ToStringMapStringE(i)
 	return v
 }
 
+// ToStringMapStringSlice casts an interface to a map[string][]string type.
 func ToStringMapStringSlice(i interface{}) map[string][]string {
 	v, _ := ToStringMapStringSliceE(i)
 	return v
 }
 
+// ToStringMapBool casts an interface to a map[string]bool type.
 func ToStringMapBool(i interface{}) map[string]bool {
 	v, _ := ToStringMapBoolE(i)
 	return v
 }
 
+// ToStringMap casts an interface to a map[string]interface{} type.
 func ToStringMap(i interface{}) map[string]interface{} {
 	v, _ := ToStringMapE(i)
 	return v
 }
 
+// ToSlice casts an interface to a []interface{} type.
 func ToSlice(i interface{}) []interface{} {
 	v, _ := ToSliceE(i)
 	return v
 }
 
+// ToBoolSlice casts an interface to a []bool type.
 func ToBoolSlice(i interface{}) []bool {
 	v, _ := ToBoolSliceE(i)
 	return v
 }
 
+// ToStringSlice casts an interface to a []string type.
 func ToStringSlice(i interface{}) []string {
 	v, _ := ToStringSliceE(i)
 	return v
 }
 
+// ToIntSlice casts an interface to a []int type.
 func ToIntSlice(i interface{}) []int {
 	v, _ := ToIntSliceE(i)
 	return v

vendor/github.com/spf13/cast/caste.go

@@ -6,6 +6,7 @@
 package cast
 
 import (
+	"errors"
 	"fmt"
 	"html/template"
 	"reflect"
@@ -14,7 +15,9 @@ import (
 	"time"
 )
 
-// ToTimeE casts an empty interface to time.Time.
+var errNegativeNotAllowed = errors.New("unable to cast negative value")
+
+// ToTimeE casts an interface to a time.Time type.
 func ToTimeE(i interface{}) (tim time.Time, err error) {
 	i = indirect(i)
 
@@ -22,30 +25,32 @@ func ToTimeE(i interface{}) (tim time.Time, err error) {
 	case time.Time:
 		return v, nil
 	case string:
-		d, e := StringToDate(v)
-		if e == nil {
-			return d, nil
-		}
-		return time.Time{}, fmt.Errorf("Could not parse Date/Time format: %v\n", e)
+		return StringToDate(v)
 	case int:
 		return time.Unix(int64(v), 0), nil
-	case int32:
-		return time.Unix(int64(v), 0), nil
 	case int64:
 		return time.Unix(v, 0), nil
+	case int32:
+		return time.Unix(int64(v), 0), nil
+	case uint:
+		return time.Unix(int64(v), 0), nil
+	case uint64:
+		return time.Unix(int64(v), 0), nil
+	case uint32:
+		return time.Unix(int64(v), 0), nil
 	default:
-		return time.Time{}, fmt.Errorf("Unable to Cast %#v to Time\n", i)
+		return time.Time{}, fmt.Errorf("unable to cast %#v of type %T to Time", i, i)
 	}
 }
 
-// ToDurationE casts an empty interface to time.Duration.
+// ToDurationE casts an interface to a time.Duration type.
 func ToDurationE(i interface{}) (d time.Duration, err error) {
 	i = indirect(i)
 
 	switch s := i.(type) {
 	case time.Duration:
 		return s, nil
-	case int64, int32, int16, int8, int:
+	case int, int64, int32, int16, int8, uint, uint64, uint32, uint16, uint8:
 		d = time.Duration(ToInt64(s))
 		return
 	case float32, float64:
@@ -59,14 +64,13 @@ func ToDurationE(i interface{}) (d time.Duration, err error) {
 		}
 		return
 	default:
-		err = fmt.Errorf("Unable to Cast %#v to Duration\n", i)
+		err = fmt.Errorf("unable to cast %#v of type %T to Duration", i, i)
 		return
 	}
 }
 
-// ToBoolE casts an empty interface to a bool.
+// ToBoolE casts an interface to a bool type.
 func ToBoolE(i interface{}) (bool, error) {
-
 	i = indirect(i)
 
 	switch b := i.(type) {
@@ -82,11 +86,11 @@ func ToBoolE(i interface{}) (bool, error) {
 	case string:
 		return strconv.ParseBool(i.(string))
 	default:
-		return false, fmt.Errorf("Unable to Cast %#v to bool", i)
+		return false, fmt.Errorf("unable to cast %#v of type %T to bool", i, i)
 	}
 }
 
-// ToFloat64E casts an empty interface to a float64.
+// ToFloat64E casts an interface to a float64 type.
 func ToFloat64E(i interface{}) (float64, error) {
 	i = indirect(i)
 
@@ -95,6 +99,8 @@ func ToFloat64E(i interface{}) (float64, error) {
 		return s, nil
 	case float32:
 		return float64(s), nil
+	case int:
+		return float64(s), nil
 	case int64:
 		return float64(s), nil
 	case int32:
@@ -103,55 +109,266 @@ func ToFloat64E(i interface{}) (float64, error) {
 		return float64(s), nil
 	case int8:
 		return float64(s), nil
-	case int:
+	case uint:
+		return float64(s), nil
+	case uint64:
+		return float64(s), nil
+	case uint32:
+		return float64(s), nil
+	case uint16:
+		return float64(s), nil
+	case uint8:
 		return float64(s), nil
 	case string:
 		v, err := strconv.ParseFloat(s, 64)
 		if err == nil {
-			return float64(v), nil
+			return v, nil
 		}
-		return 0.0, fmt.Errorf("Unable to Cast %#v to float", i)
+		return 0, fmt.Errorf("unable to cast %#v of type %T to float64", i, i)
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
 	default:
-		return 0.0, fmt.Errorf("Unable to Cast %#v to float", i)
+		return 0, fmt.Errorf("unable to cast %#v of type %T to float64", i, i)
 	}
 }
 
-// ToInt64E casts an empty interface to an int64.
+// ToFloat32E casts an interface to a float32 type.
+func ToFloat32E(i interface{}) (float32, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case float64:
+		return float32(s), nil
+	case float32:
+		return s, nil
+	case int:
+		return float32(s), nil
+	case int64:
+		return float32(s), nil
+	case int32:
+		return float32(s), nil
+	case int16:
+		return float32(s), nil
+	case int8:
+		return float32(s), nil
+	case uint:
+		return float32(s), nil
+	case uint64:
+		return float32(s), nil
+	case uint32:
+		return float32(s), nil
+	case uint16:
+		return float32(s), nil
+	case uint8:
+		return float32(s), nil
+	case string:
+		v, err := strconv.ParseFloat(s, 32)
+		if err == nil {
+			return float32(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v of type %T to float32", i, i)
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to float32", i, i)
+	}
+}
+
+// ToInt64E casts an interface to an int64 type.
 func ToInt64E(i interface{}) (int64, error) {
 	i = indirect(i)
 
 	switch s := i.(type) {
-	case int64:
-		return s, nil
 	case int:
 		return int64(s), nil
+	case int64:
+		return s, nil
 	case int32:
 		return int64(s), nil
 	case int16:
 		return int64(s), nil
 	case int8:
 		return int64(s), nil
+	case uint:
+		return int64(s), nil
+	case uint64:
+		return int64(s), nil
+	case uint32:
+		return int64(s), nil
+	case uint16:
+		return int64(s), nil
+	case uint8:
+		return int64(s), nil
+	case float64:
+		return int64(s), nil
+	case float32:
+		return int64(s), nil
 	case string:
 		v, err := strconv.ParseInt(s, 0, 0)
 		if err == nil {
 			return v, nil
 		}
-		return 0, fmt.Errorf("Unable to Cast %#v to int64", i)
-	case float64:
-		return int64(s), nil
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int64", i, i)
 	case bool:
-		if bool(s) {
-			return int64(1), nil
+		if s {
+			return 1, nil
 		}
-		return int64(0), nil
+		return 0, nil
 	case nil:
-		return int64(0), nil
+		return 0, nil
 	default:
-		return int64(0), fmt.Errorf("Unable to Cast %#v to int64", i)
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int64", i, i)
 	}
 }
 
-// ToIntE casts an empty interface to an int.
+// ToInt32E casts an interface to an int32 type.
+func ToInt32E(i interface{}) (int32, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case int:
+		return int32(s), nil
+	case int64:
+		return int32(s), nil
+	case int32:
+		return s, nil
+	case int16:
+		return int32(s), nil
+	case int8:
+		return int32(s), nil
+	case uint:
+		return int32(s), nil
+	case uint64:
+		return int32(s), nil
+	case uint32:
+		return int32(s), nil
+	case uint16:
+		return int32(s), nil
+	case uint8:
+		return int32(s), nil
+	case float64:
+		return int32(s), nil
+	case float32:
+		return int32(s), nil
+	case string:
+		v, err := strconv.ParseInt(s, 0, 0)
+		if err == nil {
+			return int32(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int32", i, i)
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int32", i, i)
+	}
+}
+
+// ToInt16E casts an interface to an int16 type.
+func ToInt16E(i interface{}) (int16, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case int:
+		return int16(s), nil
+	case int64:
+		return int16(s), nil
+	case int32:
+		return int16(s), nil
+	case int16:
+		return s, nil
+	case int8:
+		return int16(s), nil
+	case uint:
+		return int16(s), nil
+	case uint64:
+		return int16(s), nil
+	case uint32:
+		return int16(s), nil
+	case uint16:
+		return int16(s), nil
+	case uint8:
+		return int16(s), nil
+	case float64:
+		return int16(s), nil
+	case float32:
+		return int16(s), nil
+	case string:
+		v, err := strconv.ParseInt(s, 0, 0)
+		if err == nil {
+			return int16(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int16", i, i)
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int16", i, i)
+	}
+}
+
+// ToInt8E casts an interface to an int8 type.
+func ToInt8E(i interface{}) (int8, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case int:
+		return int8(s), nil
+	case int64:
+		return int8(s), nil
+	case int32:
+		return int8(s), nil
+	case int16:
+		return int8(s), nil
+	case int8:
+		return s, nil
+	case uint:
+		return int8(s), nil
+	case uint64:
+		return int8(s), nil
+	case uint32:
+		return int8(s), nil
+	case uint16:
+		return int8(s), nil
+	case uint8:
+		return int8(s), nil
+	case float64:
+		return int8(s), nil
+	case float32:
+		return int8(s), nil
+	case string:
+		v, err := strconv.ParseInt(s, 0, 0)
+		if err == nil {
+			return int8(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int8", i, i)
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int8", i, i)
+	}
+}
+
+// ToIntE casts an interface to an int type.
 func ToIntE(i interface{}) (int, error) {
 	i = indirect(i)
 
@@ -166,23 +383,375 @@ func ToIntE(i interface{}) (int, error) {
 		return int(s), nil
 	case int8:
 		return int(s), nil
+	case uint:
+		return int(s), nil
+	case uint64:
+		return int(s), nil
+	case uint32:
+		return int(s), nil
+	case uint16:
+		return int(s), nil
+	case uint8:
+		return int(s), nil
+	case float64:
+		return int(s), nil
+	case float32:
+		return int(s), nil
 	case string:
 		v, err := strconv.ParseInt(s, 0, 0)
 		if err == nil {
 			return int(v), nil
 		}
-		return 0, fmt.Errorf("Unable to Cast %#v to int", i)
-	case float64:
-		return int(s), nil
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int", i, i)
 	case bool:
-		if bool(s) {
+		if s {
 			return 1, nil
 		}
 		return 0, nil
 	case nil:
 		return 0, nil
 	default:
-		return 0, fmt.Errorf("Unable to Cast %#v to int", i)
+		return 0, fmt.Errorf("unable to cast %#v of type %T to int", i, i)
+	}
+}
+
+// ToUintE casts an interface to a uint type.
+func ToUintE(i interface{}) (uint, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case string:
+		v, err := strconv.ParseUint(s, 0, 0)
+		if err == nil {
+			return uint(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v to uint: %s", i, err)
+	case int:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case int64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case int32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case int16:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case int8:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case uint:
+		return s, nil
+	case uint64:
+		return uint(s), nil
+	case uint32:
+		return uint(s), nil
+	case uint16:
+		return uint(s), nil
+	case uint8:
+		return uint(s), nil
+	case float64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case float32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint(s), nil
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to uint", i, i)
+	}
+}
+
+// ToUint64E casts an interface to a uint64 type.
+func ToUint64E(i interface{}) (uint64, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case string:
+		v, err := strconv.ParseUint(s, 0, 64)
+		if err == nil {
+			return v, nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v to uint64: %s", i, err)
+	case int:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case int64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case int32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case int16:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case int8:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case uint:
+		return uint64(s), nil
+	case uint64:
+		return s, nil
+	case uint32:
+		return uint64(s), nil
+	case uint16:
+		return uint64(s), nil
+	case uint8:
+		return uint64(s), nil
+	case float32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case float64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint64(s), nil
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to uint64", i, i)
+	}
+}
+
+// ToUint32E casts an interface to a uint32 type.
+func ToUint32E(i interface{}) (uint32, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case string:
+		v, err := strconv.ParseUint(s, 0, 32)
+		if err == nil {
+			return uint32(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v to uint32: %s", i, err)
+	case int:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case int64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case int32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case int16:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case int8:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case uint:
+		return uint32(s), nil
+	case uint64:
+		return uint32(s), nil
+	case uint32:
+		return s, nil
+	case uint16:
+		return uint32(s), nil
+	case uint8:
+		return uint32(s), nil
+	case float64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case float32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint32(s), nil
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to uint32", i, i)
+	}
+}
+
+// ToUint16E casts an interface to a uint16 type.
+func ToUint16E(i interface{}) (uint16, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case string:
+		v, err := strconv.ParseUint(s, 0, 16)
+		if err == nil {
+			return uint16(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v to uint16: %s", i, err)
+	case int:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case int64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case int32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case int16:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case int8:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case uint:
+		return uint16(s), nil
+	case uint64:
+		return uint16(s), nil
+	case uint32:
+		return uint16(s), nil
+	case uint16:
+		return s, nil
+	case uint8:
+		return uint16(s), nil
+	case float64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case float32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint16(s), nil
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to uint16", i, i)
+	}
+}
+
+// ToUint8E casts an interface to a uint type.
+func ToUint8E(i interface{}) (uint8, error) {
+	i = indirect(i)
+
+	switch s := i.(type) {
+	case string:
+		v, err := strconv.ParseUint(s, 0, 8)
+		if err == nil {
+			return uint8(v), nil
+		}
+		return 0, fmt.Errorf("unable to cast %#v to uint8: %s", i, err)
+	case int:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case int64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case int32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case int16:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case int8:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case uint:
+		return uint8(s), nil
+	case uint64:
+		return uint8(s), nil
+	case uint32:
+		return uint8(s), nil
+	case uint16:
+		return uint8(s), nil
+	case uint8:
+		return s, nil
+	case float64:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case float32:
+		if s < 0 {
+			return 0, errNegativeNotAllowed
+		}
+		return uint8(s), nil
+	case bool:
+		if s {
+			return 1, nil
+		}
+		return 0, nil
+	case nil:
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unable to cast %#v of type %T to uint8", i, i)
 	}
 }
 
@@ -225,7 +794,7 @@ func indirectToStringerOrError(a interface{}) interface{} {
 	return v.Interface()
 }
 
-// ToStringE casts an empty interface to a string.
+// ToStringE casts an interface to a string type.
 func ToStringE(i interface{}) (string, error) {
 	i = indirectToStringerOrError(i)
 
@@ -235,11 +804,29 @@ func ToStringE(i interface{}) (string, error) {
 	case bool:
 		return strconv.FormatBool(s), nil
 	case float64:
-		return strconv.FormatFloat(i.(float64), 'f', -1, 64), nil
-	case int64:
-		return strconv.FormatInt(i.(int64), 10), nil
+		return strconv.FormatFloat(s, 'f', -1, 64), nil
+	case float32:
+		return strconv.FormatFloat(float64(s), 'f', -1, 32), nil
 	case int:
-		return strconv.FormatInt(int64(i.(int)), 10), nil
+		return strconv.Itoa(s), nil
+	case int64:
+		return strconv.FormatInt(s, 10), nil
+	case int32:
+		return strconv.Itoa(int(s)), nil
+	case int16:
+		return strconv.FormatInt(int64(s), 10), nil
+	case int8:
+		return strconv.FormatInt(int64(s), 10), nil
+	case uint:
+		return strconv.FormatInt(int64(s), 10), nil
+	case uint64:
+		return strconv.FormatInt(int64(s), 10), nil
+	case uint32:
+		return strconv.FormatInt(int64(s), 10), nil
+	case uint16:
+		return strconv.FormatInt(int64(s), 10), nil
+	case uint8:
+		return strconv.FormatInt(int64(s), 10), nil
 	case []byte:
 		return string(s), nil
 	case template.HTML:
@@ -259,13 +846,12 @@ func ToStringE(i interface{}) (string, error) {
 	case error:
 		return s.Error(), nil
 	default:
-		return "", fmt.Errorf("Unable to Cast %#v to string", i)
+		return "", fmt.Errorf("unable to cast %#v of type %T to string", i, i)
 	}
 }
 
-// ToStringMapStringE casts an empty interface to a map[string]string.
+// ToStringMapStringE casts an interface to a map[string]string type.
 func ToStringMapStringE(i interface{}) (map[string]string, error) {
-
 	var m = map[string]string{}
 
 	switch v := i.(type) {
@@ -287,13 +873,12 @@ func ToStringMapStringE(i interface{}) (map[string]string, error) {
 		}
 		return m, nil
 	default:
-		return m, fmt.Errorf("Unable to Cast %#v to map[string]string", i)
+		return m, fmt.Errorf("unable to cast %#v of type %T to map[string]string", i, i)
 	}
 }
 
-// ToStringMapStringSliceE casts an empty interface to a map[string][]string.
+// ToStringMapStringSliceE casts an interface to a map[string][]string type.
 func ToStringMapStringSliceE(i interface{}) (map[string][]string, error) {
-
 	var m = map[string][]string{}
 
 	switch v := i.(type) {
@@ -339,23 +924,22 @@ func ToStringMapStringSliceE(i interface{}) (map[string][]string, error) {
 		for k, val := range v {
 			key, err := ToStringE(k)
 			if err != nil {
-				return m, fmt.Errorf("Unable to Cast %#v to map[string][]string", i)
+				return m, fmt.Errorf("unable to cast %#v of type %T to map[string][]string", i, i)
 			}
 			value, err := ToStringSliceE(val)
 			if err != nil {
-				return m, fmt.Errorf("Unable to Cast %#v to map[string][]string", i)
+				return m, fmt.Errorf("unable to cast %#v of type %T to map[string][]string", i, i)
 			}
 			m[key] = value
 		}
 	default:
-		return m, fmt.Errorf("Unable to Cast %#v to map[string][]string", i)
+		return m, fmt.Errorf("unable to cast %#v of type %T to map[string][]string", i, i)
 	}
 	return m, nil
 }
 
-// ToStringMapBoolE casts an empty interface to a map[string]bool.
+// ToStringMapBoolE casts an interface to a map[string]bool type.
 func ToStringMapBoolE(i interface{}) (map[string]bool, error) {
-
 	var m = map[string]bool{}
 
 	switch v := i.(type) {
@@ -372,13 +956,12 @@ func ToStringMapBoolE(i interface{}) (map[string]bool, error) {
 	case map[string]bool:
 		return v, nil
 	default:
-		return m, fmt.Errorf("Unable to Cast %#v to map[string]bool", i)
+		return m, fmt.Errorf("unable to cast %#v of type %T to map[string]bool", i, i)
 	}
 }
 
-// ToStringMapE casts an empty interface to a map[string]interface{}.
+// ToStringMapE casts an interface to a map[string]interface{} type.
 func ToStringMapE(i interface{}) (map[string]interface{}, error) {
-
 	var m = map[string]interface{}{}
 
 	switch v := i.(type) {
@@ -390,36 +973,31 @@ func ToStringMapE(i interface{}) (map[string]interface{}, error) {
 	case map[string]interface{}:
 		return v, nil
 	default:
-		return m, fmt.Errorf("Unable to Cast %#v to map[string]interface{}", i)
+		return m, fmt.Errorf("unable to cast %#v of type %T to map[string]interface{}", i, i)
 	}
 }
 
-// ToSliceE casts an empty interface to a []interface{}.
+// ToSliceE casts an interface to a []interface{} type.
 func ToSliceE(i interface{}) ([]interface{}, error) {
-
 	var s []interface{}
 
 	switch v := i.(type) {
 	case []interface{}:
-		for _, u := range v {
-			s = append(s, u)
-		}
-		return s, nil
+		return append(s, v...), nil
 	case []map[string]interface{}:
 		for _, u := range v {
 			s = append(s, u)
 		}
 		return s, nil
 	default:
-		return s, fmt.Errorf("Unable to Cast %#v of type %v to []interface{}", i, reflect.TypeOf(i))
+		return s, fmt.Errorf("unable to cast %#v of type %T to []interface{}", i, i)
 	}
 }
 
-// ToBoolSliceE casts an empty interface to a []bool.
+// ToBoolSliceE casts an interface to a []bool type.
 func ToBoolSliceE(i interface{}) ([]bool, error) {
-
 	if i == nil {
-		return []bool{}, fmt.Errorf("Unable to Cast %#v to []bool", i)
+		return []bool{}, fmt.Errorf("unable to cast %#v of type %T to []bool", i, i)
 	}
 
 	switch v := i.(type) {
@@ -435,19 +1013,18 @@ func ToBoolSliceE(i interface{}) ([]bool, error) {
 		for j := 0; j < s.Len(); j++ {
 			val, err := ToBoolE(s.Index(j).Interface())
 			if err != nil {
-				return []bool{}, fmt.Errorf("Unable to Cast %#v to []bool", i)
+				return []bool{}, fmt.Errorf("unable to cast %#v of type %T to []bool", i, i)
 			}
 			a[j] = val
 		}
 		return a, nil
 	default:
-		return []bool{}, fmt.Errorf("Unable to Cast %#v to []bool", i)
+		return []bool{}, fmt.Errorf("unable to cast %#v of type %T to []bool", i, i)
 	}
 }
 
-// ToStringSliceE casts an empty interface to a []string.
+// ToStringSliceE casts an interface to a []string type.
 func ToStringSliceE(i interface{}) ([]string, error) {
-
 	var a []string
 
 	switch v := i.(type) {
@@ -463,19 +1040,18 @@ func ToStringSliceE(i interface{}) ([]string, error) {
 	case interface{}:
 		str, err := ToStringE(v)
 		if err != nil {
-			return a, fmt.Errorf("Unable to Cast %#v to []string", i)
+			return a, fmt.Errorf("unable to cast %#v of type %T to []string", i, i)
 		}
 		return []string{str}, nil
 	default:
-		return a, fmt.Errorf("Unable to Cast %#v to []string", i)
+		return a, fmt.Errorf("unable to cast %#v of type %T to []string", i, i)
 	}
 }
 
-// ToIntSliceE casts an empty interface to a []int.
+// ToIntSliceE casts an interface to a []int type.
 func ToIntSliceE(i interface{}) ([]int, error) {
-
 	if i == nil {
-		return []int{}, fmt.Errorf("Unable to Cast %#v to []int", i)
+		return []int{}, fmt.Errorf("unable to cast %#v of type %T to []int", i, i)
 	}
 
 	switch v := i.(type) {
@@ -491,17 +1067,19 @@ func ToIntSliceE(i interface{}) ([]int, error) {
 		for j := 0; j < s.Len(); j++ {
 			val, err := ToIntE(s.Index(j).Interface())
 			if err != nil {
-				return []int{}, fmt.Errorf("Unable to Cast %#v to []int", i)
+				return []int{}, fmt.Errorf("unable to cast %#v of type %T to []int", i, i)
 			}
 			a[j] = val
 		}
 		return a, nil
 	default:
-		return []int{}, fmt.Errorf("Unable to Cast %#v to []int", i)
+		return []int{}, fmt.Errorf("unable to cast %#v of type %T to []int", i, i)
 	}
 }
 
-// StringToDate casts an empty interface to a time.Time.
+// StringToDate attempts to parse a string into a time.Time type using a
+// predefined list of formats.  If no suitable format is found, an error is
+// returned.
 func StringToDate(s string) (time.Time, error) {
 	return parseDateWith(s, []string{
 		time.RFC3339,
@@ -519,6 +1097,7 @@ func StringToDate(s string) (time.Time, error) {
 		"02 Jan 2006",
 		"2006-01-02 15:04:05 -07:00",
 		"2006-01-02 15:04:05 -0700",
+		"2006-01-02 15:04:05Z07:00", // RFC3339 without T
 		"2006-01-02 15:04:05",
 		time.Kitchen,
 		time.Stamp,
@@ -534,5 +1113,5 @@ func parseDateWith(s string, dates []string) (d time.Time, e error) {
 			return
 		}
 	}
-	return d, fmt.Errorf("Unable to parse date: %s", s)
+	return d, fmt.Errorf("unable to parse date: %s", s)
 }

vendor/github.com/spf13/cobra/command.go

@@ -155,12 +155,12 @@ func (c *Command) SetUsageTemplate(s string) {
 }
 
 // SetFlagErrorFunc sets a function to generate an error when flag parsing
-// fails
+// fails.
 func (c *Command) SetFlagErrorFunc(f func(*Command, error) error) {
 	c.flagErrorFunc = f
 }
 
-// SetHelpFunc sets help function. Can be defined by Application
+// SetHelpFunc sets help function. Can be defined by Application.
 func (c *Command) SetHelpFunc(f func(*Command, []string)) {
 	c.helpFunc = f
 }
@@ -187,7 +187,7 @@ func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string
 	}
 }
 
-// OutOrStdout returns output to stdout
+// OutOrStdout returns output to stdout.
 func (c *Command) OutOrStdout() io.Writer {
 	return c.getOut(os.Stdout)
 }
@@ -345,19 +345,19 @@ Aliases:
 {{end}}{{if .HasExample}}
 
 Examples:
-{{ .Example }}{{end}}{{ if .HasAvailableSubCommands}}
+{{ .Example }}{{end}}{{if .HasAvailableSubCommands}}
 
-Available Commands:{{range .Commands}}{{if .IsAvailableCommand}}
-  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableLocalFlags}}
+Available Commands:{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
 
 Flags:
-{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasAvailableInheritedFlags}}
+{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasAvailableInheritedFlags}}
 
 Global Flags:
 {{.InheritedFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasHelpSubCommands}}
 
-Additional help topics:{{range .Commands}}{{if .IsHelpCommand}}
-  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableSubCommands }}
+Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
+  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
 
 Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
 `
@@ -384,20 +384,18 @@ func (c *Command) resetChildrensParents() {
 	}
 }
 
-// Test if the named flag is a boolean flag.
-func isBooleanFlag(name string, f *flag.FlagSet) bool {
+func hasNoOptDefVal(name string, f *flag.FlagSet) bool {
 	flag := f.Lookup(name)
 	if flag == nil {
 		return false
 	}
-	return flag.Value.Type() == "bool"
+	return len(flag.NoOptDefVal) > 0
 }
 
-// Test if the named flag is a boolean flag.
-func isBooleanShortFlag(name string, f *flag.FlagSet) bool {
+func shortHasNoOptDefVal(name string, fs *flag.FlagSet) bool {
 	result := false
-	f.VisitAll(func(f *flag.Flag) {
-		if f.Shorthand == name && f.Value.Type() == "bool" {
+	fs.VisitAll(func(flag *flag.Flag) {
+		if flag.Shorthand == name && len(flag.NoOptDefVal) > 0 {
 			result = true
 		}
 	})
@@ -423,8 +421,8 @@ func stripFlags(args []string, c *Command) []string {
 				inQuote = true
 			case strings.HasPrefix(y, "--") && !strings.Contains(y, "="):
 				// TODO: this isn't quite right, we should really check ahead for 'true' or 'false'
-				inFlag = !isBooleanFlag(y[2:], c.Flags())
-			case strings.HasPrefix(y, "-") && !strings.Contains(y, "=") && len(y) == 2 && !isBooleanShortFlag(y[1:], c.Flags()):
+				inFlag = !hasNoOptDefVal(y[2:], c.Flags())
+			case strings.HasPrefix(y, "-") && !strings.Contains(y, "=") && len(y) == 2 && !shortHasNoOptDefVal(y[1:], c.Flags()):
 				inFlag = true
 			case inFlag:
 				inFlag = false
@@ -698,7 +696,6 @@ func (c *Command) Execute() error {
 
 // ExecuteC executes the command.
 func (c *Command) ExecuteC() (cmd *Command, err error) {
-
 	// Regardless of what command execute is called on, run on Root only
 	if c.HasParent() {
 		return c.Root().ExecuteC()
@@ -783,7 +780,7 @@ func (c *Command) initHelpCmd() {
 			Run: func(c *Command, args []string) {
 				cmd, _, e := c.Root().Find(args)
 				if cmd == nil || e != nil {
-					c.Printf("Unknown help topic %#q.", args)
+					c.Printf("Unknown help topic %#q\n", args)
 					c.Root().Usage()
 				} else {
 					cmd.Help()
@@ -1024,11 +1021,12 @@ func (c *Command) IsAvailableCommand() bool {
 	return false
 }
 
-// IsHelpCommand determines if a command is a 'help' command; a help command is
-// determined by the fact that it is NOT runnable/hidden/deprecated, and has no
-// sub commands that are runnable/hidden/deprecated.
-func (c *Command) IsHelpCommand() bool {
-
+// IsAdditionalHelpTopicCommand determines if a command is an additional
+// help topic command; additional help topic command is determined by the
+// fact that it is NOT runnable/hidden/deprecated, and has no sub commands that
+// are runnable/hidden/deprecated.
+// Concrete example: https://github.com/spf13/cobra/issues/393#issuecomment-282741924.
+func (c *Command) IsAdditionalHelpTopicCommand() bool {
 	// if a command is runnable, deprecated, or hidden it is not a 'help' command
 	if c.Runnable() || len(c.Deprecated) != 0 || c.Hidden {
 		return false
@@ -1036,7 +1034,7 @@ func (c *Command) IsHelpCommand() bool {
 
 	// if any non-help sub commands are found, the command is not a 'help' command
 	for _, sub := range c.commands {
-		if !sub.IsHelpCommand() {
+		if !sub.IsAdditionalHelpTopicCommand() {
 			return false
 		}
 	}
@@ -1049,10 +1047,9 @@ func (c *Command) IsHelpCommand() bool {
 // that need to be shown in the usage/help default template under 'additional help
 // topics'.
 func (c *Command) HasHelpSubCommands() bool {
-
 	// return true on the first found available 'help' sub command
 	for _, sub := range c.commands {
-		if sub.IsHelpCommand() {
+		if sub.IsAdditionalHelpTopicCommand() {
 			return true
 		}
 	}
@@ -1064,7 +1061,6 @@ func (c *Command) HasHelpSubCommands() bool {
 // HasAvailableSubCommands determines if a command has available sub commands that
 // need to be shown in the usage/help default template under 'available commands'.
 func (c *Command) HasAvailableSubCommands() bool {
-
 	// return true on the first found available (non deprecated/help/hidden)
 	// sub command
 	for _, sub := range c.commands {

vendor/github.com/spf13/viper/viper.go

@@ -1093,9 +1093,15 @@ func (v *Viper) ReadInConfig() error {
 		return err
 	}
 
-	v.config = make(map[string]interface{})
+	config := make(map[string]interface{})
 
-	return v.unmarshalReader(bytes.NewReader(file), v.config)
+	err = v.unmarshalReader(bytes.NewReader(file), config)
+	if err != nil {
+		return err
+	}
+
+	v.config = config
+	return nil
 }
 
 // MergeInConfig merges a new configuration with an existing config.