vendor update

vendor/github.com/pelletier/go-buffruneio/buffruneio.go

@@ -31,13 +31,8 @@ func NewReader(rd io.Reader) *Reader {
 	}
 }
 
-type runeWithSize struct {
-	r    rune
-	size int
-}
-
 func (rd *Reader) feedBuffer() error {
-	r, size, err := rd.input.ReadRune()
+	r, _, err := rd.input.ReadRune()
 
 	if err != nil {
 		if err != io.EOF {
@@ -46,9 +41,7 @@ func (rd *Reader) feedBuffer() error {
 		r = EOF
 	}
 
-	newRuneWithSize := runeWithSize{r, size}
-
-	rd.buffer.PushBack(newRuneWithSize)
+	rd.buffer.PushBack(r)
 	if rd.current == nil {
 		rd.current = rd.buffer.Back()
 	}
@@ -56,17 +49,17 @@ func (rd *Reader) feedBuffer() error {
 }
 
 // ReadRune reads the next rune from buffer, or from the underlying reader if needed.
-func (rd *Reader) ReadRune() (rune, int, error) {
+func (rd *Reader) ReadRune() (rune, error) {
 	if rd.current == rd.buffer.Back() || rd.current == nil {
 		err := rd.feedBuffer()
 		if err != nil {
-			return EOF, 0, err
+			return EOF, err
 		}
 	}
 
-	runeWithSize := rd.current.Value.(runeWithSize)
+	r := rd.current.Value
 	rd.current = rd.current.Next()
-	return runeWithSize.r, runeWithSize.size, nil
+	return r.(rune), nil
 }
 
 // UnreadRune pushes back the previously read rune in the buffer, extending it if needed.
@@ -91,9 +84,9 @@ func (rd *Reader) Forget() {
 	}
 }
 
-// PeekRune returns at most the next n runes, reading from the uderlying source if
+// Peek returns at most the next n runes, reading from the uderlying source if
 // needed. Does not move the current index. It includes EOF if reached.
-func (rd *Reader) PeekRunes(n int) []rune {
+func (rd *Reader) Peek(n int) []rune {
 	res := make([]rune, 0, n)
 	cursor := rd.current
 	for i := 0; i < n; i++ {
@@ -105,7 +98,7 @@ func (rd *Reader) PeekRunes(n int) []rune {
 			cursor = rd.buffer.Back()
 		}
 		if cursor != nil {
-			r := cursor.Value.(runeWithSize).r
+			r := cursor.Value.(rune)
 			res = append(res, r)
 			if r == EOF {
 				return res

vendor/github.com/pelletier/go-toml/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 - 2017 Thomas Pelletier, Eric Anderton
-
-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.

vendor/github.com/pelletier/go-toml/doc.go

@@ -22,8 +22,8 @@
 // After parsing TOML data with Load() or LoadFile(), use the Has() and Get()
 // methods on the returned TomlTree, to find your way through the document data.
 //
-//   if tree.Has("foo") {
-//     fmt.Println("foo is:", tree.Get("foo"))
+//   if tree.Has('foo') {
+//     fmt.Prinln("foo is: %v", tree.Get('foo'))
 //   }
 //
 // Working with Paths
@@ -44,10 +44,10 @@
 // it avoids having to parse the passed key for '.' delimiters.
 //
 //   // looks for a key named 'baz', within struct 'bar', within struct 'foo'
-//   tree.HasPath([]string{"foo","bar","baz"})
+//   tree.HasPath(string{}{"foo","bar","baz"})
 //
 //   // returns the key at this path, if it is there
-//   tree.GetPath([]string{"foo","bar","baz"})
+//   tree.GetPath(string{}{"foo","bar","baz"})
 //
 // Note that this is distinct from the heavyweight query syntax supported by
 // TomlTree.Query() and the Query() struct (see below).

vendor/github.com/pelletier/go-toml/keysparsing.go

@@ -4,7 +4,6 @@ package toml
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"unicode"
 )
@@ -13,7 +12,6 @@ func parseKey(key string) ([]string, error) {
 	groups := []string{}
 	var buffer bytes.Buffer
 	inQuotes := false
-	wasInQuotes := false
 	escapeNext := false
 	ignoreSpace := true
 	expectDot := false
@@ -35,27 +33,16 @@ func parseKey(key string) ([]string, error) {
 			escapeNext = true
 			continue
 		case '"':
-			if inQuotes {
-				groups = append(groups, buffer.String())
-				buffer.Reset()
-				wasInQuotes = true
-			}
 			inQuotes = !inQuotes
 			expectDot = false
 		case '.':
 			if inQuotes {
 				buffer.WriteRune(char)
 			} else {
-				if !wasInQuotes {
-					if buffer.Len() == 0 {
-						return nil, errors.New("empty table key")
-					}
-					groups = append(groups, buffer.String())
-					buffer.Reset()
-				}
+				groups = append(groups, buffer.String())
+				buffer.Reset()
 				ignoreSpace = true
 				expectDot = false
-				wasInQuotes = false
 			}
 		case ' ':
 			if inQuotes {
@@ -68,23 +55,23 @@ func parseKey(key string) ([]string, error) {
 				return nil, fmt.Errorf("invalid bare character: %c", char)
 			}
 			if !inQuotes && expectDot {
-				return nil, errors.New("what?")
+				return nil, fmt.Errorf("what?")
 			}
 			buffer.WriteRune(char)
 			expectDot = false
 		}
 	}
 	if inQuotes {
-		return nil, errors.New("mismatched quotes")
+		return nil, fmt.Errorf("mismatched quotes")
 	}
 	if escapeNext {
-		return nil, errors.New("unfinished escape sequence")
+		return nil, fmt.Errorf("unfinished escape sequence")
 	}
 	if buffer.Len() > 0 {
 		groups = append(groups, buffer.String())
 	}
 	if len(groups) == 0 {
-		return nil, errors.New("empty key")
+		return nil, fmt.Errorf("empty key")
 	}
 	return groups, nil
 }

vendor/github.com/pelletier/go-toml/lexer.go

@@ -1,6 +1,6 @@
 // TOML lexer.
 //
-// Written using the principles developed by Rob Pike in
+// Written using the principles developped by Rob Pike in
 // http://www.youtube.com/watch?v=HxaD_trXwRE
 
 package toml
@@ -36,7 +36,7 @@ type tomlLexer struct {
 // Basic read operations on input
 
 func (l *tomlLexer) read() rune {
-	r, _, err := l.input.ReadRune()
+	r, err := l.input.ReadRune()
 	if err != nil {
 		panic(err)
 	}
@@ -89,7 +89,7 @@ func (l *tomlLexer) emit(t tokenType) {
 }
 
 func (l *tomlLexer) peek() rune {
-	r, _, err := l.input.ReadRune()
+	r, err := l.input.ReadRune()
 	if err != nil {
 		panic(err)
 	}
@@ -99,7 +99,7 @@ func (l *tomlLexer) peek() rune {
 
 func (l *tomlLexer) follow(next string) bool {
 	for _, expectedRune := range next {
-		r, _, err := l.input.ReadRune()
+		r, err := l.input.ReadRune()
 		defer l.input.UnreadRune()
 		if err != nil {
 			panic(err)
@@ -129,9 +129,9 @@ func (l *tomlLexer) lexVoid() tomlLexStateFn {
 		next := l.peek()
 		switch next {
 		case '[':
-			return l.lexTableKey
+			return l.lexKeyGroup
 		case '#':
-			return l.lexComment(l.lexVoid)
+			return l.lexComment
 		case '=':
 			return l.lexEqual
 		case '\r':
@@ -182,7 +182,7 @@ func (l *tomlLexer) lexRvalue() tomlLexStateFn {
 		case '}':
 			return l.lexRightCurlyBrace
 		case '#':
-			return l.lexComment(l.lexRvalue)
+			return l.lexComment
 		case '"':
 			return l.lexString
 		case '\'':
@@ -219,7 +219,7 @@ func (l *tomlLexer) lexRvalue() tomlLexStateFn {
 			break
 		}
 
-		possibleDate := string(l.input.PeekRunes(35))
+		possibleDate := string(l.input.Peek(35))
 		dateMatch := dateRegexp.FindString(possibleDate)
 		if dateMatch != "" {
 			l.fastForward(len(dateMatch))
@@ -309,17 +309,15 @@ func (l *tomlLexer) lexKey() tomlLexStateFn {
 	return l.lexVoid
 }
 
-func (l *tomlLexer) lexComment(previousState tomlLexStateFn) tomlLexStateFn {
-	return func() tomlLexStateFn {
-		for next := l.peek(); next != '\n' && next != eof; next = l.peek() {
-			if next == '\r' && l.follow("\r\n") {
-				break
-			}
-			l.next()
+func (l *tomlLexer) lexComment() tomlLexStateFn {
+	for next := l.peek(); next != '\n' && next != eof; next = l.peek() {
+		if next == '\r' && l.follow("\r\n") {
+			break
 		}
-		l.ignore()
-		return previousState
+		l.next()
 	}
+	l.ignore()
+	return l.lexVoid
 }
 
 func (l *tomlLexer) lexLeftBracket() tomlLexStateFn {
@@ -518,21 +516,21 @@ func (l *tomlLexer) lexString() tomlLexStateFn {
 	return l.lexRvalue
 }
 
-func (l *tomlLexer) lexTableKey() tomlLexStateFn {
+func (l *tomlLexer) lexKeyGroup() tomlLexStateFn {
 	l.next()
 
 	if l.peek() == '[' {
-		// token '[[' signifies an array of tables
+		// token '[[' signifies an array of anonymous key groups
 		l.next()
 		l.emit(tokenDoubleLeftBracket)
-		return l.lexInsideTableArrayKey
+		return l.lexInsideKeyGroupArray
 	}
-	// vanilla table key
+	// vanilla key group
 	l.emit(tokenLeftBracket)
-	return l.lexInsideTableKey
+	return l.lexInsideKeyGroup
 }
 
-func (l *tomlLexer) lexInsideTableArrayKey() tomlLexStateFn {
+func (l *tomlLexer) lexInsideKeyGroupArray() tomlLexStateFn {
 	for r := l.peek(); r != eof; r = l.peek() {
 		switch r {
 		case ']':
@@ -547,15 +545,15 @@ func (l *tomlLexer) lexInsideTableArrayKey() tomlLexStateFn {
 			l.emit(tokenDoubleRightBracket)
 			return l.lexVoid
 		case '[':
-			return l.errorf("table array key cannot contain ']'")
+			return l.errorf("group name cannot contain ']'")
 		default:
 			l.next()
 		}
 	}
-	return l.errorf("unclosed table array key")
+	return l.errorf("unclosed key group array")
 }
 
-func (l *tomlLexer) lexInsideTableKey() tomlLexStateFn {
+func (l *tomlLexer) lexInsideKeyGroup() tomlLexStateFn {
 	for r := l.peek(); r != eof; r = l.peek() {
 		switch r {
 		case ']':
@@ -566,12 +564,12 @@ func (l *tomlLexer) lexInsideTableKey() tomlLexStateFn {
 			l.emit(tokenRightBracket)
 			return l.lexVoid
 		case '[':
-			return l.errorf("table key cannot contain ']'")
+			return l.errorf("group name cannot contain ']'")
 		default:
 			l.next()
 		}
 	}
-	return l.errorf("unclosed table key")
+	return l.errorf("unclosed key group")
 }
 
 func (l *tomlLexer) lexRightBracket() tomlLexStateFn {

vendor/github.com/pelletier/go-toml/parser.go

@@ -3,7 +3,6 @@
 package toml
 
 import (
-	"errors"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -16,8 +15,8 @@ type tomlParser struct {
 	flow          chan token
 	tree          *TomlTree
 	tokensBuffer  []token
-	currentTable  []string
-	seenTableKeys []string
+	currentGroup  []string
+	seenGroupKeys []string
 }
 
 type tomlParserStateFn func() tomlParserStateFn
@@ -96,13 +95,13 @@ func (p *tomlParser) parseGroupArray() tomlParserStateFn {
 	startToken := p.getToken() // discard the [[
 	key := p.getToken()
 	if key.typ != tokenKeyGroupArray {
-		p.raiseError(key, "unexpected token %s, was expecting a table array key", key)
+		p.raiseError(key, "unexpected token %s, was expecting a key group array", key)
 	}
 
-	// get or create table array element at the indicated part in the path
+	// get or create group array element at the indicated part in the path
 	keys, err := parseKey(key.val)
 	if err != nil {
-		p.raiseError(key, "invalid table array key: %s", err)
+		p.raiseError(key, "invalid group array key: %s", err)
 	}
 	p.tree.createSubTree(keys[:len(keys)-1], startToken.Position) // create parent entries
 	destTree := p.tree.GetPath(keys)
@@ -112,32 +111,32 @@ func (p *tomlParser) parseGroupArray() tomlParserStateFn {
 	} else if target, ok := destTree.([]*TomlTree); ok && target != nil {
 		array = destTree.([]*TomlTree)
 	} else {
-		p.raiseError(key, "key %s is already assigned and not of type table array", key)
+		p.raiseError(key, "key %s is already assigned and not of type group array", key)
 	}
-	p.currentTable = keys
+	p.currentGroup = keys
 
-	// add a new tree to the end of the table array
+	// add a new tree to the end of the group array
 	newTree := newTomlTree()
 	newTree.position = startToken.Position
 	array = append(array, newTree)
-	p.tree.SetPath(p.currentTable, array)
+	p.tree.SetPath(p.currentGroup, array)
 
-	// remove all keys that were children of this table array
+	// remove all keys that were children of this group array
 	prefix := key.val + "."
 	found := false
-	for ii := 0; ii < len(p.seenTableKeys); {
-		tableKey := p.seenTableKeys[ii]
-		if strings.HasPrefix(tableKey, prefix) {
-			p.seenTableKeys = append(p.seenTableKeys[:ii], p.seenTableKeys[ii+1:]...)
+	for ii := 0; ii < len(p.seenGroupKeys); {
+		groupKey := p.seenGroupKeys[ii]
+		if strings.HasPrefix(groupKey, prefix) {
+			p.seenGroupKeys = append(p.seenGroupKeys[:ii], p.seenGroupKeys[ii+1:]...)
 		} else {
-			found = (tableKey == key.val)
+			found = (groupKey == key.val)
 			ii++
 		}
 	}
 
 	// keep this key name from use by other kinds of assignments
 	if !found {
-		p.seenTableKeys = append(p.seenTableKeys, key.val)
+		p.seenGroupKeys = append(p.seenGroupKeys, key.val)
 	}
 
 	// move to next parser state
@@ -149,24 +148,24 @@ func (p *tomlParser) parseGroup() tomlParserStateFn {
 	startToken := p.getToken() // discard the [
 	key := p.getToken()
 	if key.typ != tokenKeyGroup {
-		p.raiseError(key, "unexpected token %s, was expecting a table key", key)
+		p.raiseError(key, "unexpected token %s, was expecting a key group", key)
 	}
-	for _, item := range p.seenTableKeys {
+	for _, item := range p.seenGroupKeys {
 		if item == key.val {
 			p.raiseError(key, "duplicated tables")
 		}
 	}
 
-	p.seenTableKeys = append(p.seenTableKeys, key.val)
+	p.seenGroupKeys = append(p.seenGroupKeys, key.val)
 	keys, err := parseKey(key.val)
 	if err != nil {
-		p.raiseError(key, "invalid table array key: %s", err)
+		p.raiseError(key, "invalid group array key: %s", err)
 	}
 	if err := p.tree.createSubTree(keys, startToken.Position); err != nil {
 		p.raiseError(key, "%s", err)
 	}
 	p.assume(tokenRightBracket)
-	p.currentTable = keys
+	p.currentGroup = keys
 	return p.parseStart
 }
 
@@ -175,26 +174,26 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 	p.assume(tokenEqual)
 
 	value := p.parseRvalue()
-	var tableKey []string
-	if len(p.currentTable) > 0 {
-		tableKey = p.currentTable
+	var groupKey []string
+	if len(p.currentGroup) > 0 {
+		groupKey = p.currentGroup
 	} else {
-		tableKey = []string{}
+		groupKey = []string{}
 	}
 
-	// find the table to assign, looking out for arrays of tables
+	// find the group to assign, looking out for arrays of groups
 	var targetNode *TomlTree
-	switch node := p.tree.GetPath(tableKey).(type) {
+	switch node := p.tree.GetPath(groupKey).(type) {
 	case []*TomlTree:
 		targetNode = node[len(node)-1]
 	case *TomlTree:
 		targetNode = node
 	default:
-		p.raiseError(key, "Unknown table type for path: %s",
-			strings.Join(tableKey, "."))
+		p.raiseError(key, "Unknown group type for path: %s",
+			strings.Join(groupKey, "."))
 	}
 
-	// assign value to the found table
+	// assign value to the found group
 	keyVals, err := parseKey(key.val)
 	if err != nil {
 		p.raiseError(key, "%s", err)
@@ -204,7 +203,7 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 	}
 	keyVal := keyVals[0]
 	localKey := []string{keyVal}
-	finalKey := append(tableKey, keyVal)
+	finalKey := append(groupKey, keyVal)
 	if targetNode.GetPath(localKey) != nil {
 		p.raiseError(key, "The following key was defined twice: %s",
 			strings.Join(finalKey, "."))
@@ -212,7 +211,7 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 	var toInsert interface{}
 
 	switch value.(type) {
-	case *TomlTree, []*TomlTree:
+	case *TomlTree:
 		toInsert = value
 	default:
 		toInsert = &tomlValue{value, key.Position}
@@ -225,7 +224,7 @@ var numberUnderscoreInvalidRegexp *regexp.Regexp
 
 func cleanupNumberToken(value string) (string, error) {
 	if numberUnderscoreInvalidRegexp.MatchString(value) {
-		return "", errors.New("invalid use of _ in number")
+		return "", fmt.Errorf("invalid use of _ in number")
 	}
 	cleanedVal := strings.Replace(value, "_", "", -1)
 	return cleanedVal, nil
@@ -381,8 +380,8 @@ func parseToml(flow chan token) *TomlTree {
 		flow:          flow,
 		tree:          result,
 		tokensBuffer:  make([]token, 0),
-		currentTable:  make([]string, 0),
-		seenTableKeys: make([]string, 0),
+		currentGroup:  make([]string, 0),
+		seenGroupKeys: make([]string, 0),
 	}
 	parser.run()
 	return result

vendor/github.com/pelletier/go-toml/position.go

@@ -18,12 +18,12 @@ type Position struct {
 
 // String representation of the position.
 // Displays 1-indexed line and column numbers.
-func (p Position) String() string {
+func (p *Position) String() string {
 	return fmt.Sprintf("(%d, %d)", p.Line, p.Col)
 }
 
 // Invalid returns whether or not the position is valid (i.e. with negative or
 // null values)
-func (p Position) Invalid() bool {
+func (p *Position) Invalid() bool {
 	return p.Line <= 0 || p.Col <= 0
 }

vendor/github.com/pelletier/go-toml/query.go

@@ -30,7 +30,7 @@ func (r *QueryResult) appendResult(node interface{}, pos Position) {
 // Values is a set of values within a QueryResult.  The order of values is not
 // guaranteed to be in document order, and may be different each time a query is
 // executed.
-func (r QueryResult) Values() []interface{} {
+func (r *QueryResult) Values() []interface{} {
 	values := make([]interface{}, len(r.items))
 	for i, v := range r.items {
 		o, ok := v.(*tomlValue)
@@ -45,7 +45,7 @@ func (r QueryResult) Values() []interface{} {
 
 // Positions is a set of positions for values within a QueryResult.  Each index
 // in Positions() corresponds to the entry in Value() of the same index.
-func (r QueryResult) Positions() []Position {
+func (r *QueryResult) Positions() []Position {
 	return r.positions
 }
 

vendor/github.com/pelletier/go-toml/querylexer.go

@@ -272,23 +272,6 @@ func (l *queryLexer) lexString() queryLexStateFn {
 				return l.errorf("invalid unicode escape: \\u" + code)
 			}
 			growingString += string(rune(intcode))
-		} else if l.follow("\\U") {
-			l.pos += 2
-			code := ""
-			for i := 0; i < 8; i++ {
-				c := l.peek()
-				l.pos++
-				if !isHexDigit(c) {
-					return l.errorf("unfinished unicode escape")
-				}
-				code = code + string(c)
-			}
-			l.pos--
-			intcode, err := strconv.ParseInt(code, 16, 32)
-			if err != nil {
-				return l.errorf("invalid unicode escape: \\u" + code)
-			}
-			growingString += string(rune(intcode))
 		} else if l.follow("\\") {
 			l.pos++
 			return l.errorf("invalid escape sequence: \\" + string(l.peek()))

vendor/github.com/pelletier/go-toml/token.go

@@ -135,6 +135,5 @@ func isDigit(r rune) bool {
 
 func isHexDigit(r rune) bool {
 	return isDigit(r) ||
-		(r >= 'a' && r <= 'f') ||
-		(r >= 'A' && r <= 'F')
+		r == 'A' || r == 'B' || r == 'C' || r == 'D' || r == 'E' || r == 'F'
 }

vendor/github.com/pelletier/go-toml/toml.go

@@ -10,13 +10,13 @@ import (
 )
 
 type tomlValue struct {
-	value    interface{} // string, int64, uint64, float64, bool, time.Time, [] of any of this list
+	value    interface{}
 	position Position
 }
 
 // TomlTree is the result of the parsing of a TOML file.
 type TomlTree struct {
-	values   map[string]interface{} // string -> *tomlValue, *TomlTree, []*TomlTree
+	values   map[string]interface{}
 	position Position
 }
 
@@ -28,12 +28,10 @@ func newTomlTree() *TomlTree {
 }
 
 // TreeFromMap initializes a new TomlTree object using the given map.
-func TreeFromMap(m map[string]interface{}) (*TomlTree, error) {
-	result, err := toTree(m)
-	if err != nil {
-		return nil, err
+func TreeFromMap(m map[string]interface{}) *TomlTree {
+	return &TomlTree{
+		values: m,
 	}
-	return result.(*TomlTree), nil
 }
 
 // Has returns a boolean indicating if the given key exists.
@@ -224,6 +222,9 @@ func (t *TomlTree) SetPath(keys []string, value interface{}) {
 func (t *TomlTree) createSubTree(keys []string, pos Position) error {
 	subtree := t
 	for _, intermediateKey := range keys {
+		if intermediateKey == "" {
+			return fmt.Errorf("empty intermediate table")
+		}
 		nextTree, exists := subtree.values[intermediateKey]
 		if !exists {
 			tree := newTomlTree()

vendor/github.com/pelletier/go-toml/tomltree_conversions.go

@@ -0,0 +1,144 @@
+// Tools to convert a TomlTree to different representations
+package toml
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// encodes a string to a TOML-compliant string value
+func encodeTomlString(value string) string {
+	result := ""
+	for _, rr := range value {
+		intRr := uint16(rr)
+		switch rr {
+		case '\b':
+			result += "\\b"
+		case '\t':
+			result += "\\t"
+		case '\n':
+			result += "\\n"
+		case '\f':
+			result += "\\f"
+		case '\r':
+			result += "\\r"
+		case '"':
+			result += "\\\""
+		case '\\':
+			result += "\\\\"
+		default:
+			if intRr < 0x001F {
+				result += fmt.Sprintf("\\u%0.4X", intRr)
+			} else {
+				result += string(rr)
+			}
+		}
+	}
+	return result
+}
+
+// Value print support function for ToString()
+// Outputs the TOML compliant string representation of a value
+func toTomlValue(item interface{}, indent int) string {
+	tab := strings.Repeat(" ", indent)
+	switch value := item.(type) {
+	case int64:
+		return tab + strconv.FormatInt(value, 10)
+	case float64:
+		return tab + strconv.FormatFloat(value, 'f', -1, 64)
+	case string:
+		return tab + "\"" + encodeTomlString(value) + "\""
+	case bool:
+		if value {
+			return "true"
+		}
+		return "false"
+	case time.Time:
+		return tab + value.Format(time.RFC3339)
+	case []interface{}:
+		result := tab + "[\n"
+		for _, item := range value {
+			result += toTomlValue(item, indent+2) + ",\n"
+		}
+		return result + tab + "]"
+	default:
+		panic(fmt.Sprintf("unsupported value type: %v", value))
+	}
+}
+
+// Recursive support function for ToString()
+// Outputs a tree, using the provided keyspace to prefix group names
+func (t *TomlTree) toToml(indent, keyspace string) string {
+	result := ""
+	for k, v := range t.values {
+		// figure out the keyspace
+		combinedKey := k
+		if keyspace != "" {
+			combinedKey = keyspace + "." + combinedKey
+		}
+		// output based on type
+		switch node := v.(type) {
+		case []*TomlTree:
+			for _, item := range node {
+				if len(item.Keys()) > 0 {
+					result += fmt.Sprintf("\n%s[[%s]]\n", indent, combinedKey)
+				}
+				result += item.toToml(indent+"  ", combinedKey)
+			}
+		case *TomlTree:
+			if len(node.Keys()) > 0 {
+				result += fmt.Sprintf("\n%s[%s]\n", indent, combinedKey)
+			}
+			result += node.toToml(indent+"  ", combinedKey)
+		case map[string]interface{}:
+			sub := TreeFromMap(node)
+
+			if len(sub.Keys()) > 0 {
+				result += fmt.Sprintf("\n%s[%s]\n", indent, combinedKey)
+			}
+			result += sub.toToml(indent+"  ", combinedKey)
+		case *tomlValue:
+			result += fmt.Sprintf("%s%s = %s\n", indent, k, toTomlValue(node.value, 0))
+		default:
+			result += fmt.Sprintf("%s%s = %s\n", indent, k, toTomlValue(v, 0))
+		}
+	}
+	return result
+}
+
+// ToString is an alias for String
+func (t *TomlTree) ToString() string {
+	return t.String()
+}
+
+// ToString generates a human-readable representation of the current tree.
+// Output spans multiple lines, and is suitable for ingest by a TOML parser
+func (t *TomlTree) String() string {
+	return t.toToml("", "")
+}
+
+// ToMap recursively generates a representation of the current tree using map[string]interface{}.
+func (t *TomlTree) ToMap() map[string]interface{} {
+	result := map[string]interface{}{}
+
+	for k, v := range t.values {
+		switch node := v.(type) {
+		case []*TomlTree:
+			result[k] = make([]interface{}, 0)
+			for _, item := range node {
+				result[k] = item.ToMap()
+			}
+		case *TomlTree:
+			result[k] = node.ToMap()
+		case map[string]interface{}:
+			sub := TreeFromMap(node)
+			result[k] = sub.ToMap()
+		case *tomlValue:
+			result[k] = node.value
+		}
+	}
+
+	return result
+}

vendor/github.com/pelletier/go-toml/tomltree_create.go

@@ -1,129 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-)
-
-// supported values:
-// string, bool, int64, uint64, float64, time.Time, int, int8, int16, int32, uint, uint8, uint16, uint32, float32
-
-var kindToTypeMapping = map[reflect.Kind]reflect.Type{
-	reflect.Bool:    reflect.TypeOf(true),
-	reflect.String:  reflect.TypeOf(""),
-	reflect.Float32: reflect.TypeOf(float64(1)),
-	reflect.Float64: reflect.TypeOf(float64(1)),
-	reflect.Int:     reflect.TypeOf(int64(1)),
-	reflect.Int8:    reflect.TypeOf(int64(1)),
-	reflect.Int16:   reflect.TypeOf(int64(1)),
-	reflect.Int32:   reflect.TypeOf(int64(1)),
-	reflect.Int64:   reflect.TypeOf(int64(1)),
-	reflect.Uint:    reflect.TypeOf(uint64(1)),
-	reflect.Uint8:   reflect.TypeOf(uint64(1)),
-	reflect.Uint16:  reflect.TypeOf(uint64(1)),
-	reflect.Uint32:  reflect.TypeOf(uint64(1)),
-	reflect.Uint64:  reflect.TypeOf(uint64(1)),
-}
-
-func simpleValueCoercion(object interface{}) (interface{}, error) {
-	switch original := object.(type) {
-	case string, bool, int64, uint64, float64, time.Time:
-		return original, nil
-	case int:
-		return int64(original), nil
-	case int8:
-		return int64(original), nil
-	case int16:
-		return int64(original), nil
-	case int32:
-		return int64(original), nil
-	case uint:
-		return uint64(original), nil
-	case uint8:
-		return uint64(original), nil
-	case uint16:
-		return uint64(original), nil
-	case uint32:
-		return uint64(original), nil
-	case float32:
-		return float64(original), nil
-	default:
-		return nil, fmt.Errorf("cannot convert type %T to TomlTree", object)
-	}
-}
-
-func sliceToTree(object interface{}) (interface{}, error) {
-	// arrays are a bit tricky, since they can represent either a
-	// collection of simple values, which is represented by one
-	// *tomlValue, or an array of tables, which is represented by an
-	// array of *TomlTree.
-
-	// holding the assumption that this function is called from toTree only when value.Kind() is Array or Slice
-	value := reflect.ValueOf(object)
-	insideType := value.Type().Elem()
-	length := value.Len()
-	if insideType.Kind() == reflect.Map {
-		// this is considered as an array of tables
-		tablesArray := make([]*TomlTree, 0, length)
-		for i := 0; i < length; i++ {
-			table := value.Index(i)
-			tree, err := toTree(table.Interface())
-			if err != nil {
-				return nil, err
-			}
-			tablesArray = append(tablesArray, tree.(*TomlTree))
-		}
-		return tablesArray, nil
-	}
-
-	sliceType := kindToTypeMapping[insideType.Kind()]
-	if sliceType == nil {
-		sliceType = insideType
-	}
-
-	arrayValue := reflect.MakeSlice(reflect.SliceOf(sliceType), 0, length)
-
-	for i := 0; i < length; i++ {
-		val := value.Index(i).Interface()
-		simpleValue, err := simpleValueCoercion(val)
-		if err != nil {
-			return nil, err
-		}
-		arrayValue = reflect.Append(arrayValue, reflect.ValueOf(simpleValue))
-	}
-	return &tomlValue{arrayValue.Interface(), Position{}}, nil
-}
-
-func toTree(object interface{}) (interface{}, error) {
-	value := reflect.ValueOf(object)
-
-	if value.Kind() == reflect.Map {
-		values := map[string]interface{}{}
-		keys := value.MapKeys()
-		for _, key := range keys {
-			k, ok := key.Interface().(string)
-			if !ok {
-				return nil, fmt.Errorf("map key needs to be a string, not %T", key.Interface())
-			}
-
-			v := value.MapIndex(key)
-			newValue, err := toTree(v.Interface())
-			if err != nil {
-				return nil, err
-			}
-			values[k] = newValue
-		}
-		return &TomlTree{values, Position{}}, nil
-	}
-
-	if value.Kind() == reflect.Array || value.Kind() == reflect.Slice {
-		return sliceToTree(object)
-	}
-
-	simpleValue, err := simpleValueCoercion(object)
-	if err != nil {
-		return nil, err
-	}
-	return &tomlValue{simpleValue, Position{}}, nil
-}

vendor/github.com/pelletier/go-toml/tomltree_write.go

@@ -1,209 +0,0 @@
-package toml
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// encodes a string to a TOML-compliant string value
-func encodeTomlString(value string) string {
-	result := ""
-	for _, rr := range value {
-		switch rr {
-		case '\b':
-			result += "\\b"
-		case '\t':
-			result += "\\t"
-		case '\n':
-			result += "\\n"
-		case '\f':
-			result += "\\f"
-		case '\r':
-			result += "\\r"
-		case '"':
-			result += "\\\""
-		case '\\':
-			result += "\\\\"
-		default:
-			intRr := uint16(rr)
-			if intRr < 0x001F {
-				result += fmt.Sprintf("\\u%0.4X", intRr)
-			} else {
-				result += string(rr)
-			}
-		}
-	}
-	return result
-}
-
-func tomlValueStringRepresentation(v interface{}) (string, error) {
-	switch value := v.(type) {
-	case uint64:
-		return strconv.FormatUint(value, 10), nil
-	case int64:
-		return strconv.FormatInt(value, 10), nil
-	case float64:
-		return strconv.FormatFloat(value, 'f', -1, 32), nil
-	case string:
-		return "\"" + encodeTomlString(value) + "\"", nil
-	case bool:
-		if value {
-			return "true", nil
-		}
-		return "false", nil
-	case time.Time:
-		return value.Format(time.RFC3339), nil
-	case nil:
-		return "", nil
-	case []interface{}:
-		values := []string{}
-		for _, item := range value {
-			itemRepr, err := tomlValueStringRepresentation(item)
-			if err != nil {
-				return "", err
-			}
-			values = append(values, itemRepr)
-		}
-		return "[" + strings.Join(values, ",") + "]", nil
-	default:
-		return "", fmt.Errorf("unsupported value type %T: %v", value, value)
-	}
-}
-
-func (t *TomlTree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64) (int64, error) {
-	simpleValuesKeys := make([]string, 0)
-	complexValuesKeys := make([]string, 0)
-
-	for k := range t.values {
-		v := t.values[k]
-		switch v.(type) {
-		case *TomlTree, []*TomlTree:
-			complexValuesKeys = append(complexValuesKeys, k)
-		default:
-			simpleValuesKeys = append(simpleValuesKeys, k)
-		}
-	}
-
-	sort.Strings(simpleValuesKeys)
-	sort.Strings(complexValuesKeys)
-
-	for _, k := range simpleValuesKeys {
-		v, ok := t.values[k].(*tomlValue)
-		if !ok {
-			return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
-		}
-
-		repr, err := tomlValueStringRepresentation(v.value)
-		if err != nil {
-			return bytesCount, err
-		}
-
-		kvRepr := fmt.Sprintf("%s%s = %s\n", indent, k, repr)
-		writtenBytesCount, err := w.Write([]byte(kvRepr))
-		bytesCount += int64(writtenBytesCount)
-		if err != nil {
-			return bytesCount, err
-		}
-	}
-
-	for _, k := range complexValuesKeys {
-		v := t.values[k]
-
-		combinedKey := k
-		if keyspace != "" {
-			combinedKey = keyspace + "." + combinedKey
-		}
-
-		switch node := v.(type) {
-		// node has to be of those two types given how keys are sorted above
-		case *TomlTree:
-			tableName := fmt.Sprintf("\n%s[%s]\n", indent, combinedKey)
-			writtenBytesCount, err := w.Write([]byte(tableName))
-			bytesCount += int64(writtenBytesCount)
-			if err != nil {
-				return bytesCount, err
-			}
-			bytesCount, err = node.writeTo(w, indent+"  ", combinedKey, bytesCount)
-			if err != nil {
-				return bytesCount, err
-			}
-		case []*TomlTree:
-			for _, subTree := range node {
-				if len(subTree.values) > 0 {
-					tableArrayName := fmt.Sprintf("\n%s[[%s]]\n", indent, combinedKey)
-					writtenBytesCount, err := w.Write([]byte(tableArrayName))
-					bytesCount += int64(writtenBytesCount)
-					if err != nil {
-						return bytesCount, err
-					}
-
-					bytesCount, err = subTree.writeTo(w, indent+"  ", combinedKey, bytesCount)
-					if err != nil {
-						return bytesCount, err
-					}
-				}
-			}
-		}
-	}
-
-	return bytesCount, nil
-}
-
-// WriteTo encode the TomlTree as Toml and writes it to the writer w.
-// Returns the number of bytes written in case of success, or an error if anything happened.
-func (t *TomlTree) WriteTo(w io.Writer) (int64, error) {
-	return t.writeTo(w, "", "", 0)
-}
-
-// ToTomlString generates a human-readable representation of the current tree.
-// Output spans multiple lines, and is suitable for ingest by a TOML parser.
-// If the conversion cannot be performed, ToString returns a non-nil error.
-func (t *TomlTree) ToTomlString() (string, error) {
-	var buf bytes.Buffer
-	_, err := t.WriteTo(&buf)
-	if err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-// String generates a human-readable representation of the current tree.
-// Alias of ToString. Present to implement the fmt.Stringer interface.
-func (t *TomlTree) String() string {
-	result, _ := t.ToTomlString()
-	return result
-}
-
-// ToMap recursively generates a representation of the tree using Go built-in structures.
-// The following types are used:
-// * uint64
-// * int64
-// * bool
-// * string
-// * time.Time
-// * map[string]interface{} (where interface{} is any of this list)
-// * []interface{} (where interface{} is any of this list)
-func (t *TomlTree) ToMap() map[string]interface{} {
-	result := map[string]interface{}{}
-
-	for k, v := range t.values {
-		switch node := v.(type) {
-		case []*TomlTree:
-			var array []interface{}
-			for _, item := range node {
-				array = append(array, item.ToMap())
-			}
-			result[k] = array
-		case *TomlTree:
-			result[k] = node.ToMap()
-		case *tomlValue:
-			result[k] = node.value
-		}
-	}
-	return result
-}