5 files changed, 399 insertions, 0 deletions

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
+}