go.mod: github.com/pelletier/go-toml v1.9.3

full diff: https://github.com/pelletier/go-toml/compare/v1.8.1...v1.9.3

- v1.9.3: Clarify license and comply with Apache 2.0
- v1.9.2: Add Encoder.CompactComments to omit extra new line
- v1.9.1: Fix empty trees line counting

v1.9.0
-------------------

The highlight of this version is that the whole toml.Tree structure has been made
public in a backward compatible way. This allows everyone using v1.x to fully
access the data and metadata in the tree to extend the library.

This is hopefully the last release in the v1.x track, as go-toml v2 is the main
focus of development.

What's new

- TOML 1.0.0-rc.3
- Improved default tag for durations
- Provide Tree and treeValue public aliases
- Expose MarshalOrder
- Value string representation public function

Fixed bugs

- Do not allow T-prefix on local dates
- toml.Unmarshaler supports leaf nodes
- Fix date lexer to only support 4-digit year
- Fix ToMap for tables in mixed-type arrays
- Fix ToMap for tables in nested mixed-type arrays
- Support literal multiline marshal

Performance

- Remove date regexp
- Remove underscore regexps

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

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

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"math"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -231,19 +230,38 @@ func (p *tomlParser) parseAssign() tomlParserStateFn {
 	return p.parseStart
 }
 
-var numberUnderscoreInvalidRegexp *regexp.Regexp
-var hexNumberUnderscoreInvalidRegexp *regexp.Regexp
+var errInvalidUnderscore = errors.New("invalid use of _ in number")
 
 func numberContainsInvalidUnderscore(value string) error {
-	if numberUnderscoreInvalidRegexp.MatchString(value) {
-		return errors.New("invalid use of _ in number")
+	// For large numbers, you may use underscores between digits to enhance
+	// readability. Each underscore must be surrounded by at least one digit on
+	// each side.
+
+	hasBefore := false
+	for idx, r := range value {
+		if r == '_' {
+			if !hasBefore || idx+1 >= len(value) {
+				// can't end with an underscore
+				return errInvalidUnderscore
+			}
+		}
+		hasBefore = isDigit(r)
 	}
 	return nil
 }
 
+var errInvalidUnderscoreHex = errors.New("invalid use of _ in hex number")
+
 func hexNumberContainsInvalidUnderscore(value string) error {
-	if hexNumberUnderscoreInvalidRegexp.MatchString(value) {
-		return errors.New("invalid use of _ in hex number")
+	hasBefore := false
+	for idx, r := range value {
+		if r == '_' {
+			if !hasBefore || idx+1 >= len(value) {
+				// can't end with an underscore
+				return errInvalidUnderscoreHex
+			}
+		}
+		hasBefore = isHexDigit(r)
 	}
 	return nil
 }
@@ -322,42 +340,44 @@ func (p *tomlParser) parseRvalue() interface{} {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
-	case tokenDate:
-		layout := time.RFC3339Nano
-		if !strings.Contains(tok.val, "T") {
-			layout = strings.Replace(layout, "T", " ", 1)
-		}
-		val, err := time.ParseInLocation(layout, tok.val, time.UTC)
+	case tokenLocalTime:
+		val, err := ParseLocalTime(tok.val)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
 	case tokenLocalDate:
-		v := strings.Replace(tok.val, " ", "T", -1)
-		isDateTime := false
-		isTime := false
-		for _, c := range v {
-			if c == 'T' || c == 't' {
-				isDateTime = true
-				break
-			}
-			if c == ':' {
-				isTime = true
-				break
+		// a local date may be followed by:
+		// * nothing: this is a local date
+		// * a local time: this is a local date-time
+
+		next := p.peek()
+		if next == nil || next.typ != tokenLocalTime {
+			val, err := ParseLocalDate(tok.val)
+			if err != nil {
+				p.raiseError(tok, "%s", err)
 			}
+			return val
 		}
 
-		var val interface{}
-		var err error
+		localDate := tok
+		localTime := p.getToken()
 
-		if isDateTime {
-			val, err = ParseLocalDateTime(v)
-		} else if isTime {
-			val, err = ParseLocalTime(v)
-		} else {
-			val, err = ParseLocalDate(v)
+		next = p.peek()
+		if next == nil || next.typ != tokenTimeOffset {
+			v := localDate.val + "T" + localTime.val
+			val, err := ParseLocalDateTime(v)
+			if err != nil {
+				p.raiseError(tok, "%s", err)
+			}
+			return val
 		}
 
+		offset := p.getToken()
+
+		layout := time.RFC3339Nano
+		v := localDate.val + "T" + localTime.val + offset.val
+		val, err := time.ParseInLocation(layout, v, time.UTC)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
@@ -370,10 +390,10 @@ func (p *tomlParser) parseRvalue() interface{} {
 		p.raiseError(tok, "cannot have multiple equals for the same key")
 	case tokenError:
 		p.raiseError(tok, "%s", tok)
+	default:
+		panic(fmt.Errorf("unhandled token: %v", tok))
 	}
 
-	p.raiseError(tok, "never reached")
-
 	return nil
 }
 
@@ -486,8 +506,3 @@ func parseToml(flow []token) *Tree {
 	parser.run()
 	return result
 }
-
-func init() {
-	numberUnderscoreInvalidRegexp = regexp.MustCompile(`([^\d]_|_[^\d])|_$|^_`)
-	hexNumberUnderscoreInvalidRegexp = regexp.MustCompile(`(^0x_)|([^\da-f]_|_[^\da-f])|_$|^_`)
-}