Refactor context flash msg and global variables (#33375)

1. add `GetSiteCookieFlashMessage` to help to parse flash message
2. clarify `handleRepoHomeFeed` logic
3. remove unnecessary global variables, use `sync.OnceValue` instead
4. add some tests for `IsUsableUsername` and `IsUsableRepoName`

modules/validation/glob_pattern_test.go

@@ -19,40 +19,40 @@ func getGlobPatternErrorString(pattern string) string {
 	return ""
 }
 
-var globValidationTestCases = []validationTestCase{
-	{
-		description: "Empty glob pattern",
-		data: TestForm{
-			GlobPattern: "",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Valid glob",
-		data: TestForm{
-			GlobPattern: "{master,release*}",
-		},
-		expectedErrors: binding.Errors{},
-	},
-
-	{
-		description: "Invalid glob",
-		data: TestForm{
-			GlobPattern: "[a-",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"GlobPattern"},
-				Classification: ErrGlobPattern,
-				Message:        getGlobPatternErrorString("[a-"),
-			},
-		},
-	},
-}
-
 func Test_GlobPatternValidation(t *testing.T) {
 	AddBindingRules()
 
+	globValidationTestCases := []validationTestCase{
+		{
+			description: "Empty glob pattern",
+			data: TestForm{
+				GlobPattern: "",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Valid glob",
+			data: TestForm{
+				GlobPattern: "{master,release*}",
+			},
+			expectedErrors: binding.Errors{},
+		},
+
+		{
+			description: "Invalid glob",
+			data: TestForm{
+				GlobPattern: "[a-",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"GlobPattern"},
+					Classification: ErrGlobPattern,
+					Message:        getGlobPatternErrorString("[a-"),
+				},
+			},
+		},
+	}
+
 	for _, testCase := range globValidationTestCases {
 		t.Run(testCase.description, func(t *testing.T) {
 			performValidationTest(t, testCase)

modules/validation/helpers.go

@@ -8,13 +8,26 @@ import (
 	"net/url"
 	"regexp"
 	"strings"
+	"sync"
 
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/gobwas/glob"
 )
 
-var externalTrackerRegex = regexp.MustCompile(`({?)(?:user|repo|index)+?(}?)`)
+type globalVarsStruct struct {
+	externalTrackerRegex   *regexp.Regexp
+	validUsernamePattern   *regexp.Regexp
+	invalidUsernamePattern *regexp.Regexp
+}
+
+var globalVars = sync.OnceValue(func() *globalVarsStruct {
+	return &globalVarsStruct{
+		externalTrackerRegex:   regexp.MustCompile(`({?)(?:user|repo|index)+?(}?)`),
+		validUsernamePattern:   regexp.MustCompile(`^[\da-zA-Z][-.\w]*$`),
+		invalidUsernamePattern: regexp.MustCompile(`[-._]{2,}|[-._]$`), // No consecutive or trailing non-alphanumeric chars
+	}
+})
 
 func isLoopbackIP(ip string) bool {
 	return net.ParseIP(ip).IsLoopback()
@@ -105,9 +118,9 @@ func IsValidExternalTrackerURLFormat(uri string) bool {
 	if !IsValidExternalURL(uri) {
 		return false
 	}
-
+	vars := globalVars()
 	// check for typoed variables like /{index/ or /[repo}
-	for _, match := range externalTrackerRegex.FindAllStringSubmatch(uri, -1) {
+	for _, match := range vars.externalTrackerRegex.FindAllStringSubmatch(uri, -1) {
 		if (match[1] == "{" || match[2] == "}") && (match[1] != "{" || match[2] != "}") {
 			return false
 		}
@@ -116,14 +129,10 @@ func IsValidExternalTrackerURLFormat(uri string) bool {
 	return true
 }
 
-var (
-	validUsernamePattern   = regexp.MustCompile(`^[\da-zA-Z][-.\w]*$`)
-	invalidUsernamePattern = regexp.MustCompile(`[-._]{2,}|[-._]$`) // No consecutive or trailing non-alphanumeric chars
-)
-
 // IsValidUsername checks if username is valid
 func IsValidUsername(name string) bool {
 	// It is difficult to find a single pattern that is both readable and effective,
 	// but it's easier to use positive and negative checks.
-	return validUsernamePattern.MatchString(name) && !invalidUsernamePattern.MatchString(name)
+	vars := globalVars()
+	return vars.validUsernamePattern.MatchString(name) && !vars.invalidUsernamePattern.MatchString(name)
 }

modules/validation/refname_test.go

@@ -9,253 +9,252 @@ import (
 	"gitea.com/go-chi/binding"
 )
 
-var gitRefNameValidationTestCases = []validationTestCase{
-	{
-		description: "Reference name contains only characters",
-		data: TestForm{
-			BranchName: "test",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Reference name contains single slash",
-		data: TestForm{
-			BranchName: "feature/test",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Reference name has allowed special characters",
-		data: TestForm{
-			BranchName: "debian/1%1.6.0-2",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Reference name contains backslash",
-		data: TestForm{
-			BranchName: "feature\\test",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name starts with dot",
-		data: TestForm{
-			BranchName: ".test",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name ends with dot",
-		data: TestForm{
-			BranchName: "test.",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name starts with slash",
-		data: TestForm{
-			BranchName: "/test",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name ends with slash",
-		data: TestForm{
-			BranchName: "test/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name ends with .lock",
-		data: TestForm{
-			BranchName: "test.lock",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name contains multiple consecutive dots",
-		data: TestForm{
-			BranchName: "te..st",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name contains multiple consecutive slashes",
-		data: TestForm{
-			BranchName: "te//st",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name is single @",
-		data: TestForm{
-			BranchName: "@",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has @{",
-		data: TestForm{
-			BranchName: "branch@{",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character ~",
-		data: TestForm{
-			BranchName: "~debian/1%1.6.0-2",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character *",
-		data: TestForm{
-			BranchName: "*debian/1%1.6.0-2",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character ?",
-		data: TestForm{
-			BranchName: "?debian/1%1.6.0-2",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character ^",
-		data: TestForm{
-			BranchName: "^debian/1%1.6.0-2",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character :",
-		data: TestForm{
-			BranchName: "debian:jessie",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character (whitespace)",
-		data: TestForm{
-			BranchName: "debian jessie",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-	{
-		description: "Reference name has unallowed special character [",
-		data: TestForm{
-			BranchName: "debian[jessie",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"BranchName"},
-				Classification: ErrGitRefName,
-				Message:        "GitRefName",
-			},
-		},
-	},
-}
-
 func Test_GitRefNameValidation(t *testing.T) {
 	AddBindingRules()
+	gitRefNameValidationTestCases := []validationTestCase{
+		{
+			description: "Reference name contains only characters",
+			data: TestForm{
+				BranchName: "test",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Reference name contains single slash",
+			data: TestForm{
+				BranchName: "feature/test",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Reference name has allowed special characters",
+			data: TestForm{
+				BranchName: "debian/1%1.6.0-2",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Reference name contains backslash",
+			data: TestForm{
+				BranchName: "feature\\test",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name starts with dot",
+			data: TestForm{
+				BranchName: ".test",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name ends with dot",
+			data: TestForm{
+				BranchName: "test.",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name starts with slash",
+			data: TestForm{
+				BranchName: "/test",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name ends with slash",
+			data: TestForm{
+				BranchName: "test/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name ends with .lock",
+			data: TestForm{
+				BranchName: "test.lock",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name contains multiple consecutive dots",
+			data: TestForm{
+				BranchName: "te..st",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name contains multiple consecutive slashes",
+			data: TestForm{
+				BranchName: "te//st",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name is single @",
+			data: TestForm{
+				BranchName: "@",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has @{",
+			data: TestForm{
+				BranchName: "branch@{",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character ~",
+			data: TestForm{
+				BranchName: "~debian/1%1.6.0-2",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character *",
+			data: TestForm{
+				BranchName: "*debian/1%1.6.0-2",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character ?",
+			data: TestForm{
+				BranchName: "?debian/1%1.6.0-2",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character ^",
+			data: TestForm{
+				BranchName: "^debian/1%1.6.0-2",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character :",
+			data: TestForm{
+				BranchName: "debian:jessie",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character (whitespace)",
+			data: TestForm{
+				BranchName: "debian jessie",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+		{
+			description: "Reference name has unallowed special character [",
+			data: TestForm{
+				BranchName: "debian[jessie",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"BranchName"},
+					Classification: ErrGitRefName,
+					Message:        "GitRefName",
+				},
+			},
+		},
+	}
 
 	for _, testCase := range gitRefNameValidationTestCases {
 		t.Run(testCase.description, func(t *testing.T) {

modules/validation/regex_pattern_test.go

@@ -17,40 +17,40 @@ func getRegexPatternErrorString(pattern string) string {
 	return ""
 }
 
-var regexValidationTestCases = []validationTestCase{
-	{
-		description: "Empty regex pattern",
-		data: TestForm{
-			RegexPattern: "",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Valid regex",
-		data: TestForm{
-			RegexPattern: `(\d{1,3})+`,
-		},
-		expectedErrors: binding.Errors{},
-	},
-
-	{
-		description: "Invalid regex",
-		data: TestForm{
-			RegexPattern: "[a-",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"RegexPattern"},
-				Classification: ErrRegexPattern,
-				Message:        getRegexPatternErrorString("[a-"),
-			},
-		},
-	},
-}
-
 func Test_RegexPatternValidation(t *testing.T) {
 	AddBindingRules()
 
+	regexValidationTestCases := []validationTestCase{
+		{
+			description: "Empty regex pattern",
+			data: TestForm{
+				RegexPattern: "",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Valid regex",
+			data: TestForm{
+				RegexPattern: `(\d{1,3})+`,
+			},
+			expectedErrors: binding.Errors{},
+		},
+
+		{
+			description: "Invalid regex",
+			data: TestForm{
+				RegexPattern: "[a-",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"RegexPattern"},
+					Classification: ErrRegexPattern,
+					Message:        getRegexPatternErrorString("[a-"),
+				},
+			},
+		},
+	}
+
 	for _, testCase := range regexValidationTestCases {
 		t.Run(testCase.description, func(t *testing.T) {
 			performValidationTest(t, testCase)

modules/validation/validurl_test.go

@@ -9,99 +9,99 @@ import (
 	"gitea.com/go-chi/binding"
 )
 
-var urlValidationTestCases = []validationTestCase{
-	{
-		description: "Empty URL",
-		data: TestForm{
-			URL: "",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL without port",
-		data: TestForm{
-			URL: "http://test.lan/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL with port",
-		data: TestForm{
-			URL: "http://test.lan:3000/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL with IPv6 address without port",
-		data: TestForm{
-			URL: "http://[::1]/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL with IPv6 address with port",
-		data: TestForm{
-			URL: "http://[::1]:3000/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Invalid URL",
-		data: TestForm{
-			URL: "http//test.lan/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URL"},
-				Classification: binding.ERR_URL,
-				Message:        "Url",
-			},
-		},
-	},
-	{
-		description: "Invalid schema",
-		data: TestForm{
-			URL: "ftp://test.lan/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URL"},
-				Classification: binding.ERR_URL,
-				Message:        "Url",
-			},
-		},
-	},
-	{
-		description: "Invalid port",
-		data: TestForm{
-			URL: "http://test.lan:3x4/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URL"},
-				Classification: binding.ERR_URL,
-				Message:        "Url",
-			},
-		},
-	},
-	{
-		description: "Invalid port with IPv6 address",
-		data: TestForm{
-			URL: "http://[::1]:3x4/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URL"},
-				Classification: binding.ERR_URL,
-				Message:        "Url",
-			},
-		},
-	},
-}
-
 func Test_ValidURLValidation(t *testing.T) {
 	AddBindingRules()
 
+	urlValidationTestCases := []validationTestCase{
+		{
+			description: "Empty URL",
+			data: TestForm{
+				URL: "",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL without port",
+			data: TestForm{
+				URL: "http://test.lan/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL with port",
+			data: TestForm{
+				URL: "http://test.lan:3000/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL with IPv6 address without port",
+			data: TestForm{
+				URL: "http://[::1]/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL with IPv6 address with port",
+			data: TestForm{
+				URL: "http://[::1]:3000/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Invalid URL",
+			data: TestForm{
+				URL: "http//test.lan/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URL"},
+					Classification: binding.ERR_URL,
+					Message:        "Url",
+				},
+			},
+		},
+		{
+			description: "Invalid schema",
+			data: TestForm{
+				URL: "ftp://test.lan/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URL"},
+					Classification: binding.ERR_URL,
+					Message:        "Url",
+				},
+			},
+		},
+		{
+			description: "Invalid port",
+			data: TestForm{
+				URL: "http://test.lan:3x4/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URL"},
+					Classification: binding.ERR_URL,
+					Message:        "Url",
+				},
+			},
+		},
+		{
+			description: "Invalid port with IPv6 address",
+			data: TestForm{
+				URL: "http://[::1]:3x4/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URL"},
+					Classification: binding.ERR_URL,
+					Message:        "Url",
+				},
+			},
+		},
+	}
+
 	for _, testCase := range urlValidationTestCases {
 		t.Run(testCase.description, func(t *testing.T) {
 			performValidationTest(t, testCase)

modules/validation/validurllist_test.go

@@ -9,146 +9,146 @@ import (
 	"gitea.com/go-chi/binding"
 )
 
-// This is a copy of all the URL tests cases, plus additional ones to
-// account for multiple URLs
-var urlListValidationTestCases = []validationTestCase{
-	{
-		description: "Empty URL",
-		data: TestForm{
-			URLs: "",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL without port",
-		data: TestForm{
-			URLs: "http://test.lan/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL with port",
-		data: TestForm{
-			URLs: "http://test.lan:3000/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL with IPv6 address without port",
-		data: TestForm{
-			URLs: "http://[::1]/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "URL with IPv6 address with port",
-		data: TestForm{
-			URLs: "http://[::1]:3000/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Invalid URL",
-		data: TestForm{
-			URLs: "http//test.lan/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "http//test.lan/",
-			},
-		},
-	},
-	{
-		description: "Invalid schema",
-		data: TestForm{
-			URLs: "ftp://test.lan/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "ftp://test.lan/",
-			},
-		},
-	},
-	{
-		description: "Invalid port",
-		data: TestForm{
-			URLs: "http://test.lan:3x4/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "http://test.lan:3x4/",
-			},
-		},
-	},
-	{
-		description: "Invalid port with IPv6 address",
-		data: TestForm{
-			URLs: "http://[::1]:3x4/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "http://[::1]:3x4/",
-			},
-		},
-	},
-	{
-		description: "Multi URLs",
-		data: TestForm{
-			URLs: "http://test.lan:3000/\nhttp://test.local/",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "Multi URLs with newline",
-		data: TestForm{
-			URLs: "http://test.lan:3000/\nhttp://test.local/\n",
-		},
-		expectedErrors: binding.Errors{},
-	},
-	{
-		description: "List with invalid entry",
-		data: TestForm{
-			URLs: "http://test.lan:3000/\nhttp://[::1]:3x4/",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "http://[::1]:3x4/",
-			},
-		},
-	},
-	{
-		description: "List with two invalid entries",
-		data: TestForm{
-			URLs: "ftp://test.lan:3000/\nhttp://[::1]:3x4/\n",
-		},
-		expectedErrors: binding.Errors{
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "ftp://test.lan:3000/",
-			},
-			binding.Error{
-				FieldNames:     []string{"URLs"},
-				Classification: binding.ERR_URL,
-				Message:        "http://[::1]:3x4/",
-			},
-		},
-	},
-}
-
 func Test_ValidURLListValidation(t *testing.T) {
 	AddBindingRules()
 
+	// This is a copy of all the URL tests cases, plus additional ones to
+	// account for multiple URLs
+	urlListValidationTestCases := []validationTestCase{
+		{
+			description: "Empty URL",
+			data: TestForm{
+				URLs: "",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL without port",
+			data: TestForm{
+				URLs: "http://test.lan/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL with port",
+			data: TestForm{
+				URLs: "http://test.lan:3000/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL with IPv6 address without port",
+			data: TestForm{
+				URLs: "http://[::1]/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "URL with IPv6 address with port",
+			data: TestForm{
+				URLs: "http://[::1]:3000/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Invalid URL",
+			data: TestForm{
+				URLs: "http//test.lan/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "http//test.lan/",
+				},
+			},
+		},
+		{
+			description: "Invalid schema",
+			data: TestForm{
+				URLs: "ftp://test.lan/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "ftp://test.lan/",
+				},
+			},
+		},
+		{
+			description: "Invalid port",
+			data: TestForm{
+				URLs: "http://test.lan:3x4/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "http://test.lan:3x4/",
+				},
+			},
+		},
+		{
+			description: "Invalid port with IPv6 address",
+			data: TestForm{
+				URLs: "http://[::1]:3x4/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "http://[::1]:3x4/",
+				},
+			},
+		},
+		{
+			description: "Multi URLs",
+			data: TestForm{
+				URLs: "http://test.lan:3000/\nhttp://test.local/",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "Multi URLs with newline",
+			data: TestForm{
+				URLs: "http://test.lan:3000/\nhttp://test.local/\n",
+			},
+			expectedErrors: binding.Errors{},
+		},
+		{
+			description: "List with invalid entry",
+			data: TestForm{
+				URLs: "http://test.lan:3000/\nhttp://[::1]:3x4/",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "http://[::1]:3x4/",
+				},
+			},
+		},
+		{
+			description: "List with two invalid entries",
+			data: TestForm{
+				URLs: "ftp://test.lan:3000/\nhttp://[::1]:3x4/\n",
+			},
+			expectedErrors: binding.Errors{
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "ftp://test.lan:3000/",
+				},
+				binding.Error{
+					FieldNames:     []string{"URLs"},
+					Classification: binding.ERR_URL,
+					Message:        "http://[::1]:3x4/",
+				},
+			},
+		},
+	}
+
 	for _, testCase := range urlListValidationTestCases {
 		t.Run(testCase.description, func(t *testing.T) {
 			performValidationTest(t, testCase)

modules/web/middleware/flash.go

@@ -6,6 +6,7 @@ package middleware
 import (
 	"fmt"
 	"html/template"
+	"net/http"
 	"net/url"
 
 	"code.gitea.io/gitea/modules/reqctx"
@@ -65,3 +66,27 @@ func (f *Flash) Success(msg any, current ...bool) {
 	f.SuccessMsg = flashMsgStringOrHTML(msg)
 	f.set("success", f.SuccessMsg, current...)
 }
+
+func ParseCookieFlashMessage(val string) *Flash {
+	if vals, _ := url.ParseQuery(val); len(vals) > 0 {
+		return &Flash{
+			Values:     vals,
+			ErrorMsg:   vals.Get("error"),
+			SuccessMsg: vals.Get("success"),
+			InfoMsg:    vals.Get("info"),
+			WarningMsg: vals.Get("warning"),
+		}
+	}
+	return nil
+}
+
+func GetSiteCookieFlashMessage(dataStore reqctx.RequestDataStore, req *http.Request, cookieName string) (string, *Flash) {
+	// Get the last flash message from cookie
+	lastFlashCookie := GetSiteCookie(req, cookieName)
+	lastFlashMsg := ParseCookieFlashMessage(lastFlashCookie)
+	if lastFlashMsg != nil {
+		lastFlashMsg.DataStore = dataStore
+		return lastFlashCookie, lastFlashMsg
+	}
+	return lastFlashCookie, nil
+}

modules/web/middleware/request.go

@@ -1,14 +0,0 @@
-// Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package middleware
-
-import (
-	"net/http"
-	"strings"
-)
-
-// IsAPIPath returns true if the specified URL is an API path
-func IsAPIPath(req *http.Request) bool {
-	return strings.HasPrefix(req.URL.Path, "/api/")
-}