Upgrade to 0.12

28 files changed, 1067 insertions, 202 deletions

diff --git a/vendor/github.com/mitchellh/cli/.travis.yml b/vendor/github.com/mitchellh/cli/.travis.yml
index 974234b..b8599b3 100644
--- a/vendor/github.com/mitchellh/cli/.travis.yml
+++ b/vendor/github.com/mitchellh/cli/.travis.yml
@@ -3,8 +3,9 @@ sudo: false
 language: go
 
 go:
-  - 1.8
-  - 1.9
+  - "1.8"
+  - "1.9"
+  - "1.10"
 
 branches:
   only:
diff --git a/vendor/github.com/mitchellh/cli/cli.go b/vendor/github.com/mitchellh/cli/cli.go
index a25a582..c2dbe55 100644
--- a/vendor/github.com/mitchellh/cli/cli.go
+++ b/vendor/github.com/mitchellh/cli/cli.go
@@ -87,7 +87,7 @@ type CLI struct {
         // should be set exactly to the binary name that is autocompleted.
         //
         // Autocompletion is supported via the github.com/posener/complete
-        // library. This library supports both bash and zsh. To add support
+        // library. This library supports bash, zsh and fish. To add support
         // for other shells, please see that library.
         //
         // AutocompleteInstall and AutocompleteUninstall are the global flag
@@ -419,6 +419,11 @@ func (c *CLI) initAutocomplete() {
 func (c *CLI) initAutocompleteSub(prefix string) complete.Command {
         var cmd complete.Command
         walkFn := func(k string, raw interface{}) bool {
+                // Ignore the empty key which can be present for default commands.
+                if k == "" {
+                        return false
+                }
+
                 // Keep track of the full key so that we can nest further if necessary
                 fullKey := k
 
diff --git a/vendor/github.com/mitchellh/cli/go.mod b/vendor/github.com/mitchellh/cli/go.mod
new file mode 100644
index 0000000..675325f
--- /dev/null
+++ b/vendor/github.com/mitchellh/cli/go.mod
@@ -0,0 +1,12 @@
+module github.com/mitchellh/cli
+
+require (
+        github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310
+        github.com/bgentry/speakeasy v0.1.0
+        github.com/fatih/color v1.7.0
+        github.com/hashicorp/go-multierror v1.0.0 // indirect
+        github.com/mattn/go-colorable v0.0.9 // indirect
+        github.com/mattn/go-isatty v0.0.3
+        github.com/posener/complete v1.1.1
+        golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc // indirect
+)
diff --git a/vendor/github.com/mitchellh/cli/go.sum b/vendor/github.com/mitchellh/cli/go.sum
new file mode 100644
index 0000000..0370875
--- /dev/null
+++ b/vendor/github.com/mitchellh/cli/go.sum
@@ -0,0 +1,22 @@
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310 h1:BUAU3CGlLvorLI26FmByPp2eC2qla6E1Tw+scpcg/to=
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/hashicorp/errwrap v0.0.0-20180715044906-d6c0cd880357 h1:Rem2+U35z1QtPQc6r+WolF7yXiefXqDKyk+lN2pE164=
+github.com/hashicorp/errwrap v0.0.0-20180715044906-d6c0cd880357/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v0.0.0-20180717150148-3d5d8f294aa0 h1:j30noezaCfvNLcdMYSvHLv81DxYRSt1grlpseG67vhU=
+github.com/hashicorp/go-multierror v0.0.0-20180717150148-3d5d8f294aa0/go.mod h1:JMRHfdO9jKNzS/+BTlxCjKNQHg/jZAft8U7LloJvN7I=
+github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/posener/complete v1.1.1 h1:ccV59UEOTzVDnDUEFdT95ZzHVZ+5+158q8+SJb2QV5w=
+github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc h1:MeuS1UDyZyFH++6vVy44PuufTeFF0d0nfI6XB87YGSk=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
diff --git a/vendor/github.com/mitchellh/cli/ui_colored.go b/vendor/github.com/mitchellh/cli/ui_colored.go
index e3d5131..b0ec448 100644
--- a/vendor/github.com/mitchellh/cli/ui_colored.go
+++ b/vendor/github.com/mitchellh/cli/ui_colored.go
@@ -1,7 +1,11 @@
 package cli
 
 import (
-        "fmt"
+        "github.com/fatih/color"
+)
+
+const (
+        noColor = -1
 )
 
 // UiColor is a posix shell color code to use.
@@ -12,13 +16,13 @@ type UiColor struct {
 
 // A list of colors that are useful. These are all non-bolded by default.
 var (
-        UiColorNone    UiColor = UiColor{-1, false}
-        UiColorRed             = UiColor{31, false}
-        UiColorGreen           = UiColor{32, false}
-        UiColorYellow          = UiColor{33, false}
-        UiColorBlue            = UiColor{34, false}
-        UiColorMagenta         = UiColor{35, false}
-        UiColorCyan            = UiColor{36, false}
+        UiColorNone    UiColor = UiColor{noColor, false}
+        UiColorRed             = UiColor{int(color.FgHiRed), false}
+        UiColorGreen           = UiColor{int(color.FgHiGreen), false}
+        UiColorYellow          = UiColor{int(color.FgHiYellow), false}
+        UiColorBlue            = UiColor{int(color.FgHiBlue), false}
+        UiColorMagenta         = UiColor{int(color.FgHiMagenta), false}
+        UiColorCyan            = UiColor{int(color.FgHiCyan), false}
 )
 
 // ColoredUi is a Ui implementation that colors its output according
@@ -55,15 +59,15 @@ func (u *ColoredUi) Warn(message string) {
         u.Ui.Warn(u.colorize(message, u.WarnColor))
 }
 
-func (u *ColoredUi) colorize(message string, color UiColor) string {
-        if color.Code == -1 {
+func (u *ColoredUi) colorize(message string, uc UiColor) string {
+        if uc.Code == noColor {
                 return message
         }
 
-        attr := 0
-        if color.Bold {
-                attr = 1
+        attr := []color.Attribute{color.Attribute(uc.Code)}
+        if uc.Bold {
+                attr = append(attr, color.Bold)
         }
 
-        return fmt.Sprintf("\033[%d;%dm%s\033[0m", attr, color.Code, message)
+        return color.New(attr...).SprintFunc()(message)
 }
diff --git a/vendor/github.com/mitchellh/colorstring/.travis.yml b/vendor/github.com/mitchellh/colorstring/.travis.yml
new file mode 100644
index 0000000..74e286a
--- /dev/null
+++ b/vendor/github.com/mitchellh/colorstring/.travis.yml
@@ -0,0 +1,15 @@
+language: go
+
+go:
+    - 1.0
+    - 1.1
+    - 1.2
+    - 1.3
+    - tip
+
+script:
+    - go test
+
+matrix:
+    allow_failures:
+        - go: tip
diff --git a/vendor/github.com/mitchellh/colorstring/LICENSE b/vendor/github.com/mitchellh/colorstring/LICENSE
new file mode 100644
index 0000000..2298515
--- /dev/null
+++ b/vendor/github.com/mitchellh/colorstring/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/colorstring/README.md b/vendor/github.com/mitchellh/colorstring/README.md
new file mode 100644
index 0000000..0654d45
--- /dev/null
+++ b/vendor/github.com/mitchellh/colorstring/README.md
@@ -0,0 +1,30 @@
+# colorstring [![Build Status](https://travis-ci.org/mitchellh/colorstring.svg)](https://travis-ci.org/mitchellh/colorstring)
+
+colorstring is a [Go](http://www.golang.org) library for outputting colored
+strings to a console using a simple inline syntax in your string to specify
+the color to print as.
+
+For example, the string `[blue]hello [red]world` would output the text
+"hello world" in two colors. The API of colorstring allows for easily disabling
+colors, adding aliases, etc.
+
+## Installation
+
+Standard `go get`:
+
+```
+$ go get github.com/mitchellh/colorstring
+```
+
+## Usage & Example
+
+For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/colorstring).
+
+Usage is easy enough:
+
+```go
+colorstring.Println("[blue]Hello [red]World!")
+```
+
+Additionally, the `Colorize` struct can be used to set options such as
+custom colors, color disabling, etc.
diff --git a/vendor/github.com/mitchellh/colorstring/colorstring.go b/vendor/github.com/mitchellh/colorstring/colorstring.go
new file mode 100644
index 0000000..3de5b24
--- /dev/null
+++ b/vendor/github.com/mitchellh/colorstring/colorstring.go
@@ -0,0 +1,244 @@
+// colorstring provides functions for colorizing strings for terminal
+// output.
+package colorstring
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "regexp"
+        "strings"
+)
+
+// Color colorizes your strings using the default settings.
+//
+// Strings given to Color should use the syntax `[color]` to specify the
+// color for text following. For example: `[blue]Hello` will return "Hello"
+// in blue. See DefaultColors for all the supported colors and attributes.
+//
+// If an unrecognized color is given, it is ignored and assumed to be part
+// of the string. For example: `[hi]world` will result in "[hi]world".
+//
+// A color reset is appended to the end of every string. This will reset
+// the color of following strings when you output this text to the same
+// terminal session.
+//
+// If you want to customize any of this behavior, use the Colorize struct.
+func Color(v string) string {
+        return def.Color(v)
+}
+
+// ColorPrefix returns the color sequence that prefixes the given text.
+//
+// This is useful when wrapping text if you want to inherit the color
+// of the wrapped text. For example, "[green]foo" will return "[green]".
+// If there is no color sequence, then this will return "".
+func ColorPrefix(v string) string {
+        return def.ColorPrefix(v)
+}
+
+// Colorize colorizes your strings, giving you the ability to customize
+// some of the colorization process.
+//
+// The options in Colorize can be set to customize colorization. If you're
+// only interested in the defaults, just use the top Color function directly,
+// which creates a default Colorize.
+type Colorize struct {
+        // Colors maps a color string to the code for that color. The code
+        // is a string so that you can use more complex colors to set foreground,
+        // background, attributes, etc. For example, "boldblue" might be
+        // "1;34"
+        Colors map[string]string
+
+        // If true, color attributes will be ignored. This is useful if you're
+        // outputting to a location that doesn't support colors and you just
+        // want the strings returned.
+        Disable bool
+
+        // Reset, if true, will reset the color after each colorization by
+        // adding a reset code at the end.
+        Reset bool
+}
+
+// Color colorizes a string according to the settings setup in the struct.
+//
+// For more details on the syntax, see the top-level Color function.
+func (c *Colorize) Color(v string) string {
+        matches := parseRe.FindAllStringIndex(v, -1)
+        if len(matches) == 0 {
+                return v
+        }
+
+        result := new(bytes.Buffer)
+        colored := false
+        m := []int{0, 0}
+        for _, nm := range matches {
+                // Write the text in between this match and the last
+                result.WriteString(v[m[1]:nm[0]])
+                m = nm
+
+                var replace string
+                if code, ok := c.Colors[v[m[0]+1:m[1]-1]]; ok {
+                        colored = true
+
+                        if !c.Disable {
+                                replace = fmt.Sprintf("\033[%sm", code)
+                        }
+                } else {
+                        replace = v[m[0]:m[1]]
+                }
+
+                result.WriteString(replace)
+        }
+        result.WriteString(v[m[1]:])
+
+        if colored && c.Reset && !c.Disable {
+                // Write the clear byte at the end
+                result.WriteString("\033[0m")
+        }
+
+        return result.String()
+}
+
+// ColorPrefix returns the first color sequence that exists in this string.
+//
+// For example: "[green]foo" would return "[green]". If no color sequence
+// exists, then "" is returned. This is especially useful when wrapping
+// colored texts to inherit the color of the wrapped text.
+func (c *Colorize) ColorPrefix(v string) string {
+        return prefixRe.FindString(strings.TrimSpace(v))
+}
+
+// DefaultColors are the default colors used when colorizing.
+//
+// If the color is surrounded in underscores, such as "_blue_", then that
+// color will be used for the background color.
+var DefaultColors map[string]string
+
+func init() {
+        DefaultColors = map[string]string{
+                // Default foreground/background colors
+                "default":   "39",
+                "_default_": "49",
+
+                // Foreground colors
+                "black":         "30",
+                "red":           "31",
+                "green":         "32",
+                "yellow":        "33",
+                "blue":          "34",
+                "magenta":       "35",
+                "cyan":          "36",
+                "light_gray":    "37",
+                "dark_gray":     "90",
+                "light_red":     "91",
+                "light_green":   "92",
+                "light_yellow":  "93",
+                "light_blue":    "94",
+                "light_magenta": "95",
+                "light_cyan":    "96",
+                "white":         "97",
+
+                // Background colors
+                "_black_":         "40",
+                "_red_":           "41",
+                "_green_":         "42",
+                "_yellow_":        "43",
+                "_blue_":          "44",
+                "_magenta_":       "45",
+                "_cyan_":          "46",
+                "_light_gray_":    "47",
+                "_dark_gray_":     "100",
+                "_light_red_":     "101",
+                "_light_green_":   "102",
+                "_light_yellow_":  "103",
+                "_light_blue_":    "104",
+                "_light_magenta_": "105",
+                "_light_cyan_":    "106",
+                "_white_":         "107",
+
+                // Attributes
+                "bold":       "1",
+                "dim":        "2",
+                "underline":  "4",
+                "blink_slow": "5",
+                "blink_fast": "6",
+                "invert":     "7",
+                "hidden":     "8",
+
+                // Reset to reset everything to their defaults
+                "reset":      "0",
+                "reset_bold": "21",
+        }
+
+        def = Colorize{
+                Colors: DefaultColors,
+                Reset:  true,
+        }
+}
+
+var def Colorize
+var parseReRaw = `\[[a-z0-9_-]+\]`
+var parseRe = regexp.MustCompile(`(?i)` + parseReRaw)
+var prefixRe = regexp.MustCompile(`^(?i)(` + parseReRaw + `)+`)
+
+// Print is a convenience wrapper for fmt.Print with support for color codes.
+//
+// Print formats using the default formats for its operands and writes to
+// standard output with support for color codes. Spaces are added between
+// operands when neither is a string. It returns the number of bytes written
+// and any write error encountered.
+func Print(a string) (n int, err error) {
+        return fmt.Print(Color(a))
+}
+
+// Println is a convenience wrapper for fmt.Println with support for color
+// codes.
+//
+// Println formats using the default formats for its operands and writes to
+// standard output with support for color codes. Spaces are always added
+// between operands and a newline is appended. It returns the number of bytes
+// written and any write error encountered.
+func Println(a string) (n int, err error) {
+        return fmt.Println(Color(a))
+}
+
+// Printf is a convenience wrapper for fmt.Printf with support for color codes.
+//
+// Printf formats according to a format specifier and writes to standard output
+// with support for color codes. It returns the number of bytes written and any
+// write error encountered.
+func Printf(format string, a ...interface{}) (n int, err error) {
+        return fmt.Printf(Color(format), a...)
+}
+
+// Fprint is a convenience wrapper for fmt.Fprint with support for color codes.
+//
+// Fprint formats using the default formats for its operands and writes to w
+// with support for color codes. Spaces are added between operands when neither
+// is a string. It returns the number of bytes written and any write error
+// encountered.
+func Fprint(w io.Writer, a string) (n int, err error) {
+        return fmt.Fprint(w, Color(a))
+}
+
+// Fprintln is a convenience wrapper for fmt.Fprintln with support for color
+// codes.
+//
+// Fprintln formats using the default formats for its operands and writes to w
+// with support for color codes. Spaces are always added between operands and a
+// newline is appended. It returns the number of bytes written and any write
+// error encountered.
+func Fprintln(w io.Writer, a string) (n int, err error) {
+        return fmt.Fprintln(w, Color(a))
+}
+
+// Fprintf is a convenience wrapper for fmt.Fprintf with support for color
+// codes.
+//
+// Fprintf formats according to a format specifier and writes to w with support
+// for color codes. It returns the number of bytes written and any write error
+// encountered.
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+        return fmt.Fprintf(w, Color(format), a...)
+}
diff --git a/vendor/github.com/mitchellh/colorstring/go.mod b/vendor/github.com/mitchellh/colorstring/go.mod
new file mode 100644
index 0000000..446ff8d
--- /dev/null
+++ b/vendor/github.com/mitchellh/colorstring/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/colorstring
diff --git a/vendor/github.com/mitchellh/copystructure/go.mod b/vendor/github.com/mitchellh/copystructure/go.mod
new file mode 100644
index 0000000..d018643
--- /dev/null
+++ b/vendor/github.com/mitchellh/copystructure/go.mod
@@ -0,0 +1,3 @@
+module github.com/mitchellh/copystructure
+
+require github.com/mitchellh/reflectwalk v1.0.0
diff --git a/vendor/github.com/mitchellh/copystructure/go.sum b/vendor/github.com/mitchellh/copystructure/go.sum
new file mode 100644
index 0000000..be57245
--- /dev/null
+++ b/vendor/github.com/mitchellh/copystructure/go.sum
@@ -0,0 +1,2 @@
+github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY=
+github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
diff --git a/vendor/github.com/mitchellh/go-homedir/go.mod b/vendor/github.com/mitchellh/go-homedir/go.mod
new file mode 100644
index 0000000..7efa09a
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-homedir/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/go-homedir
diff --git a/vendor/github.com/mitchellh/go-homedir/homedir.go b/vendor/github.com/mitchellh/go-homedir/homedir.go
index 47e1f9e..fb87bef 100644
--- a/vendor/github.com/mitchellh/go-homedir/homedir.go
+++ b/vendor/github.com/mitchellh/go-homedir/homedir.go
@@ -77,33 +77,51 @@ func Expand(path string) (string, error) {
 }
 
 func dirUnix() (string, error) {
+        homeEnv := "HOME"
+        if runtime.GOOS == "plan9" {
+                // On plan9, env vars are lowercase.
+                homeEnv = "home"
+        }
+
         // First prefer the HOME environmental variable
-        if home := os.Getenv("HOME"); home != "" {
+        if home := os.Getenv(homeEnv); 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
+
+        // If that fails, try OS specific commands
+        if runtime.GOOS == "darwin" {
+                cmd := exec.Command("sh", "-c", `dscl -q . -read /Users/"$(whoami)" NFSHomeDirectory | sed 's/^[^ ]*: //'`)
+                cmd.Stdout = &stdout
+                if err := cmd.Run(); err == nil {
+                        result := strings.TrimSpace(stdout.String())
+                        if result != "" {
+                                return result, nil
+                        }
                 }
         } 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
+                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 := exec.Command("sh", "-c", "cd && pwd")
         cmd.Stdout = &stdout
         if err := cmd.Run(); err != nil {
                 return "", err
@@ -123,14 +141,16 @@ func dirWindows() (string, error) {
                 return home, nil
         }
 
+        // Prefer standard environment variable USERPROFILE
+        if home := os.Getenv("USERPROFILE"); 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 "", errors.New("HOMEDRIVE, HOMEPATH, or USERPROFILE are blank")
         }
 
         return home, nil
diff --git a/vendor/github.com/mitchellh/go-testing-interface/.travis.yml b/vendor/github.com/mitchellh/go-testing-interface/.travis.yml
index 4c83109..928d000 100644
--- a/vendor/github.com/mitchellh/go-testing-interface/.travis.yml
+++ b/vendor/github.com/mitchellh/go-testing-interface/.travis.yml
@@ -2,6 +2,7 @@ language: go
 
 go:
     - 1.8
+    - 1.x
     - tip
 
 script:
diff --git a/vendor/github.com/mitchellh/go-testing-interface/go.mod b/vendor/github.com/mitchellh/go-testing-interface/go.mod
new file mode 100644
index 0000000..062796d
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-testing-interface/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/go-testing-interface
diff --git a/vendor/github.com/mitchellh/go-testing-interface/testing_go19.go b/vendor/github.com/mitchellh/go-testing-interface/testing_go19.go
index 07fbcb5..31b42ca 100644
--- a/vendor/github.com/mitchellh/go-testing-interface/testing_go19.go
+++ b/vendor/github.com/mitchellh/go-testing-interface/testing_go19.go
@@ -19,14 +19,19 @@ import (
 type T interface {
         Error(args ...interface{})
         Errorf(format string, args ...interface{})
-        Fatal(args ...interface{})
-        Fatalf(format string, args ...interface{})
         Fail()
         FailNow()
         Failed() bool
-        Helper()
+        Fatal(args ...interface{})
+        Fatalf(format string, args ...interface{})
         Log(args ...interface{})
         Logf(format string, args ...interface{})
+        Name() string
+        Skip(args ...interface{})
+        SkipNow()
+        Skipf(format string, args ...interface{})
+        Skipped() bool
+        Helper()
 }
 
 // RuntimeT implements T and can be instantiated and run at runtime to
@@ -34,7 +39,8 @@ type T interface {
 // for calls to Fatal. For calls to Error, you'll have to check the errors
 // list to determine whether to exit yourself.
 type RuntimeT struct {
-        failed bool
+        skipped bool
+        failed  bool
 }
 
 func (t *RuntimeT) Error(args ...interface{}) {
@@ -43,20 +49,10 @@ func (t *RuntimeT) Error(args ...interface{}) {
 }
 
 func (t *RuntimeT) Errorf(format string, args ...interface{}) {
-        log.Println(fmt.Sprintf(format, args...))
+        log.Printf(format, args...)
         t.Fail()
 }
 
-func (t *RuntimeT) Fatal(args ...interface{}) {
-        log.Println(fmt.Sprintln(args...))
-        t.FailNow()
-}
-
-func (t *RuntimeT) Fatalf(format string, args ...interface{}) {
-        log.Println(fmt.Sprintf(format, args...))
-        t.FailNow()
-}
-
 func (t *RuntimeT) Fail() {
         t.failed = true
 }
@@ -69,7 +65,15 @@ func (t *RuntimeT) Failed() bool {
         return t.failed
 }
 
-func (t *RuntimeT) Helper() {}
+func (t *RuntimeT) Fatal(args ...interface{}) {
+        log.Print(args...)
+        t.FailNow()
+}
+
+func (t *RuntimeT) Fatalf(format string, args ...interface{}) {
+        log.Printf(format, args...)
+        t.FailNow()
+}
 
 func (t *RuntimeT) Log(args ...interface{}) {
         log.Println(fmt.Sprintln(args...))
@@ -78,3 +82,27 @@ func (t *RuntimeT) Log(args ...interface{}) {
 func (t *RuntimeT) Logf(format string, args ...interface{}) {
         log.Println(fmt.Sprintf(format, args...))
 }
+
+func (t *RuntimeT) Name() string {
+        return ""
+}
+
+func (t *RuntimeT) Skip(args ...interface{}) {
+        log.Print(args...)
+        t.SkipNow()
+}
+
+func (t *RuntimeT) SkipNow() {
+        t.skipped = true
+}
+
+func (t *RuntimeT) Skipf(format string, args ...interface{}) {
+        log.Printf(format, args...)
+        t.SkipNow()
+}
+
+func (t *RuntimeT) Skipped() bool {
+        return t.skipped
+}
+
+func (t *RuntimeT) Helper() {}
diff --git a/vendor/github.com/mitchellh/go-wordwrap/go.mod b/vendor/github.com/mitchellh/go-wordwrap/go.mod
new file mode 100644
index 0000000..2ae411b
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/go-wordwrap
diff --git a/vendor/github.com/mitchellh/hashstructure/README.md b/vendor/github.com/mitchellh/hashstructure/README.md
index 7d0de5b..28ce45a 100644
--- a/vendor/github.com/mitchellh/hashstructure/README.md
+++ b/vendor/github.com/mitchellh/hashstructure/README.md
@@ -1,4 +1,4 @@
-# hashstructure
+# hashstructure [![GoDoc](https://godoc.org/github.com/mitchellh/hashstructure?status.svg)](https://godoc.org/github.com/mitchellh/hashstructure)
 
 hashstructure is a Go library for creating a unique hash value
 for arbitrary values in Go.
@@ -19,6 +19,9 @@ sending data across the network, caching values locally (de-dup), and so on.
 
   * Optionally specify a custom hash function to optimize for speed, collision
     avoidance for your data set, etc.
+  
+  * Optionally hash the output of `.String()` on structs that implement fmt.Stringer,
+    allowing effective hashing of time.Time
 
 ## Installation
 
@@ -34,28 +37,29 @@ For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/has
 
 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
+```go
+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/go.mod b/vendor/github.com/mitchellh/hashstructure/go.mod
new file mode 100644
index 0000000..966582a
--- /dev/null
+++ b/vendor/github.com/mitchellh/hashstructure/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/hashstructure
diff --git a/vendor/github.com/mitchellh/hashstructure/hashstructure.go b/vendor/github.com/mitchellh/hashstructure/hashstructure.go
index 6f586fa..ea13a15 100644
--- a/vendor/github.com/mitchellh/hashstructure/hashstructure.go
+++ b/vendor/github.com/mitchellh/hashstructure/hashstructure.go
@@ -8,6 +8,16 @@ import (
         "reflect"
 )
 
+// ErrNotStringer is returned when there's an error with hash:"string"
+type ErrNotStringer struct {
+        Field string
+}
+
+// Error implements error for ErrNotStringer
+func (ens *ErrNotStringer) Error() string {
+        return fmt.Sprintf("hashstructure: %s has hash:\"string\" set, but does not implement fmt.Stringer", ens.Field)
+}
+
 // 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
@@ -17,12 +27,18 @@ type HashOptions struct {
         // TagName is the struct tag to look at when hashing the structure.
         // By default this is "hash".
         TagName string
+
+        // ZeroNil is flag determining if nil pointer should be treated equal
+        // to a zero value of pointed type. By default this is false.
+        ZeroNil bool
 }
 
 // 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.
+// for the default values. The same *HashOptions value cannot be used
+// concurrently. None of the values within a *HashOptions struct are
+// safe to read/write while hashing is being done.
 //
 // Notes on the value:
 //
@@ -41,11 +57,14 @@ type HashOptions struct {
 //
 // The available tag values are:
 //
-//   * "ignore" - The field will be ignored and not affect the hash code.
+//   * "ignore" or "-" - 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.
 //
+//   * "string" - The field will be hashed as a string, only works when the
+//                field implements fmt.Stringer
+//
 func Hash(v interface{}, opts *HashOptions) (uint64, error) {
         // Create default options
         if opts == nil {
@@ -63,15 +82,17 @@ func Hash(v interface{}, opts *HashOptions) (uint64, error) {
 
         // Create our walker and walk the structure
         w := &walker{
-                h:   opts.Hasher,
-                tag: opts.TagName,
+                h:       opts.Hasher,
+                tag:     opts.TagName,
+                zeronil: opts.ZeroNil,
         }
         return w.visit(reflect.ValueOf(v), nil)
 }
 
 type walker struct {
-        h   hash.Hash64
-        tag string
+        h       hash.Hash64
+        tag     string
+        zeronil bool
 }
 
 type visitOpts struct {
@@ -84,6 +105,8 @@ type visitOpts struct {
 }
 
 func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
+        t := reflect.TypeOf(0)
+
         // Loop since these can be wrapped in multiple layers of pointers
         // and interfaces.
         for {
@@ -96,6 +119,9 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
                 }
 
                 if v.Kind() == reflect.Ptr {
+                        if w.zeronil {
+                                t = v.Type().Elem()
+                        }
                         v = reflect.Indirect(v)
                         continue
                 }
@@ -105,8 +131,7 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 
         // If it is nil, treat it like a zero.
         if !v.IsValid() {
-                var tmp int8
-                v = reflect.ValueOf(tmp)
+                v = reflect.Zero(t)
         }
 
         // Binary writing can use raw ints, we have to convert to
@@ -189,8 +214,8 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
                 return h, nil
 
         case reflect.Struct:
-                var include Includable
                 parent := v.Interface()
+                var include Includable
                 if impl, ok := parent.(Includable); ok {
                         include = impl
                 }
@@ -203,7 +228,7 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 
                 l := v.NumField()
                 for i := 0; i < l; i++ {
-                        if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
+                        if innerV := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
                                 var f visitFlag
                                 fieldType := t.Field(i)
                                 if fieldType.PkgPath != "" {
@@ -212,14 +237,25 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
                                 }
 
                                 tag := fieldType.Tag.Get(w.tag)
-                                if tag == "ignore" {
+                                if tag == "ignore" || tag == "-" {
                                         // Ignore this field
                                         continue
                                 }
 
+                                // if string is set, use the string value
+                                if tag == "string" {
+                                        if impl, ok := innerV.Interface().(fmt.Stringer); ok {
+                                                innerV = reflect.ValueOf(impl.String())
+                                        } else {
+                                                return 0, &ErrNotStringer{
+                                                        Field: v.Type().Field(i).Name,
+                                                }
+                                        }
+                                }
+
                                 // Check if we implement includable and check it
                                 if include != nil {
-                                        incl, err := include.HashInclude(fieldType.Name, v)
+                                        incl, err := include.HashInclude(fieldType.Name, innerV)
                                         if err != nil {
                                                 return 0, err
                                         }
@@ -238,7 +274,7 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
                                         return 0, err
                                 }
 
-                                vh, err := w.visit(v, &visitOpts{
+                                vh, err := w.visit(innerV, &visitOpts{
                                         Flags:       f,
                                         Struct:      parent,
                                         StructField: fieldType.Name,
@@ -289,7 +325,6 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
                 return 0, fmt.Errorf("unknown kind to hash: %s", k)
         }
 
-        return 0, nil
 }
 
 func hashUpdateOrdered(h hash.Hash64, a, b uint64) uint64 {
diff --git a/vendor/github.com/mitchellh/mapstructure/.travis.yml b/vendor/github.com/mitchellh/mapstructure/.travis.yml
index 7f3fe9a..1689c7d 100644
--- a/vendor/github.com/mitchellh/mapstructure/.travis.yml
+++ b/vendor/github.com/mitchellh/mapstructure/.travis.yml
@@ -1,7 +1,8 @@
-language: go 
+language: go
+
+go:
+  - "1.11.x"
+  - tip
 
-go: 
-  - 1.4
-  
 script:
-  - go test 
+  - go test
diff --git a/vendor/github.com/mitchellh/mapstructure/CHANGELOG.md b/vendor/github.com/mitchellh/mapstructure/CHANGELOG.md
new file mode 100644
index 0000000..3b3cb72
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/CHANGELOG.md
@@ -0,0 +1,21 @@
+## 1.1.2
+
+* Fix error when decode hook decodes interface implementation into interface
+  type. [GH-140]
+
+## 1.1.1
+
+* Fix panic that can happen in `decodePtr`
+
+## 1.1.0
+
+* Added `StringToIPHookFunc` to convert `string` to `net.IP` and `net.IPNet` [GH-133]
+* Support struct to struct decoding [GH-137]
+* If source map value is nil, then destination map value is nil (instead of empty)
+* If source slice value is nil, then destination slice value is nil (instead of empty)
+* If source pointer is nil, then destination pointer is set to nil (instead of
+  allocated zero value of type)
+
+## 1.0.0
+
+* Initial tagged stable release.
diff --git a/vendor/github.com/mitchellh/mapstructure/README.md b/vendor/github.com/mitchellh/mapstructure/README.md
index 659d688..0018dc7 100644
--- a/vendor/github.com/mitchellh/mapstructure/README.md
+++ b/vendor/github.com/mitchellh/mapstructure/README.md
@@ -1,4 +1,4 @@
-# mapstructure
+# mapstructure [![Godoc](https://godoc.org/github.com/mitchellh/mapstructure?status.svg)](https://godoc.org/github.com/mitchellh/mapstructure)
 
 mapstructure is a Go library for decoding generic map values to structures
 and vice versa, while providing helpful error handling.
diff --git a/vendor/github.com/mitchellh/mapstructure/decode_hooks.go b/vendor/github.com/mitchellh/mapstructure/decode_hooks.go
index 115ae67..1f0abc6 100644
--- a/vendor/github.com/mitchellh/mapstructure/decode_hooks.go
+++ b/vendor/github.com/mitchellh/mapstructure/decode_hooks.go
@@ -2,6 +2,8 @@ package mapstructure
 
 import (
         "errors"
+        "fmt"
+        "net"
         "reflect"
         "strconv"
         "strings"
@@ -38,12 +40,6 @@ 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)
@@ -121,6 +117,74 @@ func StringToTimeDurationHookFunc() DecodeHookFunc {
         }
 }
 
+// StringToIPHookFunc returns a DecodeHookFunc that converts
+// strings to net.IP
+func StringToIPHookFunc() 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(net.IP{}) {
+                        return data, nil
+                }
+
+                // Convert it by parsing
+                ip := net.ParseIP(data.(string))
+                if ip == nil {
+                        return net.IP{}, fmt.Errorf("failed parsing ip %v", data)
+                }
+
+                return ip, nil
+        }
+}
+
+// StringToIPNetHookFunc returns a DecodeHookFunc that converts
+// strings to net.IPNet
+func StringToIPNetHookFunc() 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(net.IPNet{}) {
+                        return data, nil
+                }
+
+                // Convert it by parsing
+                _, net, err := net.ParseCIDR(data.(string))
+                return net, err
+        }
+}
+
+// StringToTimeHookFunc returns a DecodeHookFunc that converts
+// strings to time.Time.
+func StringToTimeHookFunc(layout string) DecodeHookFunc {
+        return func(
+                f reflect.Type,
+                t reflect.Type,
+                data interface{}) (interface{}, error) {
+                if f.Kind() != reflect.String {
+                        return data, nil
+                }
+                if t != reflect.TypeOf(time.Time{}) {
+                        return data, nil
+                }
+
+                // Convert it by parsing
+                return time.Parse(layout, data.(string))
+        }
+}
+
+// WeaklyTypedHook is a DecodeHookFunc which adds support for weak typing to
+// the decoder.
+//
+// Note that this is significantly different from the WeaklyTypedInput option
+// of the DecoderConfig.
 func WeaklyTypedHook(
         f reflect.Kind,
         t reflect.Kind,
@@ -132,9 +196,8 @@ func WeaklyTypedHook(
                 case reflect.Bool:
                         if dataVal.Bool() {
                                 return "1", nil
-                        } else {
-                                return "0", nil
                         }
+                        return "0", nil
                 case reflect.Float32:
                         return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
                 case reflect.Int:
diff --git a/vendor/github.com/mitchellh/mapstructure/go.mod b/vendor/github.com/mitchellh/mapstructure/go.mod
new file mode 100644
index 0000000..d2a7125
--- /dev/null
+++ b/vendor/github.com/mitchellh/mapstructure/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/mapstructure
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure.go b/vendor/github.com/mitchellh/mapstructure/mapstructure.go
index 6dee0ef..256ee63 100644
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure.go
+++ b/vendor/github.com/mitchellh/mapstructure/mapstructure.go
@@ -1,5 +1,5 @@
-// The mapstructure package exposes functionality to convert an
-// arbitrary map[string]interface{} into a native Go structure.
+// Package mapstructure 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
@@ -32,7 +32,12 @@ import (
 // both.
 type DecodeHookFunc interface{}
 
+// DecodeHookFuncType is a DecodeHookFunc which has complete information about
+// the source and target types.
 type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
+
+// DecodeHookFuncKind is a DecodeHookFunc which knows only the Kinds of the
+// source and target types.
 type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
 
 // DecoderConfig is the configuration that is used to create a new decoder
@@ -109,12 +114,12 @@ type Metadata struct {
         Unused []string
 }
 
-// Decode takes a map and uses reflection to convert it into the
-// given Go native structure. val must be a pointer to a struct.
-func Decode(m interface{}, rawVal interface{}) error {
+// Decode takes an input structure and uses reflection to translate it to
+// the output structure. output must be a pointer to a map or struct.
+func Decode(input interface{}, output interface{}) error {
         config := &DecoderConfig{
                 Metadata: nil,
-                Result:   rawVal,
+                Result:   output,
         }
 
         decoder, err := NewDecoder(config)
@@ -122,7 +127,7 @@ func Decode(m interface{}, rawVal interface{}) error {
                 return err
         }
 
-        return decoder.Decode(m)
+        return decoder.Decode(input)
 }
 
 // WeakDecode is the same as Decode but is shorthand to enable
@@ -142,6 +147,40 @@ func WeakDecode(input, output interface{}) error {
         return decoder.Decode(input)
 }
 
+// DecodeMetadata is the same as Decode, but is shorthand to
+// enable metadata collection. See DecoderConfig for more info.
+func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
+        config := &DecoderConfig{
+                Metadata: metadata,
+                Result:   output,
+        }
+
+        decoder, err := NewDecoder(config)
+        if err != nil {
+                return err
+        }
+
+        return decoder.Decode(input)
+}
+
+// WeakDecodeMetadata is the same as Decode, but is shorthand to
+// enable both WeaklyTypedInput and metadata collection. See
+// DecoderConfig for more info.
+func WeakDecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
+        config := &DecoderConfig{
+                Metadata:         metadata,
+                Result:           output,
+                WeaklyTypedInput: true,
+        }
+
+        decoder, err := NewDecoder(config)
+        if err != nil {
+                return err
+        }
+
+        return decoder.Decode(input)
+}
+
 // NewDecoder returns a new decoder for the given configuration. Once
 // a decoder has been returned, the same configuration must not be used
 // again.
@@ -179,68 +218,91 @@ func NewDecoder(config *DecoderConfig) (*Decoder, error) {
 
 // Decode decodes the given raw interface to the target pointer specified
 // by the configuration.
-func (d *Decoder) Decode(raw interface{}) error {
-        return d.decode("", raw, reflect.ValueOf(d.config.Result).Elem())
+func (d *Decoder) Decode(input interface{}) error {
+        return d.decode("", input, reflect.ValueOf(d.config.Result).Elem())
 }
 
 // Decodes an unknown data type into a specific reflection value.
-func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error {
-        if data == nil {
-                // If the data is nil, then we don't set anything.
+func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {
+        var inputVal reflect.Value
+        if input != nil {
+                inputVal = reflect.ValueOf(input)
+
+                // We need to check here if input is a typed nil. Typed nils won't
+                // match the "input == nil" below so we check that here.
+                if inputVal.Kind() == reflect.Ptr && inputVal.IsNil() {
+                        input = nil
+                }
+        }
+
+        if input == nil {
+                // If the data is nil, then we don't set anything, unless ZeroFields is set
+                // to true.
+                if d.config.ZeroFields {
+                        outVal.Set(reflect.Zero(outVal.Type()))
+
+                        if d.config.Metadata != nil && name != "" {
+                                d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+                        }
+                }
                 return nil
         }
 
-        dataVal := reflect.ValueOf(data)
-        if !dataVal.IsValid() {
-                // If the data value is invalid, then we just set the value
+        if !inputVal.IsValid() {
+                // If the input value is invalid, then we just set the value
                 // to be the zero value.
-                val.Set(reflect.Zero(val.Type()))
+                outVal.Set(reflect.Zero(outVal.Type()))
+                if d.config.Metadata != nil && name != "" {
+                        d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+                }
                 return nil
         }
 
         if d.config.DecodeHook != nil {
-                // We have a DecodeHook, so let's pre-process the data.
+                // We have a DecodeHook, so let's pre-process the input.
                 var err error
-                data, err = DecodeHookExec(
+                input, err = DecodeHookExec(
                         d.config.DecodeHook,
-                        dataVal.Type(), val.Type(), data)
+                        inputVal.Type(), outVal.Type(), input)
                 if err != nil {
                         return fmt.Errorf("error decoding '%s': %s", name, err)
                 }
         }
 
         var err error
-        dataKind := getKind(val)
-        switch dataKind {
+        outputKind := getKind(outVal)
+        switch outputKind {
         case reflect.Bool:
-                err = d.decodeBool(name, data, val)
+                err = d.decodeBool(name, input, outVal)
         case reflect.Interface:
-                err = d.decodeBasic(name, data, val)
+                err = d.decodeBasic(name, input, outVal)
         case reflect.String:
-                err = d.decodeString(name, data, val)
+                err = d.decodeString(name, input, outVal)
         case reflect.Int:
-                err = d.decodeInt(name, data, val)
+                err = d.decodeInt(name, input, outVal)
         case reflect.Uint:
-                err = d.decodeUint(name, data, val)
+                err = d.decodeUint(name, input, outVal)
         case reflect.Float32:
-                err = d.decodeFloat(name, data, val)
+                err = d.decodeFloat(name, input, outVal)
         case reflect.Struct:
-                err = d.decodeStruct(name, data, val)
+                err = d.decodeStruct(name, input, outVal)
         case reflect.Map:
-                err = d.decodeMap(name, data, val)
+                err = d.decodeMap(name, input, outVal)
         case reflect.Ptr:
-                err = d.decodePtr(name, data, val)
+                err = d.decodePtr(name, input, outVal)
         case reflect.Slice:
-                err = d.decodeSlice(name, data, val)
+                err = d.decodeSlice(name, input, outVal)
+        case reflect.Array:
+                err = d.decodeArray(name, input, outVal)
         case reflect.Func:
-                err = d.decodeFunc(name, data, val)
+                err = d.decodeFunc(name, input, outVal)
         default:
                 // If we reached this point then we weren't able to decode it
-                return fmt.Errorf("%s: unsupported type: %s", name, dataKind)
+                return fmt.Errorf("%s: unsupported type: %s", name, outputKind)
         }
 
         // If we reached here, then we successfully decoded SOMETHING, so
-        // mark the key as used if we're tracking metadata.
+        // mark the key as used if we're tracking metainput.
         if d.config.Metadata != nil && name != "" {
                 d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
         }
@@ -251,7 +313,19 @@ func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error
 // This decodes a basic type (bool, int, string, etc.) and sets the
 // value to "data" of that type.
 func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
+        if val.IsValid() && val.Elem().IsValid() {
+                return d.decode(name, data, val.Elem())
+        }
+
         dataVal := reflect.ValueOf(data)
+
+        // If the input data is a pointer, and the assigned type is the dereference
+        // of that exact pointer, then indirect it so that we can assign it.
+        // Example: *string to string
+        if dataVal.Kind() == reflect.Ptr && dataVal.Type().Elem() == val.Type() {
+                dataVal = reflect.Indirect(dataVal)
+        }
+
         if !dataVal.IsValid() {
                 dataVal = reflect.Zero(val.Type())
         }
@@ -268,7 +342,7 @@ func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value)
 }
 
 func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {
-        dataVal := reflect.ValueOf(data)
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
         dataKind := getKind(dataVal)
 
         converted := true
@@ -287,12 +361,22 @@ func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value)
                 val.SetString(strconv.FormatUint(dataVal.Uint(), 10))
         case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
                 val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))
-        case dataKind == reflect.Slice && d.config.WeaklyTypedInput:
+        case dataKind == reflect.Slice && d.config.WeaklyTypedInput,
+                dataKind == reflect.Array && d.config.WeaklyTypedInput:
                 dataType := dataVal.Type()
                 elemKind := dataType.Elem().Kind()
-                switch {
-                case elemKind == reflect.Uint8:
-                        val.SetString(string(dataVal.Interface().([]uint8)))
+                switch elemKind {
+                case reflect.Uint8:
+                        var uints []uint8
+                        if dataKind == reflect.Array {
+                                uints = make([]uint8, dataVal.Len(), dataVal.Len())
+                                for i := range uints {
+                                        uints[i] = dataVal.Index(i).Interface().(uint8)
+                                }
+                        } else {
+                                uints = dataVal.Interface().([]uint8)
+                        }
+                        val.SetString(string(uints))
                 default:
                         converted = false
                 }
@@ -310,7 +394,7 @@ func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value)
 }
 
 func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
-        dataVal := reflect.ValueOf(data)
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
         dataKind := getKind(dataVal)
         dataType := dataVal.Type()
 
@@ -352,7 +436,7 @@ func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) er
 }
 
 func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
-        dataVal := reflect.ValueOf(data)
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
         dataKind := getKind(dataVal)
 
         switch {
@@ -395,7 +479,7 @@ func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) e
 }
 
 func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {
-        dataVal := reflect.ValueOf(data)
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
         dataKind := getKind(dataVal)
 
         switch {
@@ -426,7 +510,7 @@ func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) e
 }
 
 func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
-        dataVal := reflect.ValueOf(data)
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
         dataKind := getKind(dataVal)
         dataType := dataVal.Type()
 
@@ -436,7 +520,7 @@ func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value)
         case dataKind == reflect.Uint:
                 val.SetFloat(float64(dataVal.Uint()))
         case dataKind == reflect.Float32:
-                val.SetFloat(float64(dataVal.Float()))
+                val.SetFloat(dataVal.Float())
         case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
                 if dataVal.Bool() {
                         val.SetFloat(1)
@@ -482,38 +566,68 @@ func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) er
                 valMap = reflect.MakeMap(mapType)
         }
 
-        // Check input type
+        // Check input type and based on the input type jump to the proper func
         dataVal := reflect.Indirect(reflect.ValueOf(data))
-        if dataVal.Kind() != reflect.Map {
-                // In weak mode, we accept a slice of maps as an input...
-                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
-                                }
+        switch dataVal.Kind() {
+        case reflect.Map:
+                return d.decodeMapFromMap(name, dataVal, val, valMap)
 
-                                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
-                                        }
-                                }
+        case reflect.Struct:
+                return d.decodeMapFromStruct(name, dataVal, val, valMap)
 
-                                return nil
-                        }
+        case reflect.Array, reflect.Slice:
+                if d.config.WeaklyTypedInput {
+                        return d.decodeMapFromSlice(name, dataVal, val, valMap)
                 }
 
+                fallthrough
+
+        default:
                 return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
         }
+}
+
+func (d *Decoder) decodeMapFromSlice(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+        // Special case for BC reasons (covered by tests)
+        if dataVal.Len() == 0 {
+                val.Set(valMap)
+                return nil
+        }
+
+        for i := 0; i < dataVal.Len(); i++ {
+                err := d.decode(
+                        fmt.Sprintf("%s[%d]", name, i),
+                        dataVal.Index(i).Interface(), val)
+                if err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+        valType := val.Type()
+        valKeyType := valType.Key()
+        valElemType := valType.Elem()
 
         // Accumulate errors
         errors := make([]string, 0)
 
+        // If the input data is empty, then we just match what the input data is.
+        if dataVal.Len() == 0 {
+                if dataVal.IsNil() {
+                        if !val.IsNil() {
+                                val.Set(dataVal)
+                        }
+                } else {
+                        // Set to empty allocated value
+                        val.Set(valMap)
+                }
+
+                return nil
+        }
+
         for _, k := range dataVal.MapKeys() {
                 fieldName := fmt.Sprintf("%s[%s]", name, k)
 
@@ -546,22 +660,128 @@ func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) er
         return nil
 }
 
+func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+        typ := dataVal.Type()
+        for i := 0; i < typ.NumField(); i++ {
+                // Get the StructField first since this is a cheap operation. If the
+                // field is unexported, then ignore it.
+                f := typ.Field(i)
+                if f.PkgPath != "" {
+                        continue
+                }
+
+                // Next get the actual value of this field and verify it is assignable
+                // to the map value.
+                v := dataVal.Field(i)
+                if !v.Type().AssignableTo(valMap.Type().Elem()) {
+                        return fmt.Errorf("cannot assign type '%s' to map value field of type '%s'", v.Type(), valMap.Type().Elem())
+                }
+
+                tagValue := f.Tag.Get(d.config.TagName)
+                tagParts := strings.Split(tagValue, ",")
+
+                // Determine the name of the key in the map
+                keyName := f.Name
+                if tagParts[0] != "" {
+                        if tagParts[0] == "-" {
+                                continue
+                        }
+                        keyName = tagParts[0]
+                }
+
+                // If "squash" is specified in the tag, we squash the field down.
+                squash := false
+                for _, tag := range tagParts[1:] {
+                        if tag == "squash" {
+                                squash = true
+                                break
+                        }
+                }
+                if squash && v.Kind() != reflect.Struct {
+                        return fmt.Errorf("cannot squash non-struct type '%s'", v.Type())
+                }
+
+                switch v.Kind() {
+                // this is an embedded struct, so handle it differently
+                case reflect.Struct:
+                        x := reflect.New(v.Type())
+                        x.Elem().Set(v)
+
+                        vType := valMap.Type()
+                        vKeyType := vType.Key()
+                        vElemType := vType.Elem()
+                        mType := reflect.MapOf(vKeyType, vElemType)
+                        vMap := reflect.MakeMap(mType)
+
+                        err := d.decode(keyName, x.Interface(), vMap)
+                        if err != nil {
+                                return err
+                        }
+
+                        if squash {
+                                for _, k := range vMap.MapKeys() {
+                                        valMap.SetMapIndex(k, vMap.MapIndex(k))
+                                }
+                        } else {
+                                valMap.SetMapIndex(reflect.ValueOf(keyName), vMap)
+                        }
+
+                default:
+                        valMap.SetMapIndex(reflect.ValueOf(keyName), v)
+                }
+        }
+
+        if val.CanAddr() {
+                val.Set(valMap)
+        }
+
+        return nil
+}
+
 func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) error {
+        // If the input data is nil, then we want to just set the output
+        // pointer to be nil as well.
+        isNil := data == nil
+        if !isNil {
+                switch v := reflect.Indirect(reflect.ValueOf(data)); v.Kind() {
+                case reflect.Chan,
+                        reflect.Func,
+                        reflect.Interface,
+                        reflect.Map,
+                        reflect.Ptr,
+                        reflect.Slice:
+                        isNil = v.IsNil()
+                }
+        }
+        if isNil {
+                if !val.IsNil() && val.CanSet() {
+                        nilValue := reflect.New(val.Type()).Elem()
+                        val.Set(nilValue)
+                }
+
+                return nil
+        }
+
         // 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()
+        if val.CanSet() {
+                realVal := val
+                if realVal.IsNil() || d.config.ZeroFields {
+                        realVal = reflect.New(valElemType)
+                }
 
-        realVal := val
-        if realVal.IsNil() || d.config.ZeroFields {
-                realVal = reflect.New(valElemType)
-        }
+                if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
+                        return err
+                }
 
-        if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
-                return err
+                val.Set(realVal)
+        } else {
+                if err := d.decode(name, data, reflect.Indirect(val)); err != nil {
+                        return err
+                }
         }
-
-        val.Set(realVal)
         return nil
 }
 
@@ -587,22 +807,101 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
 
         valSlice := val
         if valSlice.IsNil() || d.config.ZeroFields {
+                if d.config.WeaklyTypedInput {
+                        switch {
+                        // Slice and array we use the normal logic
+                        case dataValKind == reflect.Slice, dataValKind == reflect.Array:
+                                break
+
+                        // Empty maps turn into empty slices
+                        case dataValKind == reflect.Map:
+                                if dataVal.Len() == 0 {
+                                        val.Set(reflect.MakeSlice(sliceType, 0, 0))
+                                        return nil
+                                }
+                                // Create slice of maps of other sizes
+                                return d.decodeSlice(name, []interface{}{data}, val)
+
+                        case dataValKind == reflect.String && valElemType.Kind() == reflect.Uint8:
+                                return d.decodeSlice(name, []byte(dataVal.String()), val)
+
+                        // All other types we try to convert to the slice type
+                        // and "lift" it into it. i.e. a string becomes a string slice.
+                        default:
+                                // Just re-try this function with data as a slice.
+                                return d.decodeSlice(name, []interface{}{data}, val)
+                        }
+                }
+
+                // Check input type
+                if dataValKind != reflect.Array && dataValKind != reflect.Slice {
+                        return fmt.Errorf(
+                                "'%s': source data must be an array or slice, got %s", name, dataValKind)
+
+                }
+
+                // If the input value is empty, then don't allocate since non-nil != nil
+                if dataVal.Len() == 0 {
+                        return nil
+                }
+
+                // 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) decodeArray(name string, data interface{}, val reflect.Value) error {
+        dataVal := reflect.Indirect(reflect.ValueOf(data))
+        dataValKind := dataVal.Kind()
+        valType := val.Type()
+        valElemType := valType.Elem()
+        arrayType := reflect.ArrayOf(valType.Len(), valElemType)
+
+        valArray := val
+
+        if valArray.Interface() == reflect.Zero(valArray.Type()).Interface() || d.config.ZeroFields {
                 // Check input type
                 if dataValKind != reflect.Array && dataValKind != reflect.Slice {
                         if d.config.WeaklyTypedInput {
                                 switch {
-                                // Empty maps turn into empty slices
+                                // Empty maps turn into empty arrays
                                 case dataValKind == reflect.Map:
                                         if dataVal.Len() == 0 {
-                                                val.Set(reflect.MakeSlice(sliceType, 0, 0))
+                                                val.Set(reflect.Zero(arrayType))
                                                 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.
+                                // All other types we try to convert to the array type
+                                // and "lift" it into it. i.e. a string becomes a string array.
                                 default:
                                         // Just re-try this function with data as a slice.
-                                        return d.decodeSlice(name, []interface{}{data}, val)
+                                        return d.decodeArray(name, []interface{}{data}, val)
                                 }
                         }
 
@@ -610,9 +909,14 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
                                 "'%s': source data must be an array or slice, got %s", name, dataValKind)
 
                 }
+                if dataVal.Len() > arrayType.Len() {
+                        return fmt.Errorf(
+                                "'%s': expected source data to have length less or equal to %d, got %d", name, arrayType.Len(), dataVal.Len())
 
-                // Make a new slice to hold our result, same size as the original data.
-                valSlice = reflect.MakeSlice(sliceType, dataVal.Len(), dataVal.Len())
+                }
+
+                // Make a new array to hold our result, same size as the original data.
+                valArray = reflect.New(arrayType).Elem()
         }
 
         // Accumulate any errors
@@ -620,10 +924,7 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
 
         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)
+                currentField := valArray.Index(i)
 
                 fieldName := fmt.Sprintf("%s[%d]", name, i)
                 if err := d.decode(fieldName, currentData, currentField); err != nil {
@@ -631,8 +932,8 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
                 }
         }
 
-        // Finally, set the value to the slice we built up
-        val.Set(valSlice)
+        // Finally, set the value to the array we built up
+        val.Set(valArray)
 
         // If there were errors, we return those
         if len(errors) > 0 {
@@ -653,10 +954,29 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
         }
 
         dataValKind := dataVal.Kind()
-        if dataValKind != reflect.Map {
-                return fmt.Errorf("'%s' expected a map, got '%s'", name, dataValKind)
+        switch dataValKind {
+        case reflect.Map:
+                return d.decodeStructFromMap(name, dataVal, val)
+
+        case reflect.Struct:
+                // Not the most efficient way to do this but we can optimize later if
+                // we want to. To convert from struct to struct we go to map first
+                // as an intermediary.
+                m := make(map[string]interface{})
+                mval := reflect.Indirect(reflect.ValueOf(&m))
+                if err := d.decodeMapFromStruct(name, dataVal, mval, mval); err != nil {
+                        return err
+                }
+
+                result := d.decodeStructFromMap(name, mval, val)
+                return result
+
+        default:
+                return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
         }
+}
 
+func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) error {
         dataValType := dataVal.Type()
         if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {
                 return fmt.Errorf(
@@ -681,7 +1001,11 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
 
         // 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)
+        type field struct {
+                field reflect.StructField
+                val   reflect.Value
+        }
+        fields := []field{}
         for len(structs) > 0 {
                 structVal := structs[0]
                 structs = structs[1:]
@@ -707,20 +1031,22 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
                                         errors = appendErrors(errors,
                                                 fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldKind))
                                 } else {
-                                        structs = append(structs, val.FieldByName(fieldType.Name))
+                                        structs = append(structs, structVal.FieldByName(fieldType.Name))
                                 }
                                 continue
                         }
 
                         // Normal struct field, store it away
-                        fields[&fieldType] = structVal.Field(i)
+                        fields = append(fields, field{fieldType, structVal.Field(i)})
                 }
         }
 
-        for fieldType, field := range fields {
-                fieldName := fieldType.Name
+        // for fieldType, field := range fields {
+        for _, f := range fields {
+                field, fieldValue := f.field, f.val
+                fieldName := field.Name
 
-                tagValue := fieldType.Tag.Get(d.config.TagName)
+                tagValue := field.Tag.Get(d.config.TagName)
                 tagValue = strings.SplitN(tagValue, ",", 2)[0]
                 if tagValue != "" {
                         fieldName = tagValue
@@ -755,14 +1081,14 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
                 // Delete the key we're using from the unused map so we stop tracking
                 delete(dataValKeysUnused, rawMapKey.Interface())
 
-                if !field.IsValid() {
+                if !fieldValue.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() {
+                if !fieldValue.CanSet() {
                         continue
                 }
 
@@ -772,7 +1098,7 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
                         fieldName = fmt.Sprintf("%s.%s", name, fieldName)
                 }
 
-                if err := d.decode(fieldName, rawMapVal.Interface(), field); err != nil {
+                if err := d.decode(fieldName, rawMapVal.Interface(), fieldValue); err != nil {
                         errors = appendErrors(errors, err)
                 }
         }
diff --git a/vendor/github.com/mitchellh/reflectwalk/go.mod b/vendor/github.com/mitchellh/reflectwalk/go.mod
new file mode 100644
index 0000000..52bb7c4
--- /dev/null
+++ b/vendor/github.com/mitchellh/reflectwalk/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/reflectwalk