feat: update gitea vendor

package/gitea/source/modules/util/diff_slice_test.go

@@ -0,0 +1,74 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDiffSliceBasic(t *testing.T) {
+	// Typical integer cases
+	t.Run("additions", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1, 2}, []int{1, 2, 3})
+		assert.Equal(t, []int{3}, added)
+		assert.Empty(t, removed)
+	})
+
+	t.Run("removals", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1, 2, 3}, []int{1, 2})
+		assert.Empty(t, added)
+		assert.Equal(t, []int{3}, removed)
+	})
+
+	t.Run("no changes", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1, 2}, []int{1, 2})
+		assert.Empty(t, added)
+		assert.Empty(t, removed)
+	})
+
+	t.Run("empty slices", func(t *testing.T) {
+		added, removed := DiffSlice([]int{}, []int{})
+		assert.Empty(t, added)
+		assert.Empty(t, removed)
+	})
+
+	t.Run("overlapping elements", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1, 2, 4}, []int{2, 3, 4})
+		assert.Equal(t, []int{3}, added)
+		assert.Equal(t, []int{1}, removed)
+	})
+}
+
+func TestDiffSliceOrderAndDuplicates(t *testing.T) {
+	oldSlice := []int{1, 2, 2, 3}
+	newSlice := []int{2, 4, 2, 5}
+
+	added, removed := DiffSlice(oldSlice, newSlice)
+	assert.Equal(t, []int{4, 5}, added)
+	assert.Equal(t, []int{1, 3}, removed)
+}
+
+func TestDiffSliceDeduplicatesOutput(t *testing.T) {
+	// Test case from issue: newSlice contains [4, 4, 5] and oldSlice is [1]
+	// added should return [4, 5], not [4, 4, 5]
+	t.Run("deduplicates added", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1}, []int{4, 4, 5})
+		assert.Equal(t, []int{4, 5}, added)
+		assert.Equal(t, []int{1}, removed)
+	})
+
+	t.Run("deduplicates removed", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1, 1, 2}, []int{3})
+		assert.Equal(t, []int{3}, added)
+		assert.Equal(t, []int{1, 2}, removed)
+	})
+
+	t.Run("deduplicates both", func(t *testing.T) {
+		added, removed := DiffSlice([]int{1, 1, 2, 2}, []int{3, 3, 4, 4})
+		assert.Equal(t, []int{3, 4}, added)
+		assert.Equal(t, []int{1, 2}, removed)
+	})
+}

package/gitea/source/modules/util/rotatingfilewriter/writer.go

@@ -14,8 +14,8 @@ import (
 	"sync"
 	"time"
 
-	"code.gitea.io/gitea/modules/graceful/releasereopen"
-	"code.gitea.io/gitea/modules/util"
+	"gitea.dev/modules/graceful/releasereopen"
+	"gitea.dev/modules/util"
 )
 
 type Options struct {

package/gitea/source/modules/util/runtime_test.go

@@ -12,7 +12,7 @@ import (
 
 func TestCallerFuncName(t *testing.T) {
 	s := CallerFuncName()
-	assert.Equal(t, "code.gitea.io/gitea/modules/util.TestCallerFuncName", s)
+	assert.Equal(t, "gitea.dev/modules/util.TestCallerFuncName", s)
 }
 
 func BenchmarkCallerFuncName(b *testing.B) {

package/gitea/source/modules/util/sync.go

@@ -0,0 +1,51 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package util
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+type onceValueResult[T any] struct {
+	value T
+	panic any
+}
+
+// OnceValue is similar to Golang's "sync.OnceValue", but can be reset.
+type OnceValue[T any] struct {
+	Func func() T
+	mu   sync.Mutex
+	res  atomic.Pointer[onceValueResult[T]]
+}
+
+func (o *OnceValue[T]) Value() T {
+	res := o.res.Load()
+	if res == nil {
+		o.mu.Lock()
+		defer o.mu.Unlock()
+		res = o.res.Load()
+		if res == nil {
+			res = &onceValueResult[T]{}
+			defer func() {
+				res.panic = recover()
+				o.res.Store(res)
+				if res.panic != nil {
+					panic(res.panic)
+				}
+			}()
+			res.value = o.Func()
+		}
+	}
+	if res.panic != nil {
+		panic(res.panic)
+	}
+	return res.value
+}
+
+func (o *OnceValue[T]) Reset() {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	o.res.Store(nil)
+}

package/gitea/source/modules/util/sync_test.go

@@ -0,0 +1,49 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOnceValue(t *testing.T) {
+	t.Run("RepeatCall", func(t *testing.T) {
+		callCount := 0
+		o := OnceValue[int]{Func: func() int {
+			callCount++
+			return 42
+		}}
+		assert.Equal(t, 42, o.Value())
+		assert.Equal(t, 42, o.Value())
+		assert.Equal(t, 1, callCount)
+		o.Reset()
+		assert.Equal(t, 42, o.Value())
+		assert.Equal(t, 2, callCount)
+		assert.Equal(t, 42, o.Value())
+		assert.Equal(t, 2, callCount)
+	})
+
+	t.Run("Panic", func(t *testing.T) {
+		callCount := 0
+		doPanic := true
+		o := OnceValue[int]{Func: func() int {
+			callCount++
+			if doPanic {
+				panic("some error")
+			}
+			return 42
+		}}
+		assert.PanicsWithValue(t, "some error", func() { o.Value() })
+		assert.PanicsWithValue(t, "some error", func() { o.Value() })
+		assert.Equal(t, 1, callCount)
+		doPanic = false
+		o.Reset()
+		assert.Equal(t, 42, o.Value())
+		assert.Equal(t, 2, callCount)
+		assert.Equal(t, 42, o.Value())
+		assert.Equal(t, 2, callCount)
+	})
+}

package/gitea/source/modules/util/time_str.go

@@ -40,6 +40,7 @@ var timeStrGlobalVars = sync.OnceValue(func() *timeStrGlobalVarsType {
 })
 
 func TimeEstimateParse(timeStr string) (int64, error) {
+	timeStr = strings.TrimSpace(timeStr)
 	if timeStr == "" {
 		return 0, nil
 	}
@@ -51,7 +52,13 @@ func TimeEstimateParse(timeStr string) (int64, error) {
 	if matches[0][0] != 0 || matches[len(matches)-1][1] != len(timeStr) {
 		return 0, fmt.Errorf("invalid time string: %s", timeStr)
 	}
+	prevEnd := 0
 	for _, match := range matches {
+		// only whitespace may separate two units, otherwise the string contains invalid content like "1h x 2m"
+		if strings.TrimSpace(timeStr[prevEnd:match[0]]) != "" {
+			return 0, fmt.Errorf("invalid time string: %s", timeStr)
+		}
+		prevEnd = match[1]
 		amount, err := strconv.ParseInt(timeStr[match[2]:match[3]], 10, 64)
 		if err != nil {
 			return 0, fmt.Errorf("invalid time string: %v", err)

package/gitea/source/modules/util/time_str_test.go

@@ -22,6 +22,9 @@ func TestTimeStr(t *testing.T) {
 			{"1s", 1, false},
 			{"1h 1m 1s", 3600 + 60 + 1, false},
 			{"1d1x", 0, true},
+			{"1h 2x 3m", 0, true},
+			{"1h_2m", 0, true},
+			{"1h,1m", 0, true},
 		}
 		for _, test := range tests {
 			t.Run(test.input, func(t *testing.T) {

package/gitea/source/modules/util/util.go

@@ -6,11 +6,16 @@ package util
 import (
 	"bytes"
 	"crypto/rand"
+	"encoding/hex"
 	"fmt"
 	"math/big"
+	rand2 "math/rand/v2"
 	"slices"
 	"strconv"
 	"strings"
+	"sync"
+
+	"gitea.dev/modules/container"
 
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
@@ -21,6 +26,11 @@ func IsEmptyString(s string) bool {
 	return len(strings.TrimSpace(s)) == 0
 }
 
+// ParseYamlBool parses YAML 1.2 boolean values into bool
+func ParseYamlBool(s string) bool {
+	return s == "true" || s == "True" || s == "TRUE"
+}
+
 // NormalizeEOL will convert Windows (CRLF) and Mac (CR) EOLs to UNIX (LF)
 func NormalizeEOL(input []byte) []byte {
 	var right, left, pos int
@@ -58,37 +68,60 @@ func NormalizeEOL(input []byte) []byte {
 }
 
 // CryptoRandomInt returns a crypto random integer between 0 and limit, inclusive
-func CryptoRandomInt(limit int64) (int64, error) {
+func CryptoRandomInt(limit int64) int64 {
 	rInt, err := rand.Int(rand.Reader, big.NewInt(limit))
 	if err != nil {
-		return 0, err
+		panic(err) // this should never happen
 	}
-	return rInt.Int64(), nil
+	return rInt.Int64()
 }
 
-const alphanumericalChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-
 // CryptoRandomString generates a crypto random alphanumerical string, each byte is generated by [0,61] range
-func CryptoRandomString(length int64) (string, error) {
+func CryptoRandomString(length int64) string {
+	const alphanumericalChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 	buf := make([]byte, length)
 	limit := int64(len(alphanumericalChars))
 	for i := range buf {
-		num, err := CryptoRandomInt(limit)
-		if err != nil {
-			return "", err
-		}
+		num := CryptoRandomInt(limit)
 		buf[i] = alphanumericalChars[num]
 	}
-	return string(buf), nil
+	return string(buf)
 }
 
 // CryptoRandomBytes generates `length` crypto bytes
 // This differs from CryptoRandomString, as each byte in CryptoRandomString is generated by [0,61] range
 // This function generates totally random bytes, each byte is generated by [0,255] range
-func CryptoRandomBytes(length int64) ([]byte, error) {
+func CryptoRandomBytes(length int64) []byte {
 	buf := make([]byte, length)
-	_, err := rand.Read(buf)
-	return buf, err
+	if _, err := rand.Read(buf); err != nil {
+		panic(err) // this should never happen, "rand.Read" never fails
+	}
+	return buf
+}
+
+var chaCha8RandPool = sync.OnceValue(func() *sync.Pool {
+	return &sync.Pool{
+		New: func() any {
+			seed := CryptoRandomBytes(32)
+			return rand2.NewChaCha8([32]byte(seed))
+		},
+	}
+})
+
+func FastCryptoRandomBytes(length int) []byte {
+	// ChaCha8 is about 20x times faster than system's crypto/rand.
+	// It is suitable for UUIDs, session IDs, etc
+	pool := chaCha8RandPool()
+	chaCha8Rand := pool.Get().(*rand2.ChaCha8)
+	defer pool.Put(chaCha8Rand)
+	buf := make([]byte, length)
+	_, _ = chaCha8Rand.Read(buf)
+	return buf
+}
+
+func FastCryptoRandomHex(length int) string {
+	buf := FastCryptoRandomBytes(length / 2)
+	return hex.EncodeToString(buf)
 }
 
 // ToLowerASCII returns s with all ASCII letters mapped to their lower case.
@@ -265,3 +298,27 @@ func NormalizeStringEOL(input string) string {
 	// Other than this, we should respect the original content, even leading or trailing spaces.
 	return UnsafeBytesToString(NormalizeEOL(UnsafeStringToBytes(input)))
 }
+
+func DiffSlice[T comparable](oldSlice, newSlice []T) (added, removed []T) {
+	oldSet := container.SetOf(oldSlice...)
+	newSet := container.SetOf(newSlice...)
+
+	addedSet, removedSet := container.Set[T]{}, container.Set[T]{}
+	for _, v := range newSlice {
+		if !oldSet.Contains(v) && addedSet.Add(v) {
+			added = append(added, v)
+		}
+	}
+	for _, v := range oldSlice {
+		if !newSet.Contains(v) && removedSet.Add(v) {
+			removed = append(removed, v)
+		}
+	}
+	return added, removed
+}
+
+func MustNoError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

package/gitea/source/modules/util/util_test.go

@@ -86,35 +86,31 @@ func Test_NormalizeEOL(t *testing.T) {
 }
 
 func Test_RandomInt(t *testing.T) {
-	randInt, err := CryptoRandomInt(255)
+	randInt := CryptoRandomInt(255)
 	assert.GreaterOrEqual(t, randInt, int64(0))
 	assert.LessOrEqual(t, randInt, int64(255))
-	assert.NoError(t, err)
 }
 
 func Test_RandomString(t *testing.T) {
-	str1, err := CryptoRandomString(32)
-	assert.NoError(t, err)
+	str1 := CryptoRandomString(32)
+	var err error
 	matches, err := regexp.MatchString(`^[a-zA-Z0-9]{32}$`, str1)
 	assert.NoError(t, err)
 	assert.True(t, matches)
 
-	str2, err := CryptoRandomString(32)
-	assert.NoError(t, err)
+	str2 := CryptoRandomString(32)
 	matches, err = regexp.MatchString(`^[a-zA-Z0-9]{32}$`, str1)
 	assert.NoError(t, err)
 	assert.True(t, matches)
 
 	assert.NotEqual(t, str1, str2)
 
-	str3, err := CryptoRandomString(256)
-	assert.NoError(t, err)
+	str3 := CryptoRandomString(256)
 	matches, err = regexp.MatchString(`^[a-zA-Z0-9]{256}$`, str3)
 	assert.NoError(t, err)
 	assert.True(t, matches)
 
-	str4, err := CryptoRandomString(256)
-	assert.NoError(t, err)
+	str4 := CryptoRandomString(256)
 	matches, err = regexp.MatchString(`^[a-zA-Z0-9]{256}$`, str4)
 	assert.NoError(t, err)
 	assert.True(t, matches)
@@ -123,19 +119,15 @@ func Test_RandomString(t *testing.T) {
 }
 
 func Test_RandomBytes(t *testing.T) {
-	bytes1, err := CryptoRandomBytes(32)
-	assert.NoError(t, err)
+	bytes1 := CryptoRandomBytes(32)
 
-	bytes2, err := CryptoRandomBytes(32)
-	assert.NoError(t, err)
+	bytes2 := CryptoRandomBytes(32)
 
 	assert.NotEqual(t, bytes1, bytes2)
 
-	bytes3, err := CryptoRandomBytes(256)
-	assert.NoError(t, err)
+	bytes3 := CryptoRandomBytes(256)
 
-	bytes4, err := CryptoRandomBytes(256)
-	assert.NoError(t, err)
+	bytes4 := CryptoRandomBytes(256)
 
 	assert.NotEqual(t, bytes3, bytes4)
 }