golang/mikael/madonctl: comparison vendor/github.com/pelletier/go-toml/tomltree

equal deleted inserted replaced

-:c040f992052f
+:1c52a0eeb952
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"math"
+	"math/big"
 	"reflect"
 	"sort"
 	"strconv"
 	"strings"
 	"time"
 )
+type valueComplexity int
+const (
+	valueSimple valueComplexity = iota + 1
+	valueComplex
+)
+type sortNode struct {
+	key        string
+	complexity valueComplexity
+}
 // Encodes a string to a TOML-compliant multi-line string value
 // This function is a clone of the existing encodeTomlString function, except that whitespace characters
 // are preserved. Quotation marks and backslashes are also not escaped.
 func encodeMultilineTomlString(value string) string {
 	case uint64:
 		return strconv.FormatUint(value, 10), nil
 	case int64:
 		return strconv.FormatInt(value, 10), nil
 	case float64:
-		// Ensure a round float does contain a decimal point. Otherwise feeding
+		// Default bit length is full 64
-		// the output back to the parser would convert to an integer.
+		bits := 64
+		// Float panics if nan is used
+		if !math.IsNaN(value) {
+			// if 32 bit accuracy is enough to exactly show, use 32
+			_, acc := big.NewFloat(value).Float32()
+			if acc == big.Exact {
+				bits = 32
+			}
+		}
 		if math.Trunc(value) == value {
-			return strings.ToLower(strconv.FormatFloat(value, 'f', 1, 32)), nil
+			return strings.ToLower(strconv.FormatFloat(value, 'f', 1, bits)), nil
 		}
-		return strings.ToLower(strconv.FormatFloat(value, 'f', -1, 32)), nil
+		return strings.ToLower(strconv.FormatFloat(value, 'f', -1, bits)), nil
 	case string:
 		if tv.multiline {
 			return "\"\"\"\n" + encodeMultilineTomlString(value) + "\"\"\"", nil
 		}
 		return "\"" + encodeTomlString(value) + "\"", nil
 			return "true", nil
 		}
 		return "false", nil
 	case time.Time:
 		return value.Format(time.RFC3339), nil
+	case LocalDate:
+		return value.String(), nil
+	case LocalDateTime:
+		return value.String(), nil
+	case LocalTime:
+		return value.String(), nil
 	case nil:
 		return "", nil
 	}
 	rv := reflect.ValueOf(v)
 		return "[" + strings.Join(values, ",") + "]", nil
 	}
 	return "", fmt.Errorf("unsupported value type %T: %v", v, v)
 }
-func (t *Tree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool) (int64, error) {
+func getTreeArrayLine(trees []*Tree) (line int) {
-	simpleValuesKeys := make([]string, 0)
+	// get lowest line number that is not 0
-	complexValuesKeys := make([]string, 0)
+	for _, tv := range trees {
+		if tv.position.Line < line || line == 0 {
+			line = tv.position.Line
+		}
+	}
+	return
+}
+func sortByLines(t *Tree) (vals []sortNode) {
+	var (
+		line  int
+		lines []int
+		tv    *Tree
+		tom   *tomlValue
+		node  sortNode
+	)
+	vals = make([]sortNode, 0)
+	m := make(map[int]sortNode)
+	for k := range t.values {
+		v := t.values[k]
+		switch v.(type) {
+		case *Tree:
+			tv = v.(*Tree)
+			line = tv.position.Line
+			node = sortNode{key: k, complexity: valueComplex}
+		case []*Tree:
+			line = getTreeArrayLine(v.([]*Tree))
+			node = sortNode{key: k, complexity: valueComplex}
+		default:
+			tom = v.(*tomlValue)
+			line = tom.position.Line
+			node = sortNode{key: k, complexity: valueSimple}
+		}
+		lines = append(lines, line)
+		vals = append(vals, node)
+		m[line] = node
+	}
+	sort.Ints(lines)
+	for i, line := range lines {
+		vals[i] = m[line]
+	}
+	return vals
+}
+func sortAlphabetical(t *Tree) (vals []sortNode) {
+	var (
+		node     sortNode
+		simpVals []string
+		compVals []string
+	)
+	vals = make([]sortNode, 0)
+	m := make(map[string]sortNode)
 	for k := range t.values {
 		v := t.values[k]
 		switch v.(type) {
 		case *Tree, []*Tree:
-			complexValuesKeys = append(complexValuesKeys, k)
+			node = sortNode{key: k, complexity: valueComplex}
+			compVals = append(compVals, node.key)
 		default:
-			simpleValuesKeys = append(simpleValuesKeys, k)
+			node = sortNode{key: k, complexity: valueSimple}
-		}
+			simpVals = append(simpVals, node.key)
-	}
+		}
+		vals = append(vals, node)
-	sort.Strings(simpleValuesKeys)
+		m[node.key] = node
-	sort.Strings(complexValuesKeys)
+	}
-	for _, k := range simpleValuesKeys {
+	// Simples first to match previous implementation
-		v, ok := t.values[k].(*tomlValue)
+	sort.Strings(simpVals)
-		if !ok {
+	i := 0
-			return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
+	for _, key := range simpVals {
-		}
+		vals[i] = m[key]
+		i++
-		repr, err := tomlValueStringRepresentation(v, indent, arraysOneElementPerLine)
+	}
-		if err != nil {
-			return bytesCount, err
+	sort.Strings(compVals)
-		}
+	for _, key := range compVals {
+		vals[i] = m[key]
-		if v.comment != "" {
+		i++
-			comment := strings.Replace(v.comment, "\n", "\n"+indent+"#", -1)
+	}
-			start := "# "
-			if strings.HasPrefix(comment, "#") {
+	return vals
-				start = ""
+}
-			}
-			writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment, "\n")
+func (t *Tree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool) (int64, error) {
-			bytesCount += int64(writtenBytesCountComment)
+	return t.writeToOrdered(w, indent, keyspace, bytesCount, arraysOneElementPerLine, OrderAlphabetical)
-			if errc != nil {
+}
-				return bytesCount, errc
-			}
+func (t *Tree) writeToOrdered(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool, ord marshalOrder) (int64, error) {
-		}
+	var orderedVals []sortNode
-		var commented string
+	switch ord {
-		if v.commented {
+	case OrderPreserve:
-			commented = "# "
+		orderedVals = sortByLines(t)
-		}
+	default:
-		writtenBytesCount, err := writeStrings(w, indent, commented, k, " = ", repr, "\n")
+		orderedVals = sortAlphabetical(t)
-		bytesCount += int64(writtenBytesCount)
+	}
-		if err != nil {
-			return bytesCount, err
+	for _, node := range orderedVals {
-		}
+		switch node.complexity {
-	}
+		case valueComplex:
+			k := node.key
-	for _, k := range complexValuesKeys {
+			v := t.values[k]
-		v := t.values[k]
+			combinedKey := k
-		combinedKey := k
+			if keyspace != "" {
-		if keyspace != "" {
+				combinedKey = keyspace + "." + combinedKey
-			combinedKey = keyspace + "." + combinedKey
+			}
-		}
+			var commented string
-		var commented string
+			if t.commented {
-		if t.commented {
+				commented = "# "
-			commented = "# "
+			}
-		}
+			switch node := v.(type) {
-		switch node := v.(type) {
+			// node has to be of those two types given how keys are sorted above
-		// node has to be of those two types given how keys are sorted above
+			case *Tree:
-		case *Tree:
+				tv, ok := t.values[k].(*Tree)
-			tv, ok := t.values[k].(*Tree)
+				if !ok {
+					return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
+				}
+				if tv.comment != "" {
+					comment := strings.Replace(tv.comment, "\n", "\n"+indent+"#", -1)
+					start := "# "
+					if strings.HasPrefix(comment, "#") {
+						start = ""
+					}
+					writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment)
+					bytesCount += int64(writtenBytesCountComment)
+					if errc != nil {
+						return bytesCount, errc
+					}
+				}
+				writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[", combinedKey, "]\n")
+				bytesCount += int64(writtenBytesCount)
+				if err != nil {
+					return bytesCount, err
+				}
+				bytesCount, err = node.writeToOrdered(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine, ord)
+				if err != nil {
+					return bytesCount, err
+				}
+			case []*Tree:
+				for _, subTree := range node {
+					writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[[", combinedKey, "]]\n")
+					bytesCount += int64(writtenBytesCount)
+					if err != nil {
+						return bytesCount, err
+					}
+					bytesCount, err = subTree.writeToOrdered(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine, ord)
+					if err != nil {
+						return bytesCount, err
+					}
+				}
+			}
+		default: // Simple
+			k := node.key
+			v, ok := t.values[k].(*tomlValue)
 			if !ok {
 				return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])
 			}
-			if tv.comment != "" {
-				comment := strings.Replace(tv.comment, "\n", "\n"+indent+"#", -1)
+			repr, err := tomlValueStringRepresentation(v, indent, arraysOneElementPerLine)
+			if err != nil {
+				return bytesCount, err
+			}
+			if v.comment != "" {
+				comment := strings.Replace(v.comment, "\n", "\n"+indent+"#", -1)
 				start := "# "
 				if strings.HasPrefix(comment, "#") {
 					start = ""
 				}
-				writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment)
+				writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment, "\n")
 				bytesCount += int64(writtenBytesCountComment)
 				if errc != nil {
 					return bytesCount, errc
 				}
 			}
-			writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[", combinedKey, "]\n")
+			var commented string
+			if v.commented {
+				commented = "# "
+			}
+			quotedKey := quoteKeyIfNeeded(k)
+			writtenBytesCount, err := writeStrings(w, indent, commented, quotedKey, " = ", repr, "\n")
 			bytesCount += int64(writtenBytesCount)
 			if err != nil {
 				return bytesCount, err
 			}
-			bytesCount, err = node.writeTo(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine)
-			if err != nil {
-				return bytesCount, err
-			}
-		case []*Tree:
-			for _, subTree := range node {
-				writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[[", combinedKey, "]]\n")
-				bytesCount += int64(writtenBytesCount)
-				if err != nil {
-					return bytesCount, err
-				}
-				bytesCount, err = subTree.writeTo(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine)
-				if err != nil {
-					return bytesCount, err
-				}
-			}
 		}
 	}
 	return bytesCount, nil
+}
+// quote a key if it does not fit the bare key format (A-Za-z0-9_-)
+// quoted keys use the same rules as strings
+func quoteKeyIfNeeded(k string) string {
+	// when encoding a map with the 'quoteMapKeys' option enabled, the tree will contain
+	// keys that have already been quoted.
+	// not an ideal situation, but good enough of a stop gap.
+	if len(k) >= 2 && k[0] == '"' && k[len(k)-1] == '"' {
+		return k
+	}
+	isBare := true
+	for _, r := range k {
+		if !isValidBareChar(r) {
+			isBare = false
+			break
+		}
+	}
+	if isBare {
+		return k
+	}
+	return quoteKey(k)
+}
+func quoteKey(k string) string {
+	return "\"" + encodeTomlString(k) + "\""
 }
 func writeStrings(w io.Writer, s ...string) (int, error) {
 	var n int
 	for i := range s {
 // 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 *Tree) ToTomlString() (string, error) {
-	var buf bytes.Buffer
+	b, err := t.Marshal()
-	_, err := t.WriteTo(&buf)
 	if err != nil {
 		return "", err
 	}
-	return buf.String(), nil
+	return string(b), nil
 }
 // String generates a human-readable representation of the current tree.
 // Alias of ToString. Present to implement the fmt.Stringer interface.
 func (t *Tree) String() string {

changeset 251	1c52a0eeb952
parent 242	2a9ec03fe5a1
child 256	6d9efbef00a9