Initial transfer of provider code

21 files changed, 2619 insertions, 0 deletions

diff --git a/vendor/github.com/mitchellh/copystructure/LICENSE b/vendor/github.com/mitchellh/copystructure/LICENSE
new file mode 100644
index 0000000..2298515
--- /dev/null
+++ b/vendor/github.com/mitchellh/copystructure/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mitchell Hashimoto
+
+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.
diff --git a/vendor/github.com/mitchellh/copystructure/README.md b/vendor/github.com/mitchellh/copystructure/README.md
new file mode 100644
index 0000000..bcb8c8d
--- /dev/null
+++ b/vendor/github.com/mitchellh/copystructure/README.md
@@ -0,0 +1,21 @@
+# copystructure

+

+copystructure is a Go library for deep copying values in Go.

+

+This allows you to copy Go values that may contain reference values

+such as maps, slices, or pointers, and copy their data as well instead

+of just their references.

+

+## Installation

+

+Standard `go get`:

+

+```

+$ go get github.com/mitchellh/copystructure

+```

+

+## Usage & Example

+

+For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/copystructure).

+

+The `Copy` function has examples associated with it there.

diff --git a/vendor/github.com/mitchellh/copystructure/copier_time.go b/vendor/github.com/mitchellh/copystructure/copier_time.go
new file mode 100644
index 0000000..db6a6aa
--- /dev/null
+++ b/vendor/github.com/mitchellh/copystructure/copier_time.go
@@ -0,0 +1,15 @@
+package copystructure
+
+import (
+        "reflect"
+        "time"
+)
+
+func init() {
+        Copiers[reflect.TypeOf(time.Time{})] = timeCopier
+}
+
+func timeCopier(v interface{}) (interface{}, error) {
+        // Just... copy it.
+        return v.(time.Time), nil
+}
diff --git a/vendor/github.com/mitchellh/copystructure/copystructure.go b/vendor/github.com/mitchellh/copystructure/copystructure.go
new file mode 100644
index 0000000..0e725ea
--- /dev/null
+++ b/vendor/github.com/mitchellh/copystructure/copystructure.go
@@ -0,0 +1,477 @@
+package copystructure
+
+import (
+        "errors"
+        "reflect"
+        "sync"
+
+        "github.com/mitchellh/reflectwalk"
+)
+
+// Copy returns a deep copy of v.
+func Copy(v interface{}) (interface{}, error) {
+        return Config{}.Copy(v)
+}
+
+// CopierFunc is a function that knows how to deep copy a specific type.
+// Register these globally with the Copiers variable.
+type CopierFunc func(interface{}) (interface{}, error)
+
+// Copiers is a map of types that behave specially when they are copied.
+// If a type is found in this map while deep copying, this function
+// will be called to copy it instead of attempting to copy all fields.
+//
+// The key should be the type, obtained using: reflect.TypeOf(value with type).
+//
+// It is unsafe to write to this map after Copies have started. If you
+// are writing to this map while also copying, wrap all modifications to
+// this map as well as to Copy in a mutex.
+var Copiers map[reflect.Type]CopierFunc = make(map[reflect.Type]CopierFunc)
+
+// Must is a helper that wraps a call to a function returning
+// (interface{}, error) and panics if the error is non-nil. It is intended
+// for use in variable initializations and should only be used when a copy
+// error should be a crashing case.
+func Must(v interface{}, err error) interface{} {
+        if err != nil {
+                panic("copy error: " + err.Error())
+        }
+
+        return v
+}
+
+var errPointerRequired = errors.New("Copy argument must be a pointer when Lock is true")
+
+type Config struct {
+        // Lock any types that are a sync.Locker and are not a mutex while copying.
+        // If there is an RLocker method, use that to get the sync.Locker.
+        Lock bool
+
+        // Copiers is a map of types associated with a CopierFunc. Use the global
+        // Copiers map if this is nil.
+        Copiers map[reflect.Type]CopierFunc
+}
+
+func (c Config) Copy(v interface{}) (interface{}, error) {
+        if c.Lock && reflect.ValueOf(v).Kind() != reflect.Ptr {
+                return nil, errPointerRequired
+        }
+
+        w := new(walker)
+        if c.Lock {
+                w.useLocks = true
+        }
+
+        if c.Copiers == nil {
+                c.Copiers = Copiers
+        }
+
+        err := reflectwalk.Walk(v, w)
+        if err != nil {
+                return nil, err
+        }
+
+        // Get the result. If the result is nil, then we want to turn it
+        // into a typed nil if we can.
+        result := w.Result
+        if result == nil {
+                val := reflect.ValueOf(v)
+                result = reflect.Indirect(reflect.New(val.Type())).Interface()
+        }
+
+        return result, nil
+}
+
+// Return the key used to index interfaces types we've seen. Store the number
+// of pointers in the upper 32bits, and the depth in the lower 32bits. This is
+// easy to calculate, easy to match a key with our current depth, and we don't
+// need to deal with initializing and cleaning up nested maps or slices.
+func ifaceKey(pointers, depth int) uint64 {
+        return uint64(pointers)<<32 | uint64(depth)
+}
+
+type walker struct {
+        Result interface{}
+
+        depth       int
+        ignoreDepth int
+        vals        []reflect.Value
+        cs          []reflect.Value
+
+        // This stores the number of pointers we've walked over, indexed by depth.
+        ps []int
+
+        // If an interface is indirected by a pointer, we need to know the type of
+        // interface to create when creating the new value.  Store the interface
+        // types here, indexed by both the walk depth and the number of pointers
+        // already seen at that depth. Use ifaceKey to calculate the proper uint64
+        // value.
+        ifaceTypes map[uint64]reflect.Type
+
+        // any locks we've taken, indexed by depth
+        locks []sync.Locker
+        // take locks while walking the structure
+        useLocks bool
+}
+
+func (w *walker) Enter(l reflectwalk.Location) error {
+        w.depth++
+
+        // ensure we have enough elements to index via w.depth
+        for w.depth >= len(w.locks) {
+                w.locks = append(w.locks, nil)
+        }
+
+        for len(w.ps) < w.depth+1 {
+                w.ps = append(w.ps, 0)
+        }
+
+        return nil
+}
+
+func (w *walker) Exit(l reflectwalk.Location) error {
+        locker := w.locks[w.depth]
+        w.locks[w.depth] = nil
+        if locker != nil {
+                defer locker.Unlock()
+        }
+
+        // clear out pointers and interfaces as we exit the stack
+        w.ps[w.depth] = 0
+
+        for k := range w.ifaceTypes {
+                mask := uint64(^uint32(0))
+                if k&mask == uint64(w.depth) {
+                        delete(w.ifaceTypes, k)
+                }
+        }
+
+        w.depth--
+        if w.ignoreDepth > w.depth {
+                w.ignoreDepth = 0
+        }
+
+        if w.ignoring() {
+                return nil
+        }
+
+        switch l {
+        case reflectwalk.Map:
+                fallthrough
+        case reflectwalk.Slice:
+                // Pop map off our container
+                w.cs = w.cs[:len(w.cs)-1]
+        case reflectwalk.MapValue:
+                // Pop off the key and value
+                mv := w.valPop()
+                mk := w.valPop()
+                m := w.cs[len(w.cs)-1]
+
+                // If mv is the zero value, SetMapIndex deletes the key form the map,
+                // or in this case never adds it. We need to create a properly typed
+                // zero value so that this key can be set.
+                if !mv.IsValid() {
+                        mv = reflect.Zero(m.Type().Elem())
+                }
+                m.SetMapIndex(mk, mv)
+        case reflectwalk.SliceElem:
+                // Pop off the value and the index and set it on the slice
+                v := w.valPop()
+                i := w.valPop().Interface().(int)
+                if v.IsValid() {
+                        s := w.cs[len(w.cs)-1]
+                        se := s.Index(i)
+                        if se.CanSet() {
+                                se.Set(v)
+                        }
+                }
+        case reflectwalk.Struct:
+                w.replacePointerMaybe()
+
+                // Remove the struct from the container stack
+                w.cs = w.cs[:len(w.cs)-1]
+        case reflectwalk.StructField:
+                // Pop off the value and the field
+                v := w.valPop()
+                f := w.valPop().Interface().(reflect.StructField)
+                if v.IsValid() {
+                        s := w.cs[len(w.cs)-1]
+                        sf := reflect.Indirect(s).FieldByName(f.Name)
+
+                        if sf.CanSet() {
+                                sf.Set(v)
+                        }
+                }
+        case reflectwalk.WalkLoc:
+                // Clear out the slices for GC
+                w.cs = nil
+                w.vals = nil
+        }
+
+        return nil
+}
+
+func (w *walker) Map(m reflect.Value) error {
+        if w.ignoring() {
+                return nil
+        }
+        w.lock(m)
+
+        // Create the map. If the map itself is nil, then just make a nil map
+        var newMap reflect.Value
+        if m.IsNil() {
+                newMap = reflect.Indirect(reflect.New(m.Type()))
+        } else {
+                newMap = reflect.MakeMap(m.Type())
+        }
+
+        w.cs = append(w.cs, newMap)
+        w.valPush(newMap)
+        return nil
+}
+
+func (w *walker) MapElem(m, k, v reflect.Value) error {
+        return nil
+}
+
+func (w *walker) PointerEnter(v bool) error {
+        if v {
+                w.ps[w.depth]++
+        }
+        return nil
+}
+
+func (w *walker) PointerExit(v bool) error {
+        if v {
+                w.ps[w.depth]--
+        }
+        return nil
+}
+
+func (w *walker) Interface(v reflect.Value) error {
+        if !v.IsValid() {
+                return nil
+        }
+        if w.ifaceTypes == nil {
+                w.ifaceTypes = make(map[uint64]reflect.Type)
+        }
+
+        w.ifaceTypes[ifaceKey(w.ps[w.depth], w.depth)] = v.Type()
+        return nil
+}
+
+func (w *walker) Primitive(v reflect.Value) error {
+        if w.ignoring() {
+                return nil
+        }
+        w.lock(v)
+
+        // IsValid verifies the v is non-zero and CanInterface verifies
+        // that we're allowed to read this value (unexported fields).
+        var newV reflect.Value
+        if v.IsValid() && v.CanInterface() {
+                newV = reflect.New(v.Type())
+                newV.Elem().Set(v)
+        }
+
+        w.valPush(newV)
+        w.replacePointerMaybe()
+        return nil
+}
+
+func (w *walker) Slice(s reflect.Value) error {
+        if w.ignoring() {
+                return nil
+        }
+        w.lock(s)
+
+        var newS reflect.Value
+        if s.IsNil() {
+                newS = reflect.Indirect(reflect.New(s.Type()))
+        } else {
+                newS = reflect.MakeSlice(s.Type(), s.Len(), s.Cap())
+        }
+
+        w.cs = append(w.cs, newS)
+        w.valPush(newS)
+        return nil
+}
+
+func (w *walker) SliceElem(i int, elem reflect.Value) error {
+        if w.ignoring() {
+                return nil
+        }
+
+        // We don't write the slice here because elem might still be
+        // arbitrarily complex. Just record the index and continue on.
+        w.valPush(reflect.ValueOf(i))
+
+        return nil
+}
+
+func (w *walker) Struct(s reflect.Value) error {
+        if w.ignoring() {
+                return nil
+        }
+        w.lock(s)
+
+        var v reflect.Value
+        if c, ok := Copiers[s.Type()]; ok {
+                // We have a Copier for this struct, so we use that copier to
+                // get the copy, and we ignore anything deeper than this.
+                w.ignoreDepth = w.depth
+
+                dup, err := c(s.Interface())
+                if err != nil {
+                        return err
+                }
+
+                v = reflect.ValueOf(dup)
+        } else {
+                // No copier, we copy ourselves and allow reflectwalk to guide
+                // us deeper into the structure for copying.
+                v = reflect.New(s.Type())
+        }
+
+        // Push the value onto the value stack for setting the struct field,
+        // and add the struct itself to the containers stack in case we walk
+        // deeper so that its own fields can be modified.
+        w.valPush(v)
+        w.cs = append(w.cs, v)
+
+        return nil
+}
+
+func (w *walker) StructField(f reflect.StructField, v reflect.Value) error {
+        if w.ignoring() {
+                return nil
+        }
+
+        // If PkgPath is non-empty, this is a private (unexported) field.
+        // We do not set this unexported since the Go runtime doesn't allow us.
+        if f.PkgPath != "" {
+                return reflectwalk.SkipEntry
+        }
+
+        // Push the field onto the stack, we'll handle it when we exit
+        // the struct field in Exit...
+        w.valPush(reflect.ValueOf(f))
+        return nil
+}
+
+// ignore causes the walker to ignore any more values until we exit this on
+func (w *walker) ignore() {
+        w.ignoreDepth = w.depth
+}
+
+func (w *walker) ignoring() bool {
+        return w.ignoreDepth > 0 && w.depth >= w.ignoreDepth
+}
+
+func (w *walker) pointerPeek() bool {
+        return w.ps[w.depth] > 0
+}
+
+func (w *walker) valPop() reflect.Value {
+        result := w.vals[len(w.vals)-1]
+        w.vals = w.vals[:len(w.vals)-1]
+
+        // If we're out of values, that means we popped everything off. In
+        // this case, we reset the result so the next pushed value becomes
+        // the result.
+        if len(w.vals) == 0 {
+                w.Result = nil
+        }
+
+        return result
+}
+
+func (w *walker) valPush(v reflect.Value) {
+        w.vals = append(w.vals, v)
+
+        // If we haven't set the result yet, then this is the result since
+        // it is the first (outermost) value we're seeing.
+        if w.Result == nil && v.IsValid() {
+                w.Result = v.Interface()
+        }
+}
+
+func (w *walker) replacePointerMaybe() {
+        // Determine the last pointer value. If it is NOT a pointer, then
+        // we need to push that onto the stack.
+        if !w.pointerPeek() {
+                w.valPush(reflect.Indirect(w.valPop()))
+                return
+        }
+
+        v := w.valPop()
+        for i := 1; i < w.ps[w.depth]; i++ {
+                if iType, ok := w.ifaceTypes[ifaceKey(w.ps[w.depth]-i, w.depth)]; ok {
+                        iface := reflect.New(iType).Elem()
+                        iface.Set(v)
+                        v = iface
+                }
+
+                p := reflect.New(v.Type())
+                p.Elem().Set(v)
+                v = p
+        }
+
+        w.valPush(v)
+}
+
+// if this value is a Locker, lock it and add it to the locks slice
+func (w *walker) lock(v reflect.Value) {
+        if !w.useLocks {
+                return
+        }
+
+        if !v.IsValid() || !v.CanInterface() {
+                return
+        }
+
+        type rlocker interface {
+                RLocker() sync.Locker
+        }
+
+        var locker sync.Locker
+
+        // We can't call Interface() on a value directly, since that requires
+        // a copy. This is OK, since the pointer to a value which is a sync.Locker
+        // is also a sync.Locker.
+        if v.Kind() == reflect.Ptr {
+                switch l := v.Interface().(type) {
+                case rlocker:
+                        // don't lock a mutex directly
+                        if _, ok := l.(*sync.RWMutex); !ok {
+                                locker = l.RLocker()
+                        }
+                case sync.Locker:
+                        locker = l
+                }
+        } else if v.CanAddr() {
+                switch l := v.Addr().Interface().(type) {
+                case rlocker:
+                        // don't lock a mutex directly
+                        if _, ok := l.(*sync.RWMutex); !ok {
+                                locker = l.RLocker()
+                        }
+                case sync.Locker:
+                        locker = l
+                }
+        }
+
+        // still no callable locker
+        if locker == nil {
+                return
+        }
+
+        // don't lock a mutex directly
+        switch locker.(type) {
+        case *sync.Mutex, *sync.RWMutex:
+                return
+        }
+
+        locker.Lock()
+        w.locks[w.depth] = locker
+}
diff --git a/vendor/github.com/mitchellh/go-homedir/LICENSE b/vendor/github.com/mitchellh/go-homedir/LICENSE
new file mode 100644
index 0000000..f9c841a
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mitchell Hashimoto
+
+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.
diff --git a/vendor/github.com/mitchellh/go-homedir/README.md b/vendor/github.com/mitchellh/go-homedir/README.md
new file mode 100644
index 0000000..d70706d
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/README.md
@@ -0,0 +1,14 @@
+# go-homedir
+
+This is a Go library for detecting the user's home directory without
+the use of cgo, so the library can be used in cross-compilation environments.
+
+Usage is incredibly simple, just call `homedir.Dir()` to get the home directory
+for a user, and `homedir.Expand()` to expand the `~` in a path to the home
+directory.
+
+**Why not just use `os/user`?** The built-in `os/user` package requires
+cgo on Darwin systems. This means that any Go code that uses that package
+cannot cross compile. But 99% of the time the use for `os/user` is just to
+retrieve the home directory, which we can do for the current user without
+cgo. This library does that, enabling cross-compilation.
diff --git a/vendor/github.com/mitchellh/go-homedir/homedir.go b/vendor/github.com/mitchellh/go-homedir/homedir.go
new file mode 100644
index 0000000..47e1f9e
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/homedir.go
@@ -0,0 +1,137 @@
+package homedir
+
+import (
+        "bytes"
+        "errors"
+        "os"
+        "os/exec"
+        "path/filepath"
+        "runtime"
+        "strconv"
+        "strings"
+        "sync"
+)
+
+// DisableCache will disable caching of the home directory. Caching is enabled
+// by default.
+var DisableCache bool
+
+var homedirCache string
+var cacheLock sync.RWMutex
+
+// Dir returns the home directory for the executing user.
+//
+// This uses an OS-specific method for discovering the home directory.
+// An error is returned if a home directory cannot be detected.
+func Dir() (string, error) {
+        if !DisableCache {
+                cacheLock.RLock()
+                cached := homedirCache
+                cacheLock.RUnlock()
+                if cached != "" {
+                        return cached, nil
+                }
+        }
+
+        cacheLock.Lock()
+        defer cacheLock.Unlock()
+
+        var result string
+        var err error
+        if runtime.GOOS == "windows" {
+                result, err = dirWindows()
+        } else {
+                // Unix-like system, so just assume Unix
+                result, err = dirUnix()
+        }
+
+        if err != nil {
+                return "", err
+        }
+        homedirCache = result
+        return result, nil
+}
+
+// Expand expands the path to include the home directory if the path
+// is prefixed with `~`. If it isn't prefixed with `~`, the path is
+// returned as-is.
+func Expand(path string) (string, error) {
+        if len(path) == 0 {
+                return path, nil
+        }
+
+        if path[0] != '~' {
+                return path, nil
+        }
+
+        if len(path) > 1 && path[1] != '/' && path[1] != '\\' {
+                return "", errors.New("cannot expand user-specific home dir")
+        }
+
+        dir, err := Dir()
+        if err != nil {
+                return "", err
+        }
+
+        return filepath.Join(dir, path[1:]), nil
+}
+
+func dirUnix() (string, error) {
+        // First prefer the HOME environmental variable
+        if home := os.Getenv("HOME"); home != "" {
+                return home, nil
+        }
+
+        // If that fails, try getent
+        var stdout bytes.Buffer
+        cmd := exec.Command("getent", "passwd", strconv.Itoa(os.Getuid()))
+        cmd.Stdout = &stdout
+        if err := cmd.Run(); err != nil {
+                // If the error is ErrNotFound, we ignore it. Otherwise, return it.
+                if err != exec.ErrNotFound {
+                        return "", err
+                }
+        } else {
+                if passwd := strings.TrimSpace(stdout.String()); passwd != "" {
+                        // username:password:uid:gid:gecos:home:shell
+                        passwdParts := strings.SplitN(passwd, ":", 7)
+                        if len(passwdParts) > 5 {
+                                return passwdParts[5], nil
+                        }
+                }
+        }
+
+        // If all else fails, try the shell
+        stdout.Reset()
+        cmd = exec.Command("sh", "-c", "cd && pwd")
+        cmd.Stdout = &stdout
+        if err := cmd.Run(); err != nil {
+                return "", err
+        }
+
+        result := strings.TrimSpace(stdout.String())
+        if result == "" {
+                return "", errors.New("blank output when reading home directory")
+        }
+
+        return result, nil
+}
+
+func dirWindows() (string, error) {
+        // First prefer the HOME environmental variable
+        if home := os.Getenv("HOME"); home != "" {
+                return home, nil
+        }
+
+        drive := os.Getenv("HOMEDRIVE")
+        path := os.Getenv("HOMEPATH")
+        home := drive + path
+        if drive == "" || path == "" {
+                home = os.Getenv("USERPROFILE")
+        }
+        if home == "" {
+                return "", errors.New("HOMEDRIVE, HOMEPATH, and USERPROFILE are blank")
+        }
+
+        return home, nil
+}
diff --git a/vendor/github.com/mitchellh/hashstructure/LICENSE b/vendor/github.com/mitchellh/hashstructure/LICENSE
new file mode 100644
index 0000000..a3866a2
--- /dev/null
+++ b/vendor/github.com/mitchellh/hashstructure/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Mitchell Hashimoto
+
+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.
diff --git a/vendor/github.com/mitchellh/hashstructure/README.md b/vendor/github.com/mitchellh/hashstructure/README.md
new file mode 100644
index 0000000..7d0de5b
--- /dev/null
+++ b/vendor/github.com/mitchellh/hashstructure/README.md
@@ -0,0 +1,61 @@
+# hashstructure
+
+hashstructure is a Go library for creating a unique hash value
+for arbitrary values in Go.
+
+This can be used to key values in a hash (for use in a map, set, etc.)
+that are complex. The most common use case is comparing two values without
+sending data across the network, caching values locally (de-dup), and so on.
+
+## Features
+
+  * Hash any arbitrary Go value, including complex types.
+
+  * Tag a struct field to ignore it and not affect the hash value.
+
+  * Tag a slice type struct field to treat it as a set where ordering
+    doesn't affect the hash code but the field itself is still taken into
+    account to create the hash value.
+
+  * Optionally specify a custom hash function to optimize for speed, collision
+    avoidance for your data set, etc.
+
+## Installation
+
+Standard `go get`:
+
+```
+$ go get github.com/mitchellh/hashstructure
+```
+
+## Usage & Example
+
+For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/hashstructure).
+
+A quick code example is shown below:
+
+
+        type ComplexStruct struct {
+                Name     string
+                Age      uint
+                Metadata map[string]interface{}
+        }
+
+        v := ComplexStruct{
+                Name: "mitchellh",
+                Age:  64,
+                Metadata: map[string]interface{}{
+                        "car":      true,
+                        "location": "California",
+                        "siblings": []string{"Bob", "John"},
+                },
+        }
+
+        hash, err := hashstructure.Hash(v, nil)
+        if err != nil {
+                panic(err)
+        }
+
+        fmt.Printf("%d", hash)
+        // Output:
+        // 2307517237273902113
diff --git a/vendor/github.com/mitchellh/hashstructure/hashstructure.go b/vendor/github.com/mitchellh/hashstructure/hashstructure.go
new file mode 100644
index 0000000..6f586fa
--- /dev/null
+++ b/vendor/github.com/mitchellh/hashstructure/hashstructure.go
@@ -0,0 +1,323 @@
+package hashstructure
+
+import (
+        "encoding/binary"
+        "fmt"
+        "hash"
+        "hash/fnv"
+        "reflect"
+)
+
+// HashOptions are options that are available for hashing.
+type HashOptions struct {
+        // Hasher is the hash function to use. If this isn't set, it will
+        // default to FNV.
+        Hasher hash.Hash64
+
+        // TagName is the struct tag to look at when hashing the structure.
+        // By default this is "hash".
+        TagName string
+}
+
+// Hash returns the hash value of an arbitrary value.
+//
+// If opts is nil, then default options will be used. See HashOptions
+// for the default values.
+//
+// Notes on the value:
+//
+//   * Unexported fields on structs are ignored and do not affect the
+//     hash value.
+//
+//   * Adding an exported field to a struct with the zero value will change
+//     the hash value.
+//
+// For structs, the hashing can be controlled using tags. For example:
+//
+//    struct {
+//        Name string
+//        UUID string `hash:"ignore"`
+//    }
+//
+// The available tag values are:
+//
+//   * "ignore" - The field will be ignored and not affect the hash code.
+//
+//   * "set" - The field will be treated as a set, where ordering doesn't
+//             affect the hash code. This only works for slices.
+//
+func Hash(v interface{}, opts *HashOptions) (uint64, error) {
+        // Create default options
+        if opts == nil {
+                opts = &HashOptions{}
+        }
+        if opts.Hasher == nil {
+                opts.Hasher = fnv.New64()
+        }
+        if opts.TagName == "" {
+                opts.TagName = "hash"
+        }
+
+        // Reset the hash
+        opts.Hasher.Reset()
+
+        // Create our walker and walk the structure
+        w := &walker{
+                h:   opts.Hasher,
+                tag: opts.TagName,
+        }
+        return w.visit(reflect.ValueOf(v), nil)
+}
+
+type walker struct {
+        h   hash.Hash64
+        tag string
+}
+
+type visitOpts struct {
+        // Flags are a bitmask of flags to affect behavior of this visit
+        Flags visitFlag
+
+        // Information about the struct containing this field
+        Struct      interface{}
+        StructField string
+}
+
+func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
+        // Loop since these can be wrapped in multiple layers of pointers
+        // and interfaces.
+        for {
+                // If we have an interface, dereference it. We have to do this up
+                // here because it might be a nil in there and the check below must
+                // catch that.
+                if v.Kind() == reflect.Interface {
+                        v = v.Elem()
+                        continue
+                }
+
+                if v.Kind() == reflect.Ptr {
+                        v = reflect.Indirect(v)
+                        continue
+                }
+
+                break
+        }
+
+        // If it is nil, treat it like a zero.
+        if !v.IsValid() {
+                var tmp int8
+                v = reflect.ValueOf(tmp)
+        }
+
+        // Binary writing can use raw ints, we have to convert to
+        // a sized-int, we'll choose the largest...
+        switch v.Kind() {
+        case reflect.Int:
+                v = reflect.ValueOf(int64(v.Int()))
+        case reflect.Uint:
+                v = reflect.ValueOf(uint64(v.Uint()))
+        case reflect.Bool:
+                var tmp int8
+                if v.Bool() {
+                        tmp = 1
+                }
+                v = reflect.ValueOf(tmp)
+        }
+
+        k := v.Kind()
+
+        // We can shortcut numeric values by directly binary writing them
+        if k >= reflect.Int && k <= reflect.Complex64 {
+                // A direct hash calculation
+                w.h.Reset()
+                err := binary.Write(w.h, binary.LittleEndian, v.Interface())
+                return w.h.Sum64(), err
+        }
+
+        switch k {
+        case reflect.Array:
+                var h uint64
+                l := v.Len()
+                for i := 0; i < l; i++ {
+                        current, err := w.visit(v.Index(i), nil)
+                        if err != nil {
+                                return 0, err
+                        }
+
+                        h = hashUpdateOrdered(w.h, h, current)
+                }
+
+                return h, nil
+
+        case reflect.Map:
+                var includeMap IncludableMap
+                if opts != nil && opts.Struct != nil {
+                        if v, ok := opts.Struct.(IncludableMap); ok {
+                                includeMap = v
+                        }
+                }
+
+                // Build the hash for the map. We do this by XOR-ing all the key
+                // and value hashes. This makes it deterministic despite ordering.
+                var h uint64
+                for _, k := range v.MapKeys() {
+                        v := v.MapIndex(k)
+                        if includeMap != nil {
+                                incl, err := includeMap.HashIncludeMap(
+                                        opts.StructField, k.Interface(), v.Interface())
+                                if err != nil {
+                                        return 0, err
+                                }
+                                if !incl {
+                                        continue
+                                }
+                        }
+
+                        kh, err := w.visit(k, nil)
+                        if err != nil {
+                                return 0, err
+                        }
+                        vh, err := w.visit(v, nil)
+                        if err != nil {
+                                return 0, err
+                        }
+
+                        fieldHash := hashUpdateOrdered(w.h, kh, vh)
+                        h = hashUpdateUnordered(h, fieldHash)
+                }
+
+                return h, nil
+
+        case reflect.Struct:
+                var include Includable
+                parent := v.Interface()
+                if impl, ok := parent.(Includable); ok {
+                        include = impl
+                }
+
+                t := v.Type()
+                h, err := w.visit(reflect.ValueOf(t.Name()), nil)
+                if err != nil {
+                        return 0, err
+                }
+
+                l := v.NumField()
+                for i := 0; i < l; i++ {
+                        if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
+                                var f visitFlag
+                                fieldType := t.Field(i)
+                                if fieldType.PkgPath != "" {
+                                        // Unexported
+                                        continue
+                                }
+
+                                tag := fieldType.Tag.Get(w.tag)
+                                if tag == "ignore" {
+                                        // Ignore this field
+                                        continue
+                                }
+
+                                // Check if we implement includable and check it
+                                if include != nil {
+                                        incl, err := include.HashInclude(fieldType.Name, v)
+                                        if err != nil {
+                                                return 0, err
+                                        }
+                                        if !incl {
+                                                continue
+                                        }
+                                }
+
+                                switch tag {
+                                case "set":
+                                        f |= visitFlagSet
+                                }
+
+                                kh, err := w.visit(reflect.ValueOf(fieldType.Name), nil)
+                                if err != nil {
+                                        return 0, err
+                                }
+
+                                vh, err := w.visit(v, &visitOpts{
+                                        Flags:       f,
+                                        Struct:      parent,
+                                        StructField: fieldType.Name,
+                                })
+                                if err != nil {
+                                        return 0, err
+                                }
+
+                                fieldHash := hashUpdateOrdered(w.h, kh, vh)
+                                h = hashUpdateUnordered(h, fieldHash)
+                        }
+                }
+
+                return h, nil
+
+        case reflect.Slice:
+                // We have two behaviors here. If it isn't a set, then we just
+                // visit all the elements. If it is a set, then we do a deterministic
+                // hash code.
+                var h uint64
+                var set bool
+                if opts != nil {
+                        set = (opts.Flags & visitFlagSet) != 0
+                }
+                l := v.Len()
+                for i := 0; i < l; i++ {
+                        current, err := w.visit(v.Index(i), nil)
+                        if err != nil {
+                                return 0, err
+                        }
+
+                        if set {
+                                h = hashUpdateUnordered(h, current)
+                        } else {
+                                h = hashUpdateOrdered(w.h, h, current)
+                        }
+                }
+
+                return h, nil
+
+        case reflect.String:
+                // Directly hash
+                w.h.Reset()
+                _, err := w.h.Write([]byte(v.String()))
+                return w.h.Sum64(), err
+
+        default:
+                return 0, fmt.Errorf("unknown kind to hash: %s", k)
+        }
+
+        return 0, nil
+}
+
+func hashUpdateOrdered(h hash.Hash64, a, b uint64) uint64 {
+        // For ordered updates, use a real hash function
+        h.Reset()
+
+        // We just panic if the binary writes fail because we are writing
+        // an int64 which should never be fail-able.
+        e1 := binary.Write(h, binary.LittleEndian, a)
+        e2 := binary.Write(h, binary.LittleEndian, b)
+        if e1 != nil {
+                panic(e1)
+        }
+        if e2 != nil {
+                panic(e2)
+        }
+
+        return h.Sum64()
+}
+
+func hashUpdateUnordered(a, b uint64) uint64 {
+        return a ^ b
+}
+
+// visitFlag is used as a bitmask for affecting visit behavior
+type visitFlag uint
+
+const (
+        visitFlagInvalid visitFlag = iota
+        visitFlagSet               = iota << 1
+)
diff --git a/vendor/github.com/mitchellh/hashstructure/include.go b/vendor/github.com/mitchellh/hashstructure/include.go
new file mode 100644
index 0000000..b6289c0
--- /dev/null
+++ b/vendor/github.com/mitchellh/hashstructure/include.go
@@ -0,0 +1,15 @@
+package hashstructure
+
+// Includable is an interface that can optionally be implemented by
+// a struct. It will be called for each field in the struct to check whether
+// it should be included in the hash.
+type Includable interface {
+        HashInclude(field string, v interface{}) (bool, error)
+}
+
+// IncludableMap is an interface that can optionally be implemented by
+// a struct. It will be called when a map-type field is found to ask the
+// struct if the map item should be included in the hash.
+type IncludableMap interface {
+        HashIncludeMap(field string, k, v interface{}) (bool, error)
+}
diff --git a/vendor/github.com/mitchellh/mapstructure/LICENSE b/vendor/github.com/mitchellh/mapstructure/LICENSE
new file mode 100644
index 0000000..f9c841a
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mitchell Hashimoto
+
+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.
diff --git a/vendor/github.com/mitchellh/mapstructure/README.md b/vendor/github.com/mitchellh/mapstructure/README.md
new file mode 100644
index 0000000..659d688
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/README.md
@@ -0,0 +1,46 @@
+# mapstructure
+
+mapstructure is a Go library for decoding generic map values to structures
+and vice versa, while providing helpful error handling.
+
+This library is most useful when decoding values from some data stream (JSON,
+Gob, etc.) where you don't _quite_ know the structure of the underlying data
+until you read a part of it. You can therefore read a `map[string]interface{}`
+and use this library to decode it into the proper underlying native Go
+structure.
+
+## Installation
+
+Standard `go get`:
+
+```
+$ go get github.com/mitchellh/mapstructure
+```
+
+## Usage & Example
+
+For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/mapstructure).
+
+The `Decode` function has examples associated with it there.
+
+## But Why?!
+
+Go offers fantastic standard libraries for decoding formats such as JSON.
+The standard method is to have a struct pre-created, and populate that struct
+from the bytes of the encoded format. This is great, but the problem is if
+you have configuration or an encoding that changes slightly depending on
+specific fields. For example, consider this JSON:
+
+```json
+{
+  "type": "person",
+  "name": "Mitchell"
+}
+```
+
+Perhaps we can't populate a specific structure without first reading
+the "type" field from the JSON. We could always do two passes over the
+decoding of the JSON (reading the "type" first, and the rest later).
+However, it is much simpler to just decode this into a `map[string]interface{}`
+structure, read the "type" key, then use something like this library
+to decode it into the proper structure.
diff --git a/vendor/github.com/mitchellh/mapstructure/decode_hooks.go b/vendor/github.com/mitchellh/mapstructure/decode_hooks.go
new file mode 100644
index 0000000..115ae67
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/decode_hooks.go
@@ -0,0 +1,154 @@
+package mapstructure
+
+import (
+        "errors"
+        "reflect"
+        "strconv"
+        "strings"
+        "time"
+)
+
+// typedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
+// it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
+func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
+        // Create variables here so we can reference them with the reflect pkg
+        var f1 DecodeHookFuncType
+        var f2 DecodeHookFuncKind
+
+        // Fill in the variables into this interface and the rest is done
+        // automatically using the reflect package.
+        potential := []interface{}{f1, f2}
+
+        v := reflect.ValueOf(h)
+        vt := v.Type()
+        for _, raw := range potential {
+                pt := reflect.ValueOf(raw).Type()
+                if vt.ConvertibleTo(pt) {
+                        return v.Convert(pt).Interface()
+                }
+        }
+
+        return nil
+}
+
+// DecodeHookExec executes the given decode hook. This should be used
+// since it'll naturally degrade to the older backwards compatible DecodeHookFunc
+// that took reflect.Kind instead of reflect.Type.
+func DecodeHookExec(
+        raw DecodeHookFunc,
+        from reflect.Type, to reflect.Type,
+        data interface{}) (interface{}, error) {
+        // Build our arguments that reflect expects
+        argVals := make([]reflect.Value, 3)
+        argVals[0] = reflect.ValueOf(from)
+        argVals[1] = reflect.ValueOf(to)
+        argVals[2] = reflect.ValueOf(data)
+
+        switch f := typedDecodeHook(raw).(type) {
+        case DecodeHookFuncType:
+                return f(from, to, data)
+        case DecodeHookFuncKind:
+                return f(from.Kind(), to.Kind(), data)
+        default:
+                return nil, errors.New("invalid decode hook signature")
+        }
+}
+
+// ComposeDecodeHookFunc creates a single DecodeHookFunc that
+// automatically composes multiple DecodeHookFuncs.
+//
+// The composed funcs are called in order, with the result of the
+// previous transformation.
+func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
+        return func(
+                f reflect.Type,
+                t reflect.Type,
+                data interface{}) (interface{}, error) {
+                var err error
+                for _, f1 := range fs {
+                        data, err = DecodeHookExec(f1, f, t, data)
+                        if err != nil {
+                                return nil, err
+                        }
+
+                        // Modify the from kind to be correct with the new data
+                        f = nil
+                        if val := reflect.ValueOf(data); val.IsValid() {
+                                f = val.Type()
+                        }
+                }
+
+                return data, nil
+        }
+}
+
+// StringToSliceHookFunc returns a DecodeHookFunc that converts
+// string to []string by splitting on the given sep.
+func StringToSliceHookFunc(sep string) DecodeHookFunc {
+        return func(
+                f reflect.Kind,
+                t reflect.Kind,
+                data interface{}) (interface{}, error) {
+                if f != reflect.String || t != reflect.Slice {
+                        return data, nil
+                }
+
+                raw := data.(string)
+                if raw == "" {
+                        return []string{}, nil
+                }
+
+                return strings.Split(raw, sep), nil
+        }
+}
+
+// StringToTimeDurationHookFunc returns a DecodeHookFunc that converts
+// strings to time.Duration.
+func StringToTimeDurationHookFunc() 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.Duration(5)) {
+                        return data, nil
+                }
+
+                // Convert it by parsing
+                return time.ParseDuration(data.(string))
+        }
+}
+
+func WeaklyTypedHook(
+        f reflect.Kind,
+        t reflect.Kind,
+        data interface{}) (interface{}, error) {
+        dataVal := reflect.ValueOf(data)
+        switch t {
+        case reflect.String:
+                switch f {
+                case reflect.Bool:
+                        if dataVal.Bool() {
+                                return "1", nil
+                        } else {
+                                return "0", nil
+                        }
+                case reflect.Float32:
+                        return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
+                case reflect.Int:
+                        return strconv.FormatInt(dataVal.Int(), 10), nil
+                case reflect.Slice:
+                        dataType := dataVal.Type()
+                        elemKind := dataType.Elem().Kind()
+                        if elemKind == reflect.Uint8 {
+                                return string(dataVal.Interface().([]uint8)), nil
+                        }
+                case reflect.Uint:
+                        return strconv.FormatUint(dataVal.Uint(), 10), nil
+                }
+        }
+
+        return data, nil
+}
diff --git a/vendor/github.com/mitchellh/mapstructure/error.go b/vendor/github.com/mitchellh/mapstructure/error.go
new file mode 100644
index 0000000..47a99e5
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/error.go
@@ -0,0 +1,50 @@
+package mapstructure
+
+import (
+        "errors"
+        "fmt"
+        "sort"
+        "strings"
+)
+
+// Error implements the error interface and can represents multiple
+// errors that occur in the course of a single decode.
+type Error struct {
+        Errors []string
+}
+
+func (e *Error) Error() string {
+        points := make([]string, len(e.Errors))
+        for i, err := range e.Errors {
+                points[i] = fmt.Sprintf("* %s", err)
+        }
+
+        sort.Strings(points)
+        return fmt.Sprintf(
+                "%d error(s) decoding:\n\n%s",
+                len(e.Errors), strings.Join(points, "\n"))
+}
+
+// WrappedErrors implements the errwrap.Wrapper interface to make this
+// return value more useful with the errwrap and go-multierror libraries.
+func (e *Error) WrappedErrors() []error {
+        if e == nil {
+                return nil
+        }
+
+        result := make([]error, len(e.Errors))
+        for i, e := range e.Errors {
+                result[i] = errors.New(e)
+        }
+
+        return result
+}
+
+func appendErrors(errors []string, err error) []string {
+        switch e := err.(type) {
+        case *Error:
+                return append(errors, e.Errors...)
+        default:
+                return append(errors, e.Error())
+        }
+}
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure.go b/vendor/github.com/mitchellh/mapstructure/mapstructure.go
new file mode 100644
index 0000000..6dee0ef
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/mapstructure.go
@@ -0,0 +1,823 @@
+// The mapstructure package exposes functionality to convert an
+// arbitrary map[string]interface{} into a native Go structure.
+//
+// The Go structure can be arbitrarily complex, containing slices,
+// other structs, etc. and the decoder will properly decode nested
+// maps and so on into the proper structures in the native Go struct.
+// See the examples to see what the decoder is capable of.
+package mapstructure
+
+import (
+        "encoding/json"
+        "errors"
+        "fmt"
+        "reflect"
+        "sort"
+        "strconv"
+        "strings"
+)
+
+// DecodeHookFunc is the callback function that can be used for
+// data transformations. See "DecodeHook" in the DecoderConfig
+// struct.
+//
+// The type should be DecodeHookFuncType or DecodeHookFuncKind.
+// Either is accepted. Types are a superset of Kinds (Types can return
+// Kinds) and are generally a richer thing to use, but Kinds are simpler
+// if you only need those.
+//
+// The reason DecodeHookFunc is multi-typed is for backwards compatibility:
+// we started with Kinds and then realized Types were the better solution,
+// but have a promise to not break backwards compat so we now support
+// both.
+type DecodeHookFunc interface{}
+
+type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
+type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
+
+// DecoderConfig is the configuration that is used to create a new decoder
+// and allows customization of various aspects of decoding.
+type DecoderConfig struct {
+        // DecodeHook, if set, will be called before any decoding and any
+        // type conversion (if WeaklyTypedInput is on). This lets you modify
+        // the values before they're set down onto the resulting struct.
+        //
+        // If an error is returned, the entire decode will fail with that
+        // error.
+        DecodeHook DecodeHookFunc
+
+        // If ErrorUnused is true, then it is an error for there to exist
+        // keys in the original map that were unused in the decoding process
+        // (extra keys).
+        ErrorUnused bool
+
+        // ZeroFields, if set to true, will zero fields before writing them.
+        // For example, a map will be emptied before decoded values are put in
+        // it. If this is false, a map will be merged.
+        ZeroFields bool
+
+        // If WeaklyTypedInput is true, the decoder will make the following
+        // "weak" conversions:
+        //
+        //   - bools to string (true = "1", false = "0")
+        //   - numbers to string (base 10)
+        //   - bools to int/uint (true = 1, false = 0)
+        //   - strings to int/uint (base implied by prefix)
+        //   - int to bool (true if value != 0)
+        //   - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,
+        //     FALSE, false, False. Anything else is an error)
+        //   - empty array = empty map and vice versa
+        //   - negative numbers to overflowed uint values (base 10)
+        //   - slice of maps to a merged map
+        //   - single values are converted to slices if required. Each
+        //     element is weakly decoded. For example: "4" can become []int{4}
+        //     if the target type is an int slice.
+        //
+        WeaklyTypedInput bool
+
+        // Metadata is the struct that will contain extra metadata about
+        // the decoding. If this is nil, then no metadata will be tracked.
+        Metadata *Metadata
+
+        // Result is a pointer to the struct that will contain the decoded
+        // value.
+        Result interface{}
+
+        // The tag name that mapstructure reads for field names. This
+        // defaults to "mapstructure"
+        TagName string
+}
+
+// A Decoder takes a raw interface value and turns it into structured
+// data, keeping track of rich error information along the way in case
+// anything goes wrong. Unlike the basic top-level Decode method, you can
+// more finely control how the Decoder behaves using the DecoderConfig
+// structure. The top-level Decode method is just a convenience that sets
+// up the most basic Decoder.
+type Decoder struct {
+        config *DecoderConfig
+}
+
+// Metadata contains information about decoding a structure that
+// is tedious or difficult to get otherwise.
+type Metadata struct {
+        // Keys are the keys of the structure which were successfully decoded
+        Keys []string
+
+        // Unused is a slice of keys that were found in the raw value but
+        // weren't decoded since there was no matching field in the result interface
+        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 {
+        config := &DecoderConfig{
+                Metadata: nil,
+                Result:   rawVal,
+        }
+
+        decoder, err := NewDecoder(config)
+        if err != nil {
+                return err
+        }
+
+        return decoder.Decode(m)
+}
+
+// WeakDecode is the same as Decode but is shorthand to enable
+// WeaklyTypedInput. See DecoderConfig for more info.
+func WeakDecode(input, output interface{}) error {
+        config := &DecoderConfig{
+                Metadata:         nil,
+                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.
+func NewDecoder(config *DecoderConfig) (*Decoder, error) {
+        val := reflect.ValueOf(config.Result)
+        if val.Kind() != reflect.Ptr {
+                return nil, errors.New("result must be a pointer")
+        }
+
+        val = val.Elem()
+        if !val.CanAddr() {
+                return nil, errors.New("result must be addressable (a pointer)")
+        }
+
+        if config.Metadata != nil {
+                if config.Metadata.Keys == nil {
+                        config.Metadata.Keys = make([]string, 0)
+                }
+
+                if config.Metadata.Unused == nil {
+                        config.Metadata.Unused = make([]string, 0)
+                }
+        }
+
+        if config.TagName == "" {
+                config.TagName = "mapstructure"
+        }
+
+        result := &Decoder{
+                config: config,
+        }
+
+        return result, nil
+}
+
+// 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())
+}
+
+// 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.
+                return nil
+        }
+
+        dataVal := reflect.ValueOf(data)
+        if !dataVal.IsValid() {
+                // If the data value is invalid, then we just set the value
+                // to be the zero value.
+                val.Set(reflect.Zero(val.Type()))
+                return nil
+        }
+
+        if d.config.DecodeHook != nil {
+                // We have a DecodeHook, so let's pre-process the data.
+                var err error
+                data, err = DecodeHookExec(
+                        d.config.DecodeHook,
+                        dataVal.Type(), val.Type(), data)
+                if err != nil {
+                        return fmt.Errorf("error decoding '%s': %s", name, err)
+                }
+        }
+
+        var err error
+        dataKind := getKind(val)
+        switch dataKind {
+        case reflect.Bool:
+                err = d.decodeBool(name, data, val)
+        case reflect.Interface:
+                err = d.decodeBasic(name, data, val)
+        case reflect.String:
+                err = d.decodeString(name, data, val)
+        case reflect.Int:
+                err = d.decodeInt(name, data, val)
+        case reflect.Uint:
+                err = d.decodeUint(name, data, val)
+        case reflect.Float32:
+                err = d.decodeFloat(name, data, val)
+        case reflect.Struct:
+                err = d.decodeStruct(name, data, val)
+        case reflect.Map:
+                err = d.decodeMap(name, data, val)
+        case reflect.Ptr:
+                err = d.decodePtr(name, data, val)
+        case reflect.Slice:
+                err = d.decodeSlice(name, data, val)
+        case reflect.Func:
+                err = d.decodeFunc(name, data, val)
+        default:
+                // If we reached this point then we weren't able to decode it
+                return fmt.Errorf("%s: unsupported type: %s", name, dataKind)
+        }
+
+        // If we reached here, then we successfully decoded SOMETHING, so
+        // mark the key as used if we're tracking metadata.
+        if d.config.Metadata != nil && name != "" {
+                d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+        }
+
+        return err
+}
+
+// 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 {
+        dataVal := reflect.ValueOf(data)
+        if !dataVal.IsValid() {
+                dataVal = reflect.Zero(val.Type())
+        }
+
+        dataValType := dataVal.Type()
+        if !dataValType.AssignableTo(val.Type()) {
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got '%s'",
+                        name, val.Type(), dataValType)
+        }
+
+        val.Set(dataVal)
+        return nil
+}
+
+func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.ValueOf(data)
+        dataKind := getKind(dataVal)
+
+        converted := true
+        switch {
+        case dataKind == reflect.String:
+                val.SetString(dataVal.String())
+        case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+                if dataVal.Bool() {
+                        val.SetString("1")
+                } else {
+                        val.SetString("0")
+                }
+        case dataKind == reflect.Int && d.config.WeaklyTypedInput:
+                val.SetString(strconv.FormatInt(dataVal.Int(), 10))
+        case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
+                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:
+                dataType := dataVal.Type()
+                elemKind := dataType.Elem().Kind()
+                switch {
+                case elemKind == reflect.Uint8:
+                        val.SetString(string(dataVal.Interface().([]uint8)))
+                default:
+                        converted = false
+                }
+        default:
+                converted = false
+        }
+
+        if !converted {
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got unconvertible type '%s'",
+                        name, val.Type(), dataVal.Type())
+        }
+
+        return nil
+}
+
+func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.ValueOf(data)
+        dataKind := getKind(dataVal)
+        dataType := dataVal.Type()
+
+        switch {
+        case dataKind == reflect.Int:
+                val.SetInt(dataVal.Int())
+        case dataKind == reflect.Uint:
+                val.SetInt(int64(dataVal.Uint()))
+        case dataKind == reflect.Float32:
+                val.SetInt(int64(dataVal.Float()))
+        case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+                if dataVal.Bool() {
+                        val.SetInt(1)
+                } else {
+                        val.SetInt(0)
+                }
+        case dataKind == reflect.String && d.config.WeaklyTypedInput:
+                i, err := strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())
+                if err == nil {
+                        val.SetInt(i)
+                } else {
+                        return fmt.Errorf("cannot parse '%s' as int: %s", name, err)
+                }
+        case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
+                jn := data.(json.Number)
+                i, err := jn.Int64()
+                if err != nil {
+                        return fmt.Errorf(
+                                "error decoding json.Number into %s: %s", name, err)
+                }
+                val.SetInt(i)
+        default:
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got unconvertible type '%s'",
+                        name, val.Type(), dataVal.Type())
+        }
+
+        return nil
+}
+
+func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.ValueOf(data)
+        dataKind := getKind(dataVal)
+
+        switch {
+        case dataKind == reflect.Int:
+                i := dataVal.Int()
+                if i < 0 && !d.config.WeaklyTypedInput {
+                        return fmt.Errorf("cannot parse '%s', %d overflows uint",
+                                name, i)
+                }
+                val.SetUint(uint64(i))
+        case dataKind == reflect.Uint:
+                val.SetUint(dataVal.Uint())
+        case dataKind == reflect.Float32:
+                f := dataVal.Float()
+                if f < 0 && !d.config.WeaklyTypedInput {
+                        return fmt.Errorf("cannot parse '%s', %f overflows uint",
+                                name, f)
+                }
+                val.SetUint(uint64(f))
+        case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+                if dataVal.Bool() {
+                        val.SetUint(1)
+                } else {
+                        val.SetUint(0)
+                }
+        case dataKind == reflect.String && d.config.WeaklyTypedInput:
+                i, err := strconv.ParseUint(dataVal.String(), 0, val.Type().Bits())
+                if err == nil {
+                        val.SetUint(i)
+                } else {
+                        return fmt.Errorf("cannot parse '%s' as uint: %s", name, err)
+                }
+        default:
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got unconvertible type '%s'",
+                        name, val.Type(), dataVal.Type())
+        }
+
+        return nil
+}
+
+func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.ValueOf(data)
+        dataKind := getKind(dataVal)
+
+        switch {
+        case dataKind == reflect.Bool:
+                val.SetBool(dataVal.Bool())
+        case dataKind == reflect.Int && d.config.WeaklyTypedInput:
+                val.SetBool(dataVal.Int() != 0)
+        case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
+                val.SetBool(dataVal.Uint() != 0)
+        case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
+                val.SetBool(dataVal.Float() != 0)
+        case dataKind == reflect.String && d.config.WeaklyTypedInput:
+                b, err := strconv.ParseBool(dataVal.String())
+                if err == nil {
+                        val.SetBool(b)
+                } else if dataVal.String() == "" {
+                        val.SetBool(false)
+                } else {
+                        return fmt.Errorf("cannot parse '%s' as bool: %s", name, err)
+                }
+        default:
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got unconvertible type '%s'",
+                        name, val.Type(), dataVal.Type())
+        }
+
+        return nil
+}
+
+func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.ValueOf(data)
+        dataKind := getKind(dataVal)
+        dataType := dataVal.Type()
+
+        switch {
+        case dataKind == reflect.Int:
+                val.SetFloat(float64(dataVal.Int()))
+        case dataKind == reflect.Uint:
+                val.SetFloat(float64(dataVal.Uint()))
+        case dataKind == reflect.Float32:
+                val.SetFloat(float64(dataVal.Float()))
+        case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+                if dataVal.Bool() {
+                        val.SetFloat(1)
+                } else {
+                        val.SetFloat(0)
+                }
+        case dataKind == reflect.String && d.config.WeaklyTypedInput:
+                f, err := strconv.ParseFloat(dataVal.String(), val.Type().Bits())
+                if err == nil {
+                        val.SetFloat(f)
+                } else {
+                        return fmt.Errorf("cannot parse '%s' as float: %s", name, err)
+                }
+        case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
+                jn := data.(json.Number)
+                i, err := jn.Float64()
+                if err != nil {
+                        return fmt.Errorf(
+                                "error decoding json.Number into %s: %s", name, err)
+                }
+                val.SetFloat(i)
+        default:
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got unconvertible type '%s'",
+                        name, val.Type(), dataVal.Type())
+        }
+
+        return nil
+}
+
+func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
+        valType := val.Type()
+        valKeyType := valType.Key()
+        valElemType := valType.Elem()
+
+        // By default we overwrite keys in the current map
+        valMap := val
+
+        // If the map is nil or we're purposely zeroing fields, make a new map
+        if valMap.IsNil() || d.config.ZeroFields {
+                // Make a new map to hold our result
+                mapType := reflect.MapOf(valKeyType, valElemType)
+                valMap = reflect.MakeMap(mapType)
+        }
+
+        // Check input type
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
+        if dataVal.Kind() != reflect.Map {
+                // In weak mode, we accept a slice of maps as an input...
+                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 fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
+        }
+
+        // Accumulate errors
+        errors := make([]string, 0)
+
+        for _, k := range dataVal.MapKeys() {
+                fieldName := fmt.Sprintf("%s[%s]", name, k)
+
+                // First decode the key into the proper type
+                currentKey := reflect.Indirect(reflect.New(valKeyType))
+                if err := d.decode(fieldName, k.Interface(), currentKey); err != nil {
+                        errors = appendErrors(errors, err)
+                        continue
+                }
+
+                // Next decode the data into the proper type
+                v := dataVal.MapIndex(k).Interface()
+                currentVal := reflect.Indirect(reflect.New(valElemType))
+                if err := d.decode(fieldName, v, currentVal); err != nil {
+                        errors = appendErrors(errors, err)
+                        continue
+                }
+
+                valMap.SetMapIndex(currentKey, currentVal)
+        }
+
+        // Set the built up map to the value
+        val.Set(valMap)
+
+        // If we had errors, return those
+        if len(errors) > 0 {
+                return &Error{errors}
+        }
+
+        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 err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
+                return err
+        }
+
+        val.Set(realVal)
+        return nil
+}
+
+func (d *Decoder) decodeFunc(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.
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
+        if val.Type() != dataVal.Type() {
+                return fmt.Errorf(
+                        "'%s' expected type '%s', got unconvertible type '%s'",
+                        name, val.Type(), dataVal.Type())
+        }
+        val.Set(dataVal)
+        return nil
+}
+
+func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
+        dataValKind := dataVal.Kind()
+        valType := val.Type()
+        valElemType := valType.Elem()
+        sliceType := reflect.SliceOf(valElemType)
+
+        valSlice := val
+        if valSlice.IsNil() || d.config.ZeroFields {
+                // Check input type
+                if dataValKind != reflect.Array && dataValKind != reflect.Slice {
+                        if d.config.WeaklyTypedInput {
+                                switch {
+                                // Empty maps turn into empty slices
+                                case dataValKind == reflect.Map:
+                                        if dataVal.Len() == 0 {
+                                                val.Set(reflect.MakeSlice(sliceType, 0, 0))
+                                                return nil
+                                        }
+
+                                // 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:
+                                        // Just re-try this function with data as a slice.
+                                        return d.decodeSlice(name, []interface{}{data}, val)
+                                }
+                        }
+
+                        return fmt.Errorf(
+                                "'%s': source data must be an array or slice, got %s", name, dataValKind)
+
+                }
+
+                // Make a new slice to hold our result, same size as the original data.
+                valSlice = reflect.MakeSlice(sliceType, dataVal.Len(), dataVal.Len())
+        }
+
+        // Accumulate any errors
+        errors := make([]string, 0)
+
+        for i := 0; i < dataVal.Len(); i++ {
+                currentData := dataVal.Index(i).Interface()
+                for valSlice.Len() <= i {
+                        valSlice = reflect.Append(valSlice, reflect.Zero(valElemType))
+                }
+                currentField := valSlice.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 slice we built up
+        val.Set(valSlice)
+
+        // 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))
+
+        // If the type of the value to write to and the data match directly,
+        // then we just set it directly instead of recursing into the structure.
+        if dataVal.Type() == val.Type() {
+                val.Set(dataVal)
+                return nil
+        }
+
+        dataValKind := dataVal.Kind()
+        if dataValKind != reflect.Map {
+                return fmt.Errorf("'%s' expected a map, got '%s'", name, dataValKind)
+        }
+
+        dataValType := dataVal.Type()
+        if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {
+                return fmt.Errorf(
+                        "'%s' needs a map with string keys, has '%s' keys",
+                        name, dataValType.Key().Kind())
+        }
+
+        dataValKeys := make(map[reflect.Value]struct{})
+        dataValKeysUnused := make(map[interface{}]struct{})
+        for _, dataValKey := range dataVal.MapKeys() {
+                dataValKeys[dataValKey] = struct{}{}
+                dataValKeysUnused[dataValKey.Interface()] = struct{}{}
+        }
+
+        errors := make([]string, 0)
+
+        // This slice will keep track of all the structs we'll be decoding.
+        // There can be more than one struct if there are embedded structs
+        // that are squashed.
+        structs := make([]reflect.Value, 1, 5)
+        structs[0] = val
+
+        // Compile the list of all the fields that we're going to be decoding
+        // from all the structs.
+        fields := make(map[*reflect.StructField]reflect.Value)
+        for len(structs) > 0 {
+                structVal := structs[0]
+                structs = structs[1:]
+
+                structType := structVal.Type()
+
+                for i := 0; i < structType.NumField(); i++ {
+                        fieldType := structType.Field(i)
+                        fieldKind := fieldType.Type.Kind()
+
+                        // If "squash" is specified in the tag, we squash the field down.
+                        squash := false
+                        tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
+                        for _, tag := range tagParts[1:] {
+                                if tag == "squash" {
+                                        squash = true
+                                        break
+                                }
+                        }
+
+                        if squash {
+                                if fieldKind != reflect.Struct {
+                                        errors = appendErrors(errors,
+                                                fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldKind))
+                                } else {
+                                        structs = append(structs, val.FieldByName(fieldType.Name))
+                                }
+                                continue
+                        }
+
+                        // Normal struct field, store it away
+                        fields[&fieldType] = structVal.Field(i)
+                }
+        }
+
+        for fieldType, field := range fields {
+                fieldName := fieldType.Name
+
+                tagValue := fieldType.Tag.Get(d.config.TagName)
+                tagValue = strings.SplitN(tagValue, ",", 2)[0]
+                if tagValue != "" {
+                        fieldName = tagValue
+                }
+
+                rawMapKey := reflect.ValueOf(fieldName)
+                rawMapVal := dataVal.MapIndex(rawMapKey)
+                if !rawMapVal.IsValid() {
+                        // Do a slower search by iterating over each key and
+                        // doing case-insensitive search.
+                        for dataValKey := range dataValKeys {
+                                mK, ok := dataValKey.Interface().(string)
+                                if !ok {
+                                        // Not a string key
+                                        continue
+                                }
+
+                                if strings.EqualFold(mK, fieldName) {
+                                        rawMapKey = dataValKey
+                                        rawMapVal = dataVal.MapIndex(dataValKey)
+                                        break
+                                }
+                        }
+
+                        if !rawMapVal.IsValid() {
+                                // There was no matching key in the map for the value in
+                                // the struct. Just ignore.
+                                continue
+                        }
+                }
+
+                // Delete the key we're using from the unused map so we stop tracking
+                delete(dataValKeysUnused, rawMapKey.Interface())
+
+                if !field.IsValid() {
+                        // This should never happen
+                        panic("field is not valid")
+                }
+
+                // If we can't set the field, then it is unexported or something,
+                // and we just continue onwards.
+                if !field.CanSet() {
+                        continue
+                }
+
+                // If the name is empty string, then we're at the root, and we
+                // don't dot-join the fields.
+                if name != "" {
+                        fieldName = fmt.Sprintf("%s.%s", name, fieldName)
+                }
+
+                if err := d.decode(fieldName, rawMapVal.Interface(), field); err != nil {
+                        errors = appendErrors(errors, err)
+                }
+        }
+
+        if d.config.ErrorUnused && len(dataValKeysUnused) > 0 {
+                keys := make([]string, 0, len(dataValKeysUnused))
+                for rawKey := range dataValKeysUnused {
+                        keys = append(keys, rawKey.(string))
+                }
+                sort.Strings(keys)
+
+                err := fmt.Errorf("'%s' has invalid keys: %s", name, strings.Join(keys, ", "))
+                errors = appendErrors(errors, err)
+        }
+
+        if len(errors) > 0 {
+                return &Error{errors}
+        }
+
+        // Add the unused keys to the list of unused keys if we're tracking metadata
+        if d.config.Metadata != nil {
+                for rawKey := range dataValKeysUnused {
+                        key := rawKey.(string)
+                        if name != "" {
+                                key = fmt.Sprintf("%s.%s", name, key)
+                        }
+
+                        d.config.Metadata.Unused = append(d.config.Metadata.Unused, key)
+                }
+        }
+
+        return nil
+}
+
+func getKind(val reflect.Value) reflect.Kind {
+        kind := val.Kind()
+
+        switch {
+        case kind >= reflect.Int && kind <= reflect.Int64:
+                return reflect.Int
+        case kind >= reflect.Uint && kind <= reflect.Uint64:
+                return reflect.Uint
+        case kind >= reflect.Float32 && kind <= reflect.Float64:
+                return reflect.Float32
+        default:
+                return kind
+        }
+}
diff --git a/vendor/github.com/mitchellh/reflectwalk/LICENSE b/vendor/github.com/mitchellh/reflectwalk/LICENSE
new file mode 100644
index 0000000..f9c841a
--- /dev/null
+++ b/vendor/github.com/mitchellh/reflectwalk/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mitchell Hashimoto
+
+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.
diff --git a/vendor/github.com/mitchellh/reflectwalk/README.md b/vendor/github.com/mitchellh/reflectwalk/README.md
new file mode 100644
index 0000000..ac82cd2
--- /dev/null
+++ b/vendor/github.com/mitchellh/reflectwalk/README.md
@@ -0,0 +1,6 @@
+# reflectwalk
+
+reflectwalk is a Go library for "walking" a value in Go using reflection,
+in the same way a directory tree can be "walked" on the filesystem. Walking
+a complex structure can allow you to do manipulations on unknown structures
+such as those decoded from JSON.
diff --git a/vendor/github.com/mitchellh/reflectwalk/location.go b/vendor/github.com/mitchellh/reflectwalk/location.go
new file mode 100644
index 0000000..7c59d76
--- /dev/null
+++ b/vendor/github.com/mitchellh/reflectwalk/location.go
@@ -0,0 +1,17 @@
+package reflectwalk
+
+//go:generate stringer -type=Location location.go
+
+type Location uint
+
+const (
+        None Location = iota
+        Map
+        MapKey
+        MapValue
+        Slice
+        SliceElem
+        Struct
+        StructField
+        WalkLoc
+)
diff --git a/vendor/github.com/mitchellh/reflectwalk/location_string.go b/vendor/github.com/mitchellh/reflectwalk/location_string.go
new file mode 100644
index 0000000..d3cfe85
--- /dev/null
+++ b/vendor/github.com/mitchellh/reflectwalk/location_string.go
@@ -0,0 +1,16 @@
+// generated by stringer -type=Location location.go; DO NOT EDIT
+
+package reflectwalk
+
+import "fmt"
+
+const _Location_name = "NoneMapMapKeyMapValueSliceSliceElemStructStructFieldWalkLoc"
+
+var _Location_index = [...]uint8{0, 4, 7, 13, 21, 26, 35, 41, 52, 59}
+
+func (i Location) String() string {
+        if i+1 >= Location(len(_Location_index)) {
+                return fmt.Sprintf("Location(%d)", i)
+        }
+        return _Location_name[_Location_index[i]:_Location_index[i+1]]
+}
diff --git a/vendor/github.com/mitchellh/reflectwalk/reflectwalk.go b/vendor/github.com/mitchellh/reflectwalk/reflectwalk.go
new file mode 100644
index 0000000..ec0a623
--- /dev/null
+++ b/vendor/github.com/mitchellh/reflectwalk/reflectwalk.go
@@ -0,0 +1,339 @@
+// reflectwalk is a package that allows you to "walk" complex structures
+// similar to how you may "walk" a filesystem: visiting every element one
+// by one and calling callback functions allowing you to handle and manipulate
+// those elements.
+package reflectwalk
+
+import (
+        "errors"
+        "reflect"
+)
+
+// PrimitiveWalker implementations are able to handle primitive values
+// within complex structures. Primitive values are numbers, strings,
+// booleans, funcs, chans.
+//
+// These primitive values are often members of more complex
+// structures (slices, maps, etc.) that are walkable by other interfaces.
+type PrimitiveWalker interface {
+        Primitive(reflect.Value) error
+}
+
+// InterfaceWalker implementations are able to handle interface values as they
+// are encountered during the walk.
+type InterfaceWalker interface {
+        Interface(reflect.Value) error
+}
+
+// MapWalker implementations are able to handle individual elements
+// found within a map structure.
+type MapWalker interface {
+        Map(m reflect.Value) error
+        MapElem(m, k, v reflect.Value) error
+}
+
+// SliceWalker implementations are able to handle slice elements found
+// within complex structures.
+type SliceWalker interface {
+        Slice(reflect.Value) error
+        SliceElem(int, reflect.Value) error
+}
+
+// StructWalker is an interface that has methods that are called for
+// structs when a Walk is done.
+type StructWalker interface {
+        Struct(reflect.Value) error
+        StructField(reflect.StructField, reflect.Value) error
+}
+
+// EnterExitWalker implementations are notified before and after
+// they walk deeper into complex structures (into struct fields,
+// into slice elements, etc.)
+type EnterExitWalker interface {
+        Enter(Location) error
+        Exit(Location) error
+}
+
+// PointerWalker implementations are notified when the value they're
+// walking is a pointer or not. Pointer is called for _every_ value whether
+// it is a pointer or not.
+type PointerWalker interface {
+        PointerEnter(bool) error
+        PointerExit(bool) error
+}
+
+// SkipEntry can be returned from walk functions to skip walking
+// the value of this field. This is only valid in the following functions:
+//
+//   - StructField: skips walking the struct value
+//
+var SkipEntry = errors.New("skip this entry")
+
+// Walk takes an arbitrary value and an interface and traverses the
+// value, calling callbacks on the interface if they are supported.
+// The interface should implement one or more of the walker interfaces
+// in this package, such as PrimitiveWalker, StructWalker, etc.
+func Walk(data, walker interface{}) (err error) {
+        v := reflect.ValueOf(data)
+        ew, ok := walker.(EnterExitWalker)
+        if ok {
+                err = ew.Enter(WalkLoc)
+        }
+
+        if err == nil {
+                err = walk(v, walker)
+        }
+
+        if ok && err == nil {
+                err = ew.Exit(WalkLoc)
+        }
+
+        return
+}
+
+func walk(v reflect.Value, w interface{}) (err error) {
+        // Determine if we're receiving a pointer and if so notify the walker.
+        // The logic here is convoluted but very important (tests will fail if
+        // almost any part is changed). I will try to explain here.
+        //
+        // First, we check if the value is an interface, if so, we really need
+        // to check the interface's VALUE to see whether it is a pointer.
+        //
+        // Check whether the value is then a pointer. If so, then set pointer
+        // to true to notify the user.
+        //
+        // If we still have a pointer or an interface after the indirections, then
+        // we unwrap another level
+        //
+        // At this time, we also set "v" to be the dereferenced value. This is
+        // because once we've unwrapped the pointer we want to use that value.
+        pointer := false
+        pointerV := v
+
+        for {
+                if pointerV.Kind() == reflect.Interface {
+                        if iw, ok := w.(InterfaceWalker); ok {
+                                if err = iw.Interface(pointerV); err != nil {
+                                        return
+                                }
+                        }
+
+                        pointerV = pointerV.Elem()
+                }
+
+                if pointerV.Kind() == reflect.Ptr {
+                        pointer = true
+                        v = reflect.Indirect(pointerV)
+                }
+                if pw, ok := w.(PointerWalker); ok {
+                        if err = pw.PointerEnter(pointer); err != nil {
+                                return
+                        }
+
+                        defer func(pointer bool) {
+                                if err != nil {
+                                        return
+                                }
+
+                                err = pw.PointerExit(pointer)
+                        }(pointer)
+                }
+
+                if pointer {
+                        pointerV = v
+                }
+                pointer = false
+
+                // If we still have a pointer or interface we have to indirect another level.
+                switch pointerV.Kind() {
+                case reflect.Ptr, reflect.Interface:
+                        continue
+                }
+                break
+        }
+
+        // We preserve the original value here because if it is an interface
+        // type, we want to pass that directly into the walkPrimitive, so that
+        // we can set it.
+        originalV := v
+        if v.Kind() == reflect.Interface {
+                v = v.Elem()
+        }
+
+        k := v.Kind()
+        if k >= reflect.Int && k <= reflect.Complex128 {
+                k = reflect.Int
+        }
+
+        switch k {
+        // Primitives
+        case reflect.Bool, reflect.Chan, reflect.Func, reflect.Int, reflect.String, reflect.Invalid:
+                err = walkPrimitive(originalV, w)
+                return
+        case reflect.Map:
+                err = walkMap(v, w)
+                return
+        case reflect.Slice:
+                err = walkSlice(v, w)
+                return
+        case reflect.Struct:
+                err = walkStruct(v, w)
+                return
+        default:
+                panic("unsupported type: " + k.String())
+        }
+}
+
+func walkMap(v reflect.Value, w interface{}) error {
+        ew, ewok := w.(EnterExitWalker)
+        if ewok {
+                ew.Enter(Map)
+        }
+
+        if mw, ok := w.(MapWalker); ok {
+                if err := mw.Map(v); err != nil {
+                        return err
+                }
+        }
+
+        for _, k := range v.MapKeys() {
+                kv := v.MapIndex(k)
+
+                if mw, ok := w.(MapWalker); ok {
+                        if err := mw.MapElem(v, k, kv); err != nil {
+                                return err
+                        }
+                }
+
+                ew, ok := w.(EnterExitWalker)
+                if ok {
+                        ew.Enter(MapKey)
+                }
+
+                if err := walk(k, w); err != nil {
+                        return err
+                }
+
+                if ok {
+                        ew.Exit(MapKey)
+                        ew.Enter(MapValue)
+                }
+
+                if err := walk(kv, w); err != nil {
+                        return err
+                }
+
+                if ok {
+                        ew.Exit(MapValue)
+                }
+        }
+
+        if ewok {
+                ew.Exit(Map)
+        }
+
+        return nil
+}
+
+func walkPrimitive(v reflect.Value, w interface{}) error {
+        if pw, ok := w.(PrimitiveWalker); ok {
+                return pw.Primitive(v)
+        }
+
+        return nil
+}
+
+func walkSlice(v reflect.Value, w interface{}) (err error) {
+        ew, ok := w.(EnterExitWalker)
+        if ok {
+                ew.Enter(Slice)
+        }
+
+        if sw, ok := w.(SliceWalker); ok {
+                if err := sw.Slice(v); err != nil {
+                        return err
+                }
+        }
+
+        for i := 0; i < v.Len(); i++ {
+                elem := v.Index(i)
+
+                if sw, ok := w.(SliceWalker); ok {
+                        if err := sw.SliceElem(i, elem); err != nil {
+                                return err
+                        }
+                }
+
+                ew, ok := w.(EnterExitWalker)
+                if ok {
+                        ew.Enter(SliceElem)
+                }
+
+                if err := walk(elem, w); err != nil {
+                        return err
+                }
+
+                if ok {
+                        ew.Exit(SliceElem)
+                }
+        }
+
+        ew, ok = w.(EnterExitWalker)
+        if ok {
+                ew.Exit(Slice)
+        }
+
+        return nil
+}
+
+func walkStruct(v reflect.Value, w interface{}) (err error) {
+        ew, ewok := w.(EnterExitWalker)
+        if ewok {
+                ew.Enter(Struct)
+        }
+
+        if sw, ok := w.(StructWalker); ok {
+                if err = sw.Struct(v); err != nil {
+                        return
+                }
+        }
+
+        vt := v.Type()
+        for i := 0; i < vt.NumField(); i++ {
+                sf := vt.Field(i)
+                f := v.FieldByIndex([]int{i})
+
+                if sw, ok := w.(StructWalker); ok {
+                        err = sw.StructField(sf, f)
+
+                        // SkipEntry just pretends this field doesn't even exist
+                        if err == SkipEntry {
+                                continue
+                        }
+
+                        if err != nil {
+                                return
+                        }
+                }
+
+                ew, ok := w.(EnterExitWalker)
+                if ok {
+                        ew.Enter(StructField)
+                }
+
+                err = walk(f, w)
+                if err != nil {
+                        return
+                }
+
+                if ok {
+                        ew.Exit(StructField)
+                }
+        }
+
+        if ewok {
+                ew.Exit(Struct)
+        }
+
+        return nil
+}