Update a few dependencies

github.com/go-openapi/*
github.com/asaskevich/govalidator

vendor/github.com/go-openapi/strfmt/format.go

@@ -19,24 +19,29 @@ import (
 	"reflect"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/go-openapi/errors"
+	"github.com/mitchellh/mapstructure"
 )
 
 // Default is the default formats registry
 var Default = NewSeededFormats(nil, nil)
 
-// Validator represents a validator for a string format
+// Validator represents a validator for a string format.
 type Validator func(string) bool
 
-// Format represents a string format
+// Format represents a string format.
+//
+// All implementations of Format provide a string representation and text
+// marshaling/unmarshaling interface to be used by encoders (e.g. encoding/json).
 type Format interface {
 	String() string
 	encoding.TextMarshaler
 	encoding.TextUnmarshaler
 }
 
-// Registry is a registry of string formats
+// Registry is a registry of string formats, with a validation method.
 type Registry interface {
 	Add(string, Format, Validator) bool
 	DelByName(string) bool
@@ -44,6 +49,7 @@ type Registry interface {
 	ContainsName(string) bool
 	Validates(string, string) bool
 	Parse(string, string) (interface{}, error)
+	MapStructureHookFunc() mapstructure.DecodeHookFunc
 }
 
 type knownFormat struct {
@@ -53,7 +59,7 @@ type knownFormat struct {
 	Validator Validator
 }
 
-// NameNormalizer is a function that normalizes a format name
+// NameNormalizer is a function that normalizes a format name.
 type NameNormalizer func(string) string
 
 // DefaultNameNormalizer removes all dashes
@@ -85,6 +91,77 @@ func NewSeededFormats(seeds []knownFormat, normalizer NameNormalizer) Registry {
 	}
 }
 
+// MapStructureHookFunc is a decode hook function for mapstructure
+func (f *defaultFormats) MapStructureHookFunc() mapstructure.DecodeHookFunc {
+	return func(from reflect.Type, to reflect.Type, data interface{}) (interface{}, error) {
+		if from.Kind() != reflect.String {
+			return data, nil
+		}
+		for _, v := range f.data {
+			tpe, _ := f.GetType(v.Name)
+			if to == tpe {
+				switch v.Name {
+				case "date":
+					d, err := time.Parse(RFC3339FullDate, data.(string))
+					if err != nil {
+						return nil, err
+					}
+					return Date(d), nil
+				case "datetime":
+					return ParseDateTime(data.(string))
+				case "duration":
+					dur, err := ParseDuration(data.(string))
+					if err != nil {
+						return nil, err
+					}
+					return Duration(dur), nil
+				case "uri":
+					return URI(data.(string)), nil
+				case "email":
+					return Email(data.(string)), nil
+				case "uuid":
+					return UUID(data.(string)), nil
+				case "uuid3":
+					return UUID3(data.(string)), nil
+				case "uuid4":
+					return UUID4(data.(string)), nil
+				case "uuid5":
+					return UUID5(data.(string)), nil
+				case "hostname":
+					return Hostname(data.(string)), nil
+				case "ipv4":
+					return IPv4(data.(string)), nil
+				case "ipv6":
+					return IPv6(data.(string)), nil
+				case "mac":
+					return MAC(data.(string)), nil
+				case "isbn":
+					return ISBN(data.(string)), nil
+				case "isbn10":
+					return ISBN10(data.(string)), nil
+				case "isbn13":
+					return ISBN13(data.(string)), nil
+				case "creditcard":
+					return CreditCard(data.(string)), nil
+				case "ssn":
+					return SSN(data.(string)), nil
+				case "hexcolor":
+					return HexColor(data.(string)), nil
+				case "rgbcolor":
+					return RGBColor(data.(string)), nil
+				case "byte":
+					return Base64(data.(string)), nil
+				case "password":
+					return Password(data.(string)), nil
+				default:
+					return nil, errors.InvalidTypeName(v.Name)
+				}
+			}
+		}
+		return data, nil
+	}
+}
+
 // Add adds a new format, return true if this was a new item instead of a replacement
 func (f *defaultFormats) Add(name string, strfmt Format, validator Validator) bool {
 	f.Lock()
@@ -191,6 +268,10 @@ func (f *defaultFormats) ContainsFormat(strfmt Format) bool {
 	return false
 }
 
+// Validates passed data against format.
+//
+// Note that the format name is automatically normalized, e.g. one may
+// use "date-time" to use the "datetime" format validator.
 func (f *defaultFormats) Validates(name, data string) bool {
 	f.Lock()
 	defer f.Unlock()
@@ -203,6 +284,9 @@ func (f *defaultFormats) Validates(name, data string) bool {
 	return false
 }
 
+// Parse a string into the appropriate format representation type.
+//
+// E.g. parsing a string a "date" will return a Date type.
 func (f *defaultFormats) Parse(name, data string) (interface{}, error) {
 	f.Lock()
 	defer f.Unlock()