502 lines
12 KiB
Go
502 lines
12 KiB
Go
// Copyright 2013 The Go Authors. All rights reserved.
|
||
// Use of this source code is governed by a BSD-style
|
||
// license that can be found in the LICENSE file.
|
||
package yaml
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding"
|
||
"encoding/json"
|
||
"reflect"
|
||
"sort"
|
||
"strings"
|
||
"sync"
|
||
"unicode"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
// indirect walks down v allocating pointers as needed,
|
||
// until it gets to a non-pointer.
|
||
// if it encounters an Unmarshaler, indirect stops and returns that.
|
||
// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
|
||
func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
|
||
// If v is a named type and is addressable,
|
||
// start with its address, so that if the type has pointer methods,
|
||
// we find them.
|
||
if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
|
||
v = v.Addr()
|
||
}
|
||
for {
|
||
// Load value from interface, but only if the result will be
|
||
// usefully addressable.
|
||
if v.Kind() == reflect.Interface && !v.IsNil() {
|
||
e := v.Elem()
|
||
if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
|
||
v = e
|
||
continue
|
||
}
|
||
}
|
||
|
||
if v.Kind() != reflect.Ptr {
|
||
break
|
||
}
|
||
|
||
if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
|
||
break
|
||
}
|
||
if v.IsNil() {
|
||
if v.CanSet() {
|
||
v.Set(reflect.New(v.Type().Elem()))
|
||
} else {
|
||
v = reflect.New(v.Type().Elem())
|
||
}
|
||
}
|
||
if v.Type().NumMethod() > 0 {
|
||
if u, ok := v.Interface().(json.Unmarshaler); ok {
|
||
return u, nil, reflect.Value{}
|
||
}
|
||
if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
|
||
return nil, u, reflect.Value{}
|
||
}
|
||
}
|
||
v = v.Elem()
|
||
}
|
||
return nil, nil, v
|
||
}
|
||
|
||
// A field represents a single field found in a struct.
|
||
type field struct {
|
||
name string
|
||
nameBytes []byte // []byte(name)
|
||
equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent
|
||
|
||
tag bool
|
||
index []int
|
||
typ reflect.Type
|
||
omitEmpty bool
|
||
quoted bool
|
||
}
|
||
|
||
func fillField(f field) field {
|
||
f.nameBytes = []byte(f.name)
|
||
f.equalFold = foldFunc(f.nameBytes)
|
||
return f
|
||
}
|
||
|
||
// byName sorts field by name, breaking ties with depth,
|
||
// then breaking ties with "name came from json tag", then
|
||
// breaking ties with index sequence.
|
||
type byName []field
|
||
|
||
func (x byName) Len() int { return len(x) }
|
||
|
||
func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
||
|
||
func (x byName) Less(i, j int) bool {
|
||
if x[i].name != x[j].name {
|
||
return x[i].name < x[j].name
|
||
}
|
||
if len(x[i].index) != len(x[j].index) {
|
||
return len(x[i].index) < len(x[j].index)
|
||
}
|
||
if x[i].tag != x[j].tag {
|
||
return x[i].tag
|
||
}
|
||
return byIndex(x).Less(i, j)
|
||
}
|
||
|
||
// byIndex sorts field by index sequence.
|
||
type byIndex []field
|
||
|
||
func (x byIndex) Len() int { return len(x) }
|
||
|
||
func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
||
|
||
func (x byIndex) Less(i, j int) bool {
|
||
for k, xik := range x[i].index {
|
||
if k >= len(x[j].index) {
|
||
return false
|
||
}
|
||
if xik != x[j].index[k] {
|
||
return xik < x[j].index[k]
|
||
}
|
||
}
|
||
return len(x[i].index) < len(x[j].index)
|
||
}
|
||
|
||
// typeFields returns a list of fields that JSON should recognize for the given type.
|
||
// The algorithm is breadth-first search over the set of structs to include - the top struct
|
||
// and then any reachable anonymous structs.
|
||
func typeFields(t reflect.Type) []field {
|
||
// Anonymous fields to explore at the current level and the next.
|
||
current := []field{}
|
||
next := []field{{typ: t}}
|
||
|
||
// Count of queued names for current level and the next.
|
||
count := map[reflect.Type]int{}
|
||
nextCount := map[reflect.Type]int{}
|
||
|
||
// Types already visited at an earlier level.
|
||
visited := map[reflect.Type]bool{}
|
||
|
||
// Fields found.
|
||
var fields []field
|
||
|
||
for len(next) > 0 {
|
||
current, next = next, current[:0]
|
||
count, nextCount = nextCount, map[reflect.Type]int{}
|
||
|
||
for _, f := range current {
|
||
if visited[f.typ] {
|
||
continue
|
||
}
|
||
visited[f.typ] = true
|
||
|
||
// Scan f.typ for fields to include.
|
||
for i := 0; i < f.typ.NumField(); i++ {
|
||
sf := f.typ.Field(i)
|
||
if sf.PkgPath != "" { // unexported
|
||
continue
|
||
}
|
||
tag := sf.Tag.Get("json")
|
||
if tag == "-" {
|
||
continue
|
||
}
|
||
name, opts := parseTag(tag)
|
||
if !isValidTag(name) {
|
||
name = ""
|
||
}
|
||
index := make([]int, len(f.index)+1)
|
||
copy(index, f.index)
|
||
index[len(f.index)] = i
|
||
|
||
ft := sf.Type
|
||
if ft.Name() == "" && ft.Kind() == reflect.Ptr {
|
||
// Follow pointer.
|
||
ft = ft.Elem()
|
||
}
|
||
|
||
// Record found field and index sequence.
|
||
if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
|
||
tagged := name != ""
|
||
if name == "" {
|
||
name = sf.Name
|
||
}
|
||
fields = append(fields, fillField(field{
|
||
name: name,
|
||
tag: tagged,
|
||
index: index,
|
||
typ: ft,
|
||
omitEmpty: opts.Contains("omitempty"),
|
||
quoted: opts.Contains("string"),
|
||
}))
|
||
if count[f.typ] > 1 {
|
||
// If there were multiple instances, add a second,
|
||
// so that the annihilation code will see a duplicate.
|
||
// It only cares about the distinction between 1 or 2,
|
||
// so don't bother generating any more copies.
|
||
fields = append(fields, fields[len(fields)-1])
|
||
}
|
||
continue
|
||
}
|
||
|
||
// Record new anonymous struct to explore in next round.
|
||
nextCount[ft]++
|
||
if nextCount[ft] == 1 {
|
||
next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
sort.Sort(byName(fields))
|
||
|
||
// Delete all fields that are hidden by the Go rules for embedded fields,
|
||
// except that fields with JSON tags are promoted.
|
||
|
||
// The fields are sorted in primary order of name, secondary order
|
||
// of field index length. Loop over names; for each name, delete
|
||
// hidden fields by choosing the one dominant field that survives.
|
||
out := fields[:0]
|
||
for advance, i := 0, 0; i < len(fields); i += advance {
|
||
// One iteration per name.
|
||
// Find the sequence of fields with the name of this first field.
|
||
fi := fields[i]
|
||
name := fi.name
|
||
for advance = 1; i+advance < len(fields); advance++ {
|
||
fj := fields[i+advance]
|
||
if fj.name != name {
|
||
break
|
||
}
|
||
}
|
||
if advance == 1 { // Only one field with this name
|
||
out = append(out, fi)
|
||
continue
|
||
}
|
||
dominant, ok := dominantField(fields[i : i+advance])
|
||
if ok {
|
||
out = append(out, dominant)
|
||
}
|
||
}
|
||
|
||
fields = out
|
||
sort.Sort(byIndex(fields))
|
||
|
||
return fields
|
||
}
|
||
|
||
// dominantField looks through the fields, all of which are known to
|
||
// have the same name, to find the single field that dominates the
|
||
// others using Go's embedding rules, modified by the presence of
|
||
// JSON tags. If there are multiple top-level fields, the boolean
|
||
// will be false: This condition is an error in Go and we skip all
|
||
// the fields.
|
||
func dominantField(fields []field) (field, bool) {
|
||
// The fields are sorted in increasing index-length order. The winner
|
||
// must therefore be one with the shortest index length. Drop all
|
||
// longer entries, which is easy: just truncate the slice.
|
||
length := len(fields[0].index)
|
||
tagged := -1 // Index of first tagged field.
|
||
for i, f := range fields {
|
||
if len(f.index) > length {
|
||
fields = fields[:i]
|
||
break
|
||
}
|
||
if f.tag {
|
||
if tagged >= 0 {
|
||
// Multiple tagged fields at the same level: conflict.
|
||
// Return no field.
|
||
return field{}, false
|
||
}
|
||
tagged = i
|
||
}
|
||
}
|
||
if tagged >= 0 {
|
||
return fields[tagged], true
|
||
}
|
||
// All remaining fields have the same length. If there's more than one,
|
||
// we have a conflict (two fields named "X" at the same level) and we
|
||
// return no field.
|
||
if len(fields) > 1 {
|
||
return field{}, false
|
||
}
|
||
return fields[0], true
|
||
}
|
||
|
||
var fieldCache struct {
|
||
sync.RWMutex
|
||
m map[reflect.Type][]field
|
||
}
|
||
|
||
// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
|
||
func cachedTypeFields(t reflect.Type) []field {
|
||
fieldCache.RLock()
|
||
f := fieldCache.m[t]
|
||
fieldCache.RUnlock()
|
||
if f != nil {
|
||
return f
|
||
}
|
||
|
||
// Compute fields without lock.
|
||
// Might duplicate effort but won't hold other computations back.
|
||
f = typeFields(t)
|
||
if f == nil {
|
||
f = []field{}
|
||
}
|
||
|
||
fieldCache.Lock()
|
||
if fieldCache.m == nil {
|
||
fieldCache.m = map[reflect.Type][]field{}
|
||
}
|
||
fieldCache.m[t] = f
|
||
fieldCache.Unlock()
|
||
return f
|
||
}
|
||
|
||
func isValidTag(s string) bool {
|
||
if s == "" {
|
||
return false
|
||
}
|
||
for _, c := range s {
|
||
switch {
|
||
case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
|
||
// Backslash and quote chars are reserved, but
|
||
// otherwise any punctuation chars are allowed
|
||
// in a tag name.
|
||
default:
|
||
if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
|
||
return false
|
||
}
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
const (
|
||
caseMask = ^byte(0x20) // Mask to ignore case in ASCII.
|
||
kelvin = '\u212a'
|
||
smallLongEss = '\u017f'
|
||
)
|
||
|
||
// foldFunc returns one of four different case folding equivalence
|
||
// functions, from most general (and slow) to fastest:
|
||
//
|
||
// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8
|
||
// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')
|
||
// 3) asciiEqualFold, no special, but includes non-letters (including _)
|
||
// 4) simpleLetterEqualFold, no specials, no non-letters.
|
||
//
|
||
// The letters S and K are special because they map to 3 runes, not just 2:
|
||
// * S maps to s and to U+017F 'ſ' Latin small letter long s
|
||
// * k maps to K and to U+212A 'K' Kelvin sign
|
||
// See http://play.golang.org/p/tTxjOc0OGo
|
||
//
|
||
// The returned function is specialized for matching against s and
|
||
// should only be given s. It's not curried for performance reasons.
|
||
func foldFunc(s []byte) func(s, t []byte) bool {
|
||
nonLetter := false
|
||
special := false // special letter
|
||
for _, b := range s {
|
||
if b >= utf8.RuneSelf {
|
||
return bytes.EqualFold
|
||
}
|
||
upper := b & caseMask
|
||
if upper < 'A' || upper > 'Z' {
|
||
nonLetter = true
|
||
} else if upper == 'K' || upper == 'S' {
|
||
// See above for why these letters are special.
|
||
special = true
|
||
}
|
||
}
|
||
if special {
|
||
return equalFoldRight
|
||
}
|
||
if nonLetter {
|
||
return asciiEqualFold
|
||
}
|
||
return simpleLetterEqualFold
|
||
}
|
||
|
||
// equalFoldRight is a specialization of bytes.EqualFold when s is
|
||
// known to be all ASCII (including punctuation), but contains an 's',
|
||
// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.
|
||
// See comments on foldFunc.
|
||
func equalFoldRight(s, t []byte) bool {
|
||
for _, sb := range s {
|
||
if len(t) == 0 {
|
||
return false
|
||
}
|
||
tb := t[0]
|
||
if tb < utf8.RuneSelf {
|
||
if sb != tb {
|
||
sbUpper := sb & caseMask
|
||
if 'A' <= sbUpper && sbUpper <= 'Z' {
|
||
if sbUpper != tb&caseMask {
|
||
return false
|
||
}
|
||
} else {
|
||
return false
|
||
}
|
||
}
|
||
t = t[1:]
|
||
continue
|
||
}
|
||
// sb is ASCII and t is not. t must be either kelvin
|
||
// sign or long s; sb must be s, S, k, or K.
|
||
tr, size := utf8.DecodeRune(t)
|
||
switch sb {
|
||
case 's', 'S':
|
||
if tr != smallLongEss {
|
||
return false
|
||
}
|
||
case 'k', 'K':
|
||
if tr != kelvin {
|
||
return false
|
||
}
|
||
default:
|
||
return false
|
||
}
|
||
t = t[size:]
|
||
|
||
}
|
||
if len(t) > 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// asciiEqualFold is a specialization of bytes.EqualFold for use when
|
||
// s is all ASCII (but may contain non-letters) and contains no
|
||
// special-folding letters.
|
||
// See comments on foldFunc.
|
||
func asciiEqualFold(s, t []byte) bool {
|
||
if len(s) != len(t) {
|
||
return false
|
||
}
|
||
for i, sb := range s {
|
||
tb := t[i]
|
||
if sb == tb {
|
||
continue
|
||
}
|
||
if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {
|
||
if sb&caseMask != tb&caseMask {
|
||
return false
|
||
}
|
||
} else {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// simpleLetterEqualFold is a specialization of bytes.EqualFold for
|
||
// use when s is all ASCII letters (no underscores, etc) and also
|
||
// doesn't contain 'k', 'K', 's', or 'S'.
|
||
// See comments on foldFunc.
|
||
func simpleLetterEqualFold(s, t []byte) bool {
|
||
if len(s) != len(t) {
|
||
return false
|
||
}
|
||
for i, b := range s {
|
||
if b&caseMask != t[i]&caseMask {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// tagOptions is the string following a comma in a struct field's "json"
|
||
// tag, or the empty string. It does not include the leading comma.
|
||
type tagOptions string
|
||
|
||
// parseTag splits a struct field's json tag into its name and
|
||
// comma-separated options.
|
||
func parseTag(tag string) (string, tagOptions) {
|
||
if idx := strings.Index(tag, ","); idx != -1 {
|
||
return tag[:idx], tagOptions(tag[idx+1:])
|
||
}
|
||
return tag, tagOptions("")
|
||
}
|
||
|
||
// Contains reports whether a comma-separated list of options
|
||
// contains a particular substr flag. substr must be surrounded by a
|
||
// string boundary or commas.
|
||
func (o tagOptions) Contains(optionName string) bool {
|
||
if len(o) == 0 {
|
||
return false
|
||
}
|
||
s := string(o)
|
||
for s != "" {
|
||
var next string
|
||
i := strings.Index(s, ",")
|
||
if i >= 0 {
|
||
s, next = s[:i], s[i+1:]
|
||
}
|
||
if s == optionName {
|
||
return true
|
||
}
|
||
s = next
|
||
}
|
||
return false
|
||
}
|