1 files changed, 169 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/errwrap/errwrap.go b/vendor/github.com/hashicorp/errwrap/errwrap.go
new file mode 100644
index 0000000..a733bef
--- /dev/null
+++ b/vendor/github.com/hashicorp/errwrap/errwrap.go
@@ -0,0 +1,169 @@
+// Package errwrap implements methods to formalize error wrapping in Go.
+//
+// All of the top-level functions that take an `error` are built to be able
+// to take any error, not just wrapped errors. This allows you to use errwrap
+// without having to type-check and type-cast everywhere.
+package errwrap
+
+import (
+        "errors"
+        "reflect"
+        "strings"
+)
+
+// WalkFunc is the callback called for Walk.
+type WalkFunc func(error)
+
+// Wrapper is an interface that can be implemented by custom types to
+// have all the Contains, Get, etc. functions in errwrap work.
+//
+// When Walk reaches a Wrapper, it will call the callback for every
+// wrapped error in addition to the wrapper itself. Since all the top-level
+// functions in errwrap use Walk, this means that all those functions work
+// with your custom type.
+type Wrapper interface {
+        WrappedErrors() []error
+}
+
+// Wrap defines that outer wraps inner, returning an error type that
+// can be cleanly used with the other methods in this package, such as
+// Contains, GetAll, etc.
+//
+// This function won't modify the error message at all (the outer message
+// will be used).
+func Wrap(outer, inner error) error {
+        return &wrappedError{
+                Outer: outer,
+                Inner: inner,
+        }
+}
+
+// Wrapf wraps an error with a formatting message. This is similar to using
+// `fmt.Errorf` to wrap an error. If you're using `fmt.Errorf` to wrap
+// errors, you should replace it with this.
+//
+// format is the format of the error message. The string '{{err}}' will
+// be replaced with the original error message.
+func Wrapf(format string, err error) error {
+        outerMsg := "<nil>"
+        if err != nil {
+                outerMsg = err.Error()
+        }
+
+        outer := errors.New(strings.Replace(
+                format, "{{err}}", outerMsg, -1))
+
+        return Wrap(outer, err)
+}
+
+// Contains checks if the given error contains an error with the
+// message msg. If err is not a wrapped error, this will always return
+// false unless the error itself happens to match this msg.
+func Contains(err error, msg string) bool {
+        return len(GetAll(err, msg)) > 0
+}
+
+// ContainsType checks if the given error contains an error with
+// the same concrete type as v. If err is not a wrapped error, this will
+// check the err itself.
+func ContainsType(err error, v interface{}) bool {
+        return len(GetAllType(err, v)) > 0
+}
+
+// Get is the same as GetAll but returns the deepest matching error.
+func Get(err error, msg string) error {
+        es := GetAll(err, msg)
+        if len(es) > 0 {
+                return es[len(es)-1]
+        }
+
+        return nil
+}
+
+// GetType is the same as GetAllType but returns the deepest matching error.
+func GetType(err error, v interface{}) error {
+        es := GetAllType(err, v)
+        if len(es) > 0 {
+                return es[len(es)-1]
+        }
+
+        return nil
+}
+
+// GetAll gets all the errors that might be wrapped in err with the
+// given message. The order of the errors is such that the outermost
+// matching error (the most recent wrap) is index zero, and so on.
+func GetAll(err error, msg string) []error {
+        var result []error
+
+        Walk(err, func(err error) {
+                if err.Error() == msg {
+                        result = append(result, err)
+                }
+        })
+
+        return result
+}
+
+// GetAllType gets all the errors that are the same type as v.
+//
+// The order of the return value is the same as described in GetAll.
+func GetAllType(err error, v interface{}) []error {
+        var result []error
+
+        var search string
+        if v != nil {
+                search = reflect.TypeOf(v).String()
+        }
+        Walk(err, func(err error) {
+                var needle string
+                if err != nil {
+                        needle = reflect.TypeOf(err).String()
+                }
+
+                if needle == search {
+                        result = append(result, err)
+                }
+        })
+
+        return result
+}
+
+// Walk walks all the wrapped errors in err and calls the callback. If
+// err isn't a wrapped error, this will be called once for err. If err
+// is a wrapped error, the callback will be called for both the wrapper
+// that implements error as well as the wrapped error itself.
+func Walk(err error, cb WalkFunc) {
+        if err == nil {
+                return
+        }
+
+        switch e := err.(type) {
+        case *wrappedError:
+                cb(e.Outer)
+                Walk(e.Inner, cb)
+        case Wrapper:
+                cb(err)
+
+                for _, err := range e.WrappedErrors() {
+                        Walk(err, cb)
+                }
+        default:
+                cb(err)
+        }
+}
+
+// wrappedError is an implementation of error that has both the
+// outer and inner errors.
+type wrappedError struct {
+        Outer error
+        Inner error
+}
+
+func (w *wrappedError) Error() string {
+        return w.Outer.Error()
+}
+
+func (w *wrappedError) WrappedErrors() []error {
+        return []error{w.Outer, w.Inner}
+}