用户登录和接口鉴权

vendor/github.com/pelletier/go-toml/v2/.goreleaser.yaml

@@ -1,4 +1,3 @@
-version: 2
 before:
   hooks:
     - go mod tidy
@@ -113,7 +112,7 @@ dockers:
 checksum:
   name_template: 'sha256sums.txt'
 snapshot:
-  version_template: "{{ incpatch .Version }}-next"
+  name_template: "{{ incpatch .Version }}-next"
 release:
   github:
     owner: pelletier

vendor/github.com/pelletier/go-toml/v2/README.md

@@ -565,7 +565,7 @@ complete solutions exist out there.
 
 ## Versioning
 
-Expect for parts explicitly marked otherwise, go-toml follows [Semantic
+Expect for parts explicitely marked otherwise, go-toml follows [Semantic
 Versioning](https://semver.org). The supported version of
 [TOML](https://github.com/toml-lang/toml) is indicated at the beginning of this
 document. The last two major versions of Go are supported (see [Go Release

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

@@ -8,7 +8,7 @@ import (
 	"io"
 	"math"
 	"reflect"
-	"slices"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -280,7 +280,7 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 	}
 
 	hasTextMarshaler := v.Type().Implements(textMarshalerType)
-	if hasTextMarshaler || (v.CanAddr() && reflect.PointerTo(v.Type()).Implements(textMarshalerType)) {
+	if hasTextMarshaler || (v.CanAddr() && reflect.PtrTo(v.Type()).Implements(textMarshalerType)) {
 		if !hasTextMarshaler {
 			v = v.Addr()
 		}
@@ -631,18 +631,6 @@ func (enc *Encoder) keyToString(k reflect.Value) (string, error) {
 			return "", fmt.Errorf("toml: error marshalling key %v from text: %w", k, err)
 		}
 		return string(keyB), nil
-
-	case keyType.Kind() == reflect.Int || keyType.Kind() == reflect.Int8 || keyType.Kind() == reflect.Int16 || keyType.Kind() == reflect.Int32 || keyType.Kind() == reflect.Int64:
-		return strconv.FormatInt(k.Int(), 10), nil
-
-	case keyType.Kind() == reflect.Uint || keyType.Kind() == reflect.Uint8 || keyType.Kind() == reflect.Uint16 || keyType.Kind() == reflect.Uint32 || keyType.Kind() == reflect.Uint64:
-		return strconv.FormatUint(k.Uint(), 10), nil
-
-	case keyType.Kind() == reflect.Float32:
-		return strconv.FormatFloat(k.Float(), 'f', -1, 32), nil
-
-	case keyType.Kind() == reflect.Float64:
-		return strconv.FormatFloat(k.Float(), 'f', -1, 64), nil
 	}
 	return "", fmt.Errorf("toml: type %s is not supported as a map key", keyType.Kind())
 }
@@ -680,8 +668,8 @@ func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte
 }
 
 func sortEntriesByKey(e []entry) {
-	slices.SortFunc(e, func(a, b entry) int {
-		return strings.Compare(a.Key, b.Key)
+	sort.Slice(e, func(i, j int) bool {
+		return e[i].Key < e[j].Key
 	})
 }
 
@@ -744,7 +732,7 @@ func walkStruct(ctx encoderCtx, t *table, v reflect.Value) {
 			if fieldType.Anonymous {
 				if fieldType.Type.Kind() == reflect.Struct {
 					walkStruct(ctx, t, f)
-				} else if fieldType.Type.Kind() == reflect.Ptr && !f.IsNil() && f.Elem().Kind() == reflect.Struct {
+				} else if fieldType.Type.Kind() == reflect.Pointer && !f.IsNil() && f.Elem().Kind() == reflect.Struct {
 					walkStruct(ctx, t, f.Elem())
 				}
 				continue
@@ -963,7 +951,7 @@ func willConvertToTable(ctx encoderCtx, v reflect.Value) bool {
 	if !v.IsValid() {
 		return false
 	}
-	if v.Type() == timeType || v.Type().Implements(textMarshalerType) || (v.Kind() != reflect.Ptr && v.CanAddr() && reflect.PointerTo(v.Type()).Implements(textMarshalerType)) {
+	if v.Type() == timeType || v.Type().Implements(textMarshalerType) || (v.Kind() != reflect.Ptr && v.CanAddr() && reflect.PtrTo(v.Type()).Implements(textMarshalerType)) {
 		return false
 	}
 

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

@@ -5,9 +5,9 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"math"
 	"reflect"
-	"strconv"
 	"strings"
 	"sync/atomic"
 	"time"
@@ -21,8 +21,10 @@ import (
 //
 // It is a shortcut for Decoder.Decode() with the default options.
 func Unmarshal(data []byte, v interface{}) error {
-	d := decoder{}
-	d.p.Reset(data)
+	p := unstable.Parser{}
+	p.Reset(data)
+	d := decoder{p: &p}
+
 	return d.FromParser(v)
 }
 
@@ -59,7 +61,7 @@ func (d *Decoder) DisallowUnknownFields() *Decoder {
 //
 // With this feature enabled, types implementing the unstable/Unmarshaler
 // interface can be decoded from any structure of the document. It allows types
-// that don't have a straightforward TOML representation to provide their own
+// that don't have a straightfoward TOML representation to provide their own
 // decoding logic.
 //
 // Currently, types can only decode from a single value. Tables and array tables
@@ -115,25 +117,27 @@ func (d *Decoder) EnableUnmarshalerInterface() *Decoder {
 //	Inline Table     -> same as Table
 //	Array of Tables  -> same as Array and Table
 func (d *Decoder) Decode(v interface{}) error {
-	b, err := io.ReadAll(d.r)
+	b, err := ioutil.ReadAll(d.r)
 	if err != nil {
 		return fmt.Errorf("toml: %w", err)
 	}
 
+	p := unstable.Parser{}
+	p.Reset(b)
 	dec := decoder{
+		p: &p,
 		strict: strict{
 			Enabled: d.strict,
 		},
 		unmarshalerInterface: d.unmarshalerInterface,
 	}
-	dec.p.Reset(b)
 
 	return dec.FromParser(v)
 }
 
 type decoder struct {
 	// Which parser instance in use for this decoding session.
-	p unstable.Parser
+	p *unstable.Parser
 
 	// Flag indicating that the current expression is stashed.
 	// If set to true, calling nextExpr will not actually pull a new expression
@@ -1074,39 +1078,12 @@ func (d *decoder) keyFromData(keyType reflect.Type, data []byte) (reflect.Value,
 		}
 		return mk, nil
 
-	case reflect.PointerTo(keyType).Implements(textUnmarshalerType):
+	case reflect.PtrTo(keyType).Implements(textUnmarshalerType):
 		mk := reflect.New(keyType)
 		if err := mk.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
 			return reflect.Value{}, fmt.Errorf("toml: error unmarshalling key type %s from text: %w", stringType, err)
 		}
 		return mk.Elem(), nil
-
-	case keyType.Kind() == reflect.Int || keyType.Kind() == reflect.Int8 || keyType.Kind() == reflect.Int16 || keyType.Kind() == reflect.Int32 || keyType.Kind() == reflect.Int64:
-		key, err := strconv.ParseInt(string(data), 10, 64)
-		if err != nil {
-			return reflect.Value{}, fmt.Errorf("toml: error parsing key of type %s from integer: %w", stringType, err)
-		}
-		return reflect.ValueOf(key).Convert(keyType), nil
-	case keyType.Kind() == reflect.Uint || keyType.Kind() == reflect.Uint8 || keyType.Kind() == reflect.Uint16 || keyType.Kind() == reflect.Uint32 || keyType.Kind() == reflect.Uint64:
-		key, err := strconv.ParseUint(string(data), 10, 64)
-		if err != nil {
-			return reflect.Value{}, fmt.Errorf("toml: error parsing key of type %s from unsigned integer: %w", stringType, err)
-		}
-		return reflect.ValueOf(key).Convert(keyType), nil
-
-	case keyType.Kind() == reflect.Float32:
-		key, err := strconv.ParseFloat(string(data), 32)
-		if err != nil {
-			return reflect.Value{}, fmt.Errorf("toml: error parsing key of type %s from float: %w", stringType, err)
-		}
-		return reflect.ValueOf(float32(key)), nil
-
-	case keyType.Kind() == reflect.Float64:
-		key, err := strconv.ParseFloat(string(data), 64)
-		if err != nil {
-			return reflect.Value{}, fmt.Errorf("toml: error parsing key of type %s from float: %w", stringType, err)
-		}
-		return reflect.ValueOf(float64(key)), nil
 	}
 	return reflect.Value{}, fmt.Errorf("toml: cannot convert map key of type %s to expected type %s", stringType, keyType)
 }