Switch to dep for dependency management

vendor/github.com/jmoiron/sqlx/reflectx/README.md

@@ -12,6 +12,6 @@ behavior of standard Go accessors.
 
 The first two are amply taken care of by `Reflect.Value.FieldByName`, and the third is
 addressed by `Reflect.Value.FieldByNameFunc`, but these don't quite understand struct
-tags in the ways that are vital to most marshalers, and they are slow.
+tags in the ways that are vital to most marshallers, and they are slow.
 
 This reflectx package extends reflect to achieve these goals.

vendor/github.com/jmoiron/sqlx/reflectx/reflect.go

@@ -1,45 +1,100 @@
-// Package reflect implements extensions to the standard reflect lib suitable
-// for implementing marshaling and unmarshaling packages.  The main Mapper type
-// allows for Go-compatible named atribute access, including accessing embedded
+// Package reflectx implements extensions to the standard reflect lib suitable
+// for implementing marshalling and unmarshalling packages.  The main Mapper type
+// allows for Go-compatible named attribute access, including accessing embedded
 // struct attributes and the ability to use  functions and struct tags to
 // customize field names.
 //
 package reflectx
 
-import "sync"
-
 import (
 	"reflect"
 	"runtime"
+	"strings"
+	"sync"
 )
 
-type fieldMap map[string][]int
-
-// Mapper is a general purpose mapper of names to struct fields.  A Mapper
-// behaves like most marshallers, optionally obeying a field tag for name
-// mapping and a function to provide a basic mapping of fields to names.
-type Mapper struct {
-	cache   map[reflect.Type]fieldMap
-	tagName string
-	mapFunc func(string) string
-	mutex   sync.Mutex
+// A FieldInfo is metadata for a struct field.
+type FieldInfo struct {
+	Index    []int
+	Path     string
+	Field    reflect.StructField
+	Zero     reflect.Value
+	Name     string
+	Options  map[string]string
+	Embedded bool
+	Children []*FieldInfo
+	Parent   *FieldInfo
 }
 
-// NewMapper returns a new mapper which optionally obeys the field tag given
-// by tagName.  If tagName is the empty string, it is ignored.
+// A StructMap is an index of field metadata for a struct.
+type StructMap struct {
+	Tree  *FieldInfo
+	Index []*FieldInfo
+	Paths map[string]*FieldInfo
+	Names map[string]*FieldInfo
+}
+
+// GetByPath returns a *FieldInfo for a given string path.
+func (f StructMap) GetByPath(path string) *FieldInfo {
+	return f.Paths[path]
+}
+
+// GetByTraversal returns a *FieldInfo for a given integer path.  It is
+// analogous to reflect.FieldByIndex, but using the cached traversal
+// rather than re-executing the reflect machinery each time.
+func (f StructMap) GetByTraversal(index []int) *FieldInfo {
+	if len(index) == 0 {
+		return nil
+	}
+
+	tree := f.Tree
+	for _, i := range index {
+		if i >= len(tree.Children) || tree.Children[i] == nil {
+			return nil
+		}
+		tree = tree.Children[i]
+	}
+	return tree
+}
+
+// Mapper is a general purpose mapper of names to struct fields.  A Mapper
+// behaves like most marshallers in the standard library, obeying a field tag
+// for name mapping but also providing a basic transform function.
+type Mapper struct {
+	cache      map[reflect.Type]*StructMap
+	tagName    string
+	tagMapFunc func(string) string
+	mapFunc    func(string) string
+	mutex      sync.Mutex
+}
+
+// NewMapper returns a new mapper using the tagName as its struct field tag.
+// If tagName is the empty string, it is ignored.
 func NewMapper(tagName string) *Mapper {
 	return &Mapper{
-		cache:   make(map[reflect.Type]fieldMap),
+		cache:   make(map[reflect.Type]*StructMap),
 		tagName: tagName,
 	}
 }
 
+// NewMapperTagFunc returns a new mapper which contains a mapper for field names
+// AND a mapper for tag values.  This is useful for tags like json which can
+// have values like "name,omitempty".
+func NewMapperTagFunc(tagName string, mapFunc, tagMapFunc func(string) string) *Mapper {
+	return &Mapper{
+		cache:      make(map[reflect.Type]*StructMap),
+		tagName:    tagName,
+		mapFunc:    mapFunc,
+		tagMapFunc: tagMapFunc,
+	}
+}
+
 // NewMapperFunc returns a new mapper which optionally obeys a field tag and
 // a struct field name mapper func given by f.  Tags will take precedence, but
 // for any other field, the mapped name will be f(field.Name)
 func NewMapperFunc(tagName string, f func(string) string) *Mapper {
 	return &Mapper{
-		cache:   make(map[reflect.Type]fieldMap),
+		cache:   make(map[reflect.Type]*StructMap),
 		tagName: tagName,
 		mapFunc: f,
 	}
@@ -47,11 +102,11 @@ func NewMapperFunc(tagName string, f func(string) string) *Mapper {
 
 // TypeMap returns a mapping of field strings to int slices representing
 // the traversal down the struct to reach the field.
-func (m *Mapper) TypeMap(t reflect.Type) fieldMap {
+func (m *Mapper) TypeMap(t reflect.Type) *StructMap {
 	m.mutex.Lock()
 	mapping, ok := m.cache[t]
 	if !ok {
-		mapping = getMapping(t, m.tagName, m.mapFunc)
+		mapping = getMapping(t, m.tagName, m.mapFunc, m.tagMapFunc)
 		m.cache[t] = mapping
 	}
 	m.mutex.Unlock()
@@ -65,26 +120,26 @@ func (m *Mapper) FieldMap(v reflect.Value) map[string]reflect.Value {
 	mustBe(v, reflect.Struct)
 
 	r := map[string]reflect.Value{}
-	nm := m.TypeMap(v.Type())
-	for tagName, indexes := range nm {
-		r[tagName] = FieldByIndexes(v, indexes)
+	tm := m.TypeMap(v.Type())
+	for tagName, fi := range tm.Names {
+		r[tagName] = FieldByIndexes(v, fi.Index)
 	}
 	return r
 }
 
-// FieldByName returns a field by the its mapped name as a reflect.Value.
+// FieldByName returns a field by its mapped name as a reflect.Value.
 // Panics if v's Kind is not Struct or v is not Indirectable to a struct Kind.
 // Returns zero Value if the name is not found.
 func (m *Mapper) FieldByName(v reflect.Value, name string) reflect.Value {
 	v = reflect.Indirect(v)
 	mustBe(v, reflect.Struct)
 
-	nm := m.TypeMap(v.Type())
-	traversal, ok := nm[name]
+	tm := m.TypeMap(v.Type())
+	fi, ok := tm.Names[name]
 	if !ok {
-		return *new(reflect.Value)
+		return v
 	}
-	return FieldByIndexes(v, traversal)
+	return FieldByIndexes(v, fi.Index)
 }
 
 // FieldsByName returns a slice of values corresponding to the slice of names
@@ -94,45 +149,64 @@ func (m *Mapper) FieldsByName(v reflect.Value, names []string) []reflect.Value {
 	v = reflect.Indirect(v)
 	mustBe(v, reflect.Struct)
 
-	nm := m.TypeMap(v.Type())
-
+	tm := m.TypeMap(v.Type())
 	vals := make([]reflect.Value, 0, len(names))
 	for _, name := range names {
-		traversal, ok := nm[name]
+		fi, ok := tm.Names[name]
 		if !ok {
 			vals = append(vals, *new(reflect.Value))
 		} else {
-			vals = append(vals, FieldByIndexes(v, traversal))
+			vals = append(vals, FieldByIndexes(v, fi.Index))
 		}
 	}
 	return vals
 }
 
-// Traversals by name returns a slice of int slices which represent the struct
+// TraversalsByName returns a slice of int slices which represent the struct
 // traversals for each mapped name.  Panics if t is not a struct or Indirectable
 // to a struct.  Returns empty int slice for each name not found.
 func (m *Mapper) TraversalsByName(t reflect.Type, names []string) [][]int {
-	t = Deref(t)
-	mustBe(t, reflect.Struct)
-	nm := m.TypeMap(t)
-
 	r := make([][]int, 0, len(names))
-	for _, name := range names {
-		traversal, ok := nm[name]
-		if !ok {
+	m.TraversalsByNameFunc(t, names, func(_ int, i []int) error {
+		if i == nil {
 			r = append(r, []int{})
 		} else {
-			r = append(r, traversal)
+			r = append(r, i)
 		}
-	}
+
+		return nil
+	})
 	return r
 }
 
-// FieldByIndexes returns a value for a particular struct traversal.
+// TraversalsByNameFunc traverses the mapped names and calls fn with the index of
+// each name and the struct traversal represented by that name. Panics if t is not
+// a struct or Indirectable to a struct. Returns the first error returned by fn or nil.
+func (m *Mapper) TraversalsByNameFunc(t reflect.Type, names []string, fn func(int, []int) error) error {
+	t = Deref(t)
+	mustBe(t, reflect.Struct)
+	tm := m.TypeMap(t)
+	for i, name := range names {
+		fi, ok := tm.Names[name]
+		if !ok {
+			if err := fn(i, nil); err != nil {
+				return err
+			}
+		} else {
+			if err := fn(i, fi.Index); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// FieldByIndexes returns a value for the field given by the struct traversal
+// for the given value.
 func FieldByIndexes(v reflect.Value, indexes []int) reflect.Value {
 	for _, i := range indexes {
 		v = reflect.Indirect(v).Field(i)
-		// if this is a pointer, it's possible it is nil
+		// if this is a pointer and it's nil, allocate a new value and set it
 		if v.Kind() == reflect.Ptr && v.IsNil() {
 			alloc := reflect.New(Deref(v.Type()))
 			v.Set(alloc)
@@ -164,20 +238,19 @@ func Deref(t reflect.Type) reflect.Type {
 
 // -- helpers & utilities --
 
-type Kinder interface {
+type kinder interface {
 	Kind() reflect.Kind
 }
 
 // mustBe checks a value against a kind, panicing with a reflect.ValueError
 // if the kind isn't that which is required.
-func mustBe(v Kinder, expected reflect.Kind) {
-	k := v.Kind()
-	if k != expected {
+func mustBe(v kinder, expected reflect.Kind) {
+	if k := v.Kind(); k != expected {
 		panic(&reflect.ValueError{Method: methodName(), Kind: k})
 	}
 }
 
-// methodName is returns the caller of the function calling methodName
+// methodName returns the caller of the function calling methodName
 func methodName() string {
 	pc, _, _, _ := runtime.Caller(2)
 	f := runtime.FuncForPC(pc)
@@ -188,8 +261,9 @@ func methodName() string {
 }
 
 type typeQueue struct {
-	t reflect.Type
-	p []int
+	t  reflect.Type
+	fi *FieldInfo
+	pp string // Parent path
 }
 
 // A copying append that creates a new slice each time.
@@ -202,52 +276,166 @@ func apnd(is []int, i int) []int {
 	return x
 }
 
-// getMapping returns a mapping for the t type, using the tagName and the mapFunc
-// to determine the canonical names of fields.
-func getMapping(t reflect.Type, tagName string, mapFunc func(string) string) fieldMap {
+type mapf func(string) string
+
+// parseName parses the tag and the target name for the given field using
+// the tagName (eg 'json' for `json:"foo"` tags), mapFunc for mapping the
+// field's name to a target name, and tagMapFunc for mapping the tag to
+// a target name.
+func parseName(field reflect.StructField, tagName string, mapFunc, tagMapFunc mapf) (tag, fieldName string) {
+	// first, set the fieldName to the field's name
+	fieldName = field.Name
+	// if a mapFunc is set, use that to override the fieldName
+	if mapFunc != nil {
+		fieldName = mapFunc(fieldName)
+	}
+
+	// if there's no tag to look for, return the field name
+	if tagName == "" {
+		return "", fieldName
+	}
+
+	// if this tag is not set using the normal convention in the tag,
+	// then return the fieldname..  this check is done because according
+	// to the reflect documentation:
+	//    If the tag does not have the conventional format,
+	//    the value returned by Get is unspecified.
+	// which doesn't sound great.
+	if !strings.Contains(string(field.Tag), tagName+":") {
+		return "", fieldName
+	}
+
+	// at this point we're fairly sure that we have a tag, so lets pull it out
+	tag = field.Tag.Get(tagName)
+
+	// if we have a mapper function, call it on the whole tag
+	// XXX: this is a change from the old version, which pulled out the name
+	// before the tagMapFunc could be run, but I think this is the right way
+	if tagMapFunc != nil {
+		tag = tagMapFunc(tag)
+	}
+
+	// finally, split the options from the name
+	parts := strings.Split(tag, ",")
+	fieldName = parts[0]
+
+	return tag, fieldName
+}
+
+// parseOptions parses options out of a tag string, skipping the name
+func parseOptions(tag string) map[string]string {
+	parts := strings.Split(tag, ",")
+	options := make(map[string]string, len(parts))
+	if len(parts) > 1 {
+		for _, opt := range parts[1:] {
+			// short circuit potentially expensive split op
+			if strings.Contains(opt, "=") {
+				kv := strings.Split(opt, "=")
+				options[kv[0]] = kv[1]
+				continue
+			}
+			options[opt] = ""
+		}
+	}
+	return options
+}
+
+// getMapping returns a mapping for the t type, using the tagName, mapFunc and
+// tagMapFunc to determine the canonical names of fields.
+func getMapping(t reflect.Type, tagName string, mapFunc, tagMapFunc mapf) *StructMap {
+	m := []*FieldInfo{}
+
+	root := &FieldInfo{}
 	queue := []typeQueue{}
-	queue = append(queue, typeQueue{Deref(t), []int{}})
-	m := fieldMap{}
+	queue = append(queue, typeQueue{Deref(t), root, ""})
+
+QueueLoop:
 	for len(queue) != 0 {
 		// pop the first item off of the queue
 		tq := queue[0]
 		queue = queue[1:]
+
+		// ignore recursive field
+		for p := tq.fi.Parent; p != nil; p = p.Parent {
+			if tq.fi.Field.Type == p.Field.Type {
+				continue QueueLoop
+			}
+		}
+
+		nChildren := 0
+		if tq.t.Kind() == reflect.Struct {
+			nChildren = tq.t.NumField()
+		}
+		tq.fi.Children = make([]*FieldInfo, nChildren)
+
 		// iterate through all of its fields
-		for fieldPos := 0; fieldPos < tq.t.NumField(); fieldPos++ {
+		for fieldPos := 0; fieldPos < nChildren; fieldPos++ {
+
 			f := tq.t.Field(fieldPos)
 
-			name := f.Tag.Get(tagName)
-			if len(name) == 0 {
-				if mapFunc != nil {
-					name = mapFunc(f.Name)
-				} else {
-					name = f.Name
-				}
-			}
+			// parse the tag and the target name using the mapping options for this field
+			tag, name := parseName(f, tagName, mapFunc, tagMapFunc)
 
 			// if the name is "-", disabled via a tag, skip it
 			if name == "-" {
 				continue
 			}
 
+			fi := FieldInfo{
+				Field:   f,
+				Name:    name,
+				Zero:    reflect.New(f.Type).Elem(),
+				Options: parseOptions(tag),
+			}
+
+			// if the path is empty this path is just the name
+			if tq.pp == "" {
+				fi.Path = fi.Name
+			} else {
+				fi.Path = tq.pp + "." + fi.Name
+			}
+
 			// skip unexported fields
-			if len(f.PkgPath) != 0 {
+			if len(f.PkgPath) != 0 && !f.Anonymous {
 				continue
 			}
 
 			// bfs search of anonymous embedded structs
 			if f.Anonymous {
-				queue = append(queue, typeQueue{Deref(f.Type), apnd(tq.p, fieldPos)})
-				continue
+				pp := tq.pp
+				if tag != "" {
+					pp = fi.Path
+				}
+
+				fi.Embedded = true
+				fi.Index = apnd(tq.fi.Index, fieldPos)
+				nChildren := 0
+				ft := Deref(f.Type)
+				if ft.Kind() == reflect.Struct {
+					nChildren = ft.NumField()
+				}
+				fi.Children = make([]*FieldInfo, nChildren)
+				queue = append(queue, typeQueue{Deref(f.Type), &fi, pp})
+			} else if fi.Zero.Kind() == reflect.Struct || (fi.Zero.Kind() == reflect.Ptr && fi.Zero.Type().Elem().Kind() == reflect.Struct) {
+				fi.Index = apnd(tq.fi.Index, fieldPos)
+				fi.Children = make([]*FieldInfo, Deref(f.Type).NumField())
+				queue = append(queue, typeQueue{Deref(f.Type), &fi, fi.Path})
 			}
 
-			// if the name is shadowed by an earlier identical name in the search, skip it
-			if _, ok := m[name]; ok {
-				continue
-			}
-			// add it to the map at the current position
-			m[name] = apnd(tq.p, fieldPos)
+			fi.Index = apnd(tq.fi.Index, fieldPos)
+			fi.Parent = tq.fi
+			tq.fi.Children[fieldPos] = &fi
+			m = append(m, &fi)
 		}
 	}
-	return m
+
+	flds := &StructMap{Index: m, Tree: root, Paths: map[string]*FieldInfo{}, Names: map[string]*FieldInfo{}}
+	for _, fi := range flds.Index {
+		flds.Paths[fi.Path] = fi
+		if fi.Name != "" && !fi.Embedded {
+			flds.Names[fi.Path] = fi
+		}
+	}
+
+	return flds
 }