Replace deprecated math/rand functions (#30733)

Suggested by logs in #30729

- Remove `math/rand.Seed`
`rand.Seed is deprecated: As of Go 1.20 there is no reason to call Seed
with a random value.`
- Replace `math/rand.Read`
`rand.Read is deprecated: For almost all use cases, [crypto/rand.Read]
is more appropriate.`
- Replace `math/rand` with `math/rand/v2`, which is available since Go
1.22

.github/workflows/release-nightly.yml

@@ -49,7 +49,7 @@ jobs:
         run: |
           REF_NAME=$(echo "${{ github.ref }}" | sed -e 's/refs\/heads\///' -e 's/refs\/tags\///' -e 's/release\/v//')
           echo "Cleaned name is ${REF_NAME}"
-          echo "branch=${REF_NAME}-nightly" >> "$GITHUB_OUTPUT"
+          echo "branch=${REF_NAME}" >> "$GITHUB_OUTPUT"
       - name: configure aws
         uses: aws-actions/configure-aws-credentials@v4
         with:

CHANGELOG.md

@@ -4,172 +4,6 @@ This changelog goes through the changes that have been made in each release
 without substantial changes to our git log; to see the highlights of what has
 been added to each release, please refer to the [blog](https://blog.gitea.com).
 
-## [1.22.0](https://github.com/go-gitea/gitea/releases/tag/v1.22.0) - 2024-05-27
-
-This release stands as a monumental milestone in our development journey with a record-breaking incorporation of [1528](https://github.com/go-gitea/gitea/pulls?q=is%3Apr+milestone%3A1.22.0+is%3Amerged) pull requests. It marks the most extensive update in Gitea's history, showcasing a plethora of new features and infrastructure improvements.
-
-Noteworthy advancements in this release include the introduction of `HTMX` and `Tailwind`, signaling a strategic shift as we gradually phase out `jquery` and `Fomantic UI`. These changes reflect our commitment to embracing modern technologies and enhancing the user experience.
-
-Key highlights of this release encompass significant changes categorized under `BREAKING`, `FEATURES`, `ENHANCEMENTS`, and `PERFORMANCE`, each contributing to a more robust and efficient Gitea platform.
-
-* BREAKING
-  * Improve reverse proxy documents and clarify the AppURL guessing behavior (#31003) (#31020)
-  * Remember log in for a month by default (#30150)
-  * Breaking summary for template refactoring (#29395)
-    * All custom templates need to follow these changes
-  * Recommend/convert to use case-sensitive collation for MySQL/MSSQL (#28662)
-  * Make offline mode as default to not connect external avatar service by default (#28548)
-  * Include public repos in the doer's dashboard for issue search (#28304)
-  * Use restricted sanitizer for repository description (#28141)
-  * Support storage base path as prefix (#27827)
-  * Enhanced auth token / remember me (#27606)
-  * Rename the default themes to `gitea-light`, `gitea-dark`, `gitea-auto` (#27419)
-    * If you didn't see the new themes, please remove the `[ui].THEMES` config option from `app.ini`
-  * Require MySQL 8.0, PostgreSQL 12, MSSQL 2012 (#27337)
-* FEATURES
-  * Allow everyone to read or write a wiki by a repo unit setting (#30495)
-  * Use raw Wiki links for non-renderable Wiki files (#30273)
-  * Render embedded code preview by permalink in markdown (#30234) (#30249)
-  * Support repo code search without setting up an indexer (#29998)
-  * Support pasting URLs over markdown text (#29566)
-  * Allow to change primary email before account activation (#29412)
-  * Customizable "Open with" applications for repository clone (#29320)
-  * Allow options to disable user deletion from the interface on app.ini (#29275)
-  * Extend issue template YAML engine (#29274)
-  * Add support for `linguist-detectable` and `linguist-documentation` (#29267)
-  * Implement code frequency graph (#29191)
-  * Show commit status for releases (#29149)
-  * Add user blocking (#29028)
-  * Actions Artifacts v4 backend (#28965)
-  * Add merge style `fast-forward-only` (#28954)
-  * Retarget depending pulls when the parent branch is deleted (#28686)
-  * Add global setting on how timestamps should be rendered (#28657)
-  * Implement actions badge SVGs (#28102)
-  * Add skip ci functionality (#28075)
-  * Show latest commit for file (#28067)
-  * Allow to sync tags from the admin dashboard (#28045)
-  * Add Profile Readme for Organisations (#27955)
-  * Implement contributors graph (#27882)
-  * Artifact deletion in actions ui (#27172)
-  * Add API routes to get runner registration token (#27144)
-  * Add support for forking single branch (#25821)
-  * Add support for sha256 repositories (#23894)
-  * Add admin API route for managing user's badges (#23106)
-* ENHANCEMENTS
-  * Make gitea webhooks openproject compatible (#28435) (#31081)
-  * Support using label names when changing issue labels (#30943) (#30958)
-  * Fix various problems around project board view (#30696) (#30902)
-  * Improve context popup rendering (#30824) (#30829)
-  * Allow to save empty comment (#30706)
-  * Prevent allow/reject reviews on merged/closed PRs (#30686)
-  * Initial support for colorblindness-friendly themes (#30625)
-  * Some NuGet package enhancements (#30280) (#30324)
-  * Markup color and font size fixes (#30282) (#30310)
-  * Show 12 lines in markup code preview (#30255) (#30257)
-  * Add `[other].SHOW_FOOTER_POWERED_BY` setting to hide `Powered by` (#30253)
-  * Pulse page improvements (#30149)
-  * Render code tags in commit messages (#30146)
-  * Prevent re-review and dismiss review actions on closed and merged PRs (#30065)
-  * Cancel previous runs of the same PR automatically (#29961)
-  * Drag-and-drop improvements for projects and issue pins (#29875)
-  * Add default board to new projects, remove uncategorized pseudo-board (#29874)
-  * Prevent layout shift in `<overflow-menu>` items (#29831)
-  * Add skip ci support for pull request title (#29774)
-  * Add more stats tables (#29730)
-  * Update API to return 'source_id' for users (#29718)
-  * Determine fuzziness of bleve indexer by keyword length (#29706)
-  * Expose fuzzy search for issues/pulls (#29701)
-  * Put an edit file button on pull request files to allow a quick operation (#29697)
-  * Fix action runner offline label padding (#29691)
-  * Update allowed attachment types (#29688)
-  * Completely style the webkit autofill (#29683)
-  * Highlight archived labels (#29680)
-  * Add a warning for disallowed email domains (#29658)
-  * Set user's 24h preference from their current OS locale (#29651)
-  * Add setting to disable user features when user login type is not plain (#29615)
-  * Improve natural sort (#29611)
-  * Make wiki default branch name changeable (#29603)
-  * Unify search boxes (#29530)
-  * Add support for API blob upload of release attachments (#29507)
-  * Detect broken git hooks (#29494)
-  * Sync branches to DB immediately when handling git hook calling (#29493)
-  * Allow options to disable user GPG key configuration from the interface on app.ini (#29486)
-  * Allow options to disable user SSH key configuration from the interface on app.ini (#29447)
-  * Use relative links for commits, mentions, and issues in markdown (#29427)
-  * Add `<overflow-menu>`, rename webcomponents (#29400)
-  * Include resource state events in Gitlab downloads (#29382)
-  * Properly migrate target branch change GitLab comment (#29340)
-  * Recolor dark theme to blue shade (#29283)
-  * Partially enable MSSQL case-sensitive collation support (#29238)
-  * Auto-update the system status in the admin dashboard (#29163)
-  * Integrate alpine `noarch` packages into other architectures index (#29137)
-  * Document how the TOC election process works (#29135)
-  * Tweak repo header (#29134)
-  * Make blockquote border size less aggressive (#29124)
-  * Downscale pasted PNG images based on metadata (#29123)
-  * Show `View at this point in history` for every commit (#29122)
-  * Add support for action artifact serve direct (#29120)
-  * Change webhook-type in create-view (#29114)
-  * Drop "@" from the email sender to avoid spam filters (#29109)
-  * Allow non-admin users to delete review requests (#29057)
-  * Improve user search display name (#29002)
-  * Include username in email headers (#28981)
-  * Show whether a PR is WIP inside popups (#28975)
-  * Also match weakly validated ETags (#28957)
-  * Support nuspec manifest download for Nuget packages (#28921)
-  * Fix hardcoded GitHub icon used as migrated release avatar (#28910)
-  * Propagate install_if and provider_priority to APKINDEX (#28899)
-  * Add artifacts v4 JWT to job message and accept it (#28885)
-  * Enable/disable owner and repo projects independently (#28805)
-  * Add non-JS fallback for reaction tooltips (#28785)
-  * Add the ability to see open and closed issues at the same time (#28757)
-  * Move sign-in labels to be above inputs (#28753)
-  * Display the latest sync time for pull mirrors on the repo page (#28712)
-  * Show in Web UI if the file is vendored and generated (#28620)
-  * Add orphaned topic consistency check (#28507)
-  * Add branch protection setting for ignoring stale approvals (#28498)
-  * Add option to set language in admin user view (#28449)
-  * Fix incorrect run order of action jobs (#28367)
-  * Add missing exclusive in advanced label options (#28322)
-  * Added instance-level variables (#28115)
-  * Add edit option for README.md (#28071)
-  * Fix link to `Code` tab on wiki commits (#28041)
-  * Allow to set explore page default sort (#27951)
-  * Improve PR diff view on mobile (#27883)
-  * Properly migrate automatic merge GitLab comments (#27873)
-  * Display issue task list on project cards (#27865)
-  * Add Index to pull_auto_merge.doer_id (#27811)
-  * Fix display member unit in the menu bar if there are no hidden members in public org (#27795)
-  * List all Debian package versions in `Packages` (#27786)
-  * Allow pull requests Manually Merged option to be used by non-admins (#27780)
-  * Only show diff file tree when more than one file changed (#27775)
-  * Show placeholder email in privacy popup (#27770)
-  * Revamp repo header (#27760)
-  * Add `must-change-password` command line parameter (#27626)
-  * Unify password changing and invalidate auth tokens (#27625)
-  * Add border to file tree 'sub-items' and add padding to 'item-file' (#27593)
-  * Add slow SQL query warning (#27545)
-  * Pre-register OAuth application for tea (#27509)
-  * Differentiate between `push` and `pull` `mirror sync in progress` (#27390)
-  * Link to file from its history (#27354)
-  * Add a shortcut to user's profile page to admin user details (#27299)
-  * Doctor: delete action entries without existing user (#27292)
-  * Show total TrackedTime on issue/pull/milestone lists (#26672)
-  * Don't show the new pull request button when the page is not compare pull (#26431)
-  * Add `Hide/Show all checks` button to commit status check (#26284)
-  * Improvements of releases list and tags list (#25859)
-* PERFORMANCE
-  * Fix package list performance (#30520) (#30616)
-  * Add commit status summary table to reduce query from commit status table (#30223)
-  * Refactor markup/csv: don't read all to memory (#29760)
-  * Lazy load object format with command line and don't do it in OpenRepository (#29712)
-  * Add cache for branch divergence on branch list page (#29577)
-  * Do some performance optimization for issues list and view issue/pull (#29515)
-  * Cache repository default branch commit status to reduce query on commit status table (#29444)
-  * Use `crypto/sha256` (#29386)
-  * Some performance optimization on the dashboard and issues page (#29010)
-  * Add combined index for issue_user.uid and issue_id (#28080)
-
 ## [1.21.11](https://github.com/go-gitea/gitea/releases/tag/v1.21.11) - 2024-04-07
 
 * SECURITY

Dockerfile

@@ -1,5 +1,5 @@
 # Build stage
-FROM docker.io/library/golang:1.22-alpine3.20 AS build-env
+FROM docker.io/library/golang:1.22-alpine3.19 AS build-env
 
 ARG GOPROXY
 ENV GOPROXY ${GOPROXY:-direct}
@@ -41,7 +41,7 @@ RUN chmod 755 /tmp/local/usr/bin/entrypoint \
               /go/src/code.gitea.io/gitea/environment-to-ini
 RUN chmod 644 /go/src/code.gitea.io/gitea/contrib/autocompletion/bash_autocomplete
 
-FROM docker.io/library/alpine:3.20
+FROM docker.io/library/alpine:3.19
 LABEL maintainer="maintainers@gitea.io"
 
 EXPOSE 22 3000

Dockerfile.rootless

@@ -1,5 +1,5 @@
 # Build stage
-FROM docker.io/library/golang:1.22-alpine3.20 AS build-env
+FROM docker.io/library/golang:1.22-alpine3.19 AS build-env
 
 ARG GOPROXY
 ENV GOPROXY ${GOPROXY:-direct}
@@ -39,7 +39,7 @@ RUN chmod 755 /tmp/local/usr/local/bin/docker-entrypoint.sh \
               /go/src/code.gitea.io/gitea/environment-to-ini
 RUN chmod 644 /go/src/code.gitea.io/gitea/contrib/autocompletion/bash_autocomplete
 
-FROM docker.io/library/alpine:3.20
+FROM docker.io/library/alpine:3.19
 LABEL maintainer="maintainers@gitea.io"
 
 EXPOSE 2222 3000

Makefile

@@ -88,7 +88,7 @@ ifneq ($(GITHUB_REF_TYPE),branch)
 	GITEA_VERSION ?= $(VERSION)
 else
 	ifneq ($(GITHUB_REF_NAME),)
-		VERSION ?= $(subst release/v,,$(GITHUB_REF_NAME))-nightly
+		VERSION ?= $(subst release/v,,$(GITHUB_REF_NAME))
 	else
 		VERSION ?= main
 	endif
@@ -778,7 +778,7 @@ generate-backend: $(TAGS_PREREQ) generate-go
 .PHONY: generate-go
 generate-go: $(TAGS_PREREQ)
 	@echo "Running go generate..."
-	@CC= GOOS= GOARCH= CGO_ENABLED=0 $(GO) generate -tags '$(TAGS)' ./...
+	@CC= GOOS= GOARCH= $(GO) generate -tags '$(TAGS)' ./...
 
 .PHONY: security-check
 security-check:

cmd/hook.go

@@ -220,7 +220,10 @@ Gitea or set your environment appropriately.`, "")
 		}
 	}
 
-	supportProcReceive := git.DefaultFeatures().SupportProcReceive
+	supportProcReceive := false
+	if git.CheckGitVersionAtLeast("2.29") == nil {
+		supportProcReceive = true
+	}
 
 	for scanner.Scan() {
 		// TODO: support news feeds for wiki
@@ -338,7 +341,6 @@ Gitea or set your environment appropriately.`, "")
 	isWiki, _ := strconv.ParseBool(os.Getenv(repo_module.EnvRepoIsWiki))
 	repoName := os.Getenv(repo_module.EnvRepoName)
 	pusherID, _ := strconv.ParseInt(os.Getenv(repo_module.EnvPusherID), 10, 64)
-	prID, _ := strconv.ParseInt(os.Getenv(repo_module.EnvPRID), 10, 64)
 	pusherName := os.Getenv(repo_module.EnvPusherName)
 
 	hookOptions := private.HookOptions{
@@ -348,8 +350,6 @@ Gitea or set your environment appropriately.`, "")
 		GitObjectDirectory:              os.Getenv(private.GitObjectDirectory),
 		GitQuarantinePath:               os.Getenv(private.GitQuarantinePath),
 		GitPushOptions:                  pushOptions(),
-		PullRequestID:                   prID,
-		PushTrigger:                     repo_module.PushTrigger(os.Getenv(repo_module.EnvPushTrigger)),
 	}
 	oldCommitIDs := make([]string, hookBatchSize)
 	newCommitIDs := make([]string, hookBatchSize)
@@ -497,7 +497,7 @@ Gitea or set your environment appropriately.`, "")
 		return nil
 	}
 
-	if !git.DefaultFeatures().SupportProcReceive {
+	if git.CheckGitVersionAtLeast("2.29") != nil {
 		return fail(ctx, "No proc-receive support", "current git version doesn't support proc-receive.")
 	}
 

cmd/migrate_storage.go

@@ -34,7 +34,7 @@ var CmdMigrateStorage = &cli.Command{
 			Name:    "type",
 			Aliases: []string{"t"},
 			Value:   "",
-			Usage:   "Type of stored files to copy.  Allowed types: 'attachments', 'lfs', 'avatars', 'repo-avatars', 'repo-archivers', 'packages', 'actions-log', 'actions-artifacts",
+			Usage:   "Type of stored files to copy.  Allowed types: 'attachments', 'lfs', 'avatars', 'repo-avatars', 'repo-archivers', 'packages', 'actions-log'",
 		},
 		&cli.StringFlag{
 			Name:    "storage",
@@ -160,13 +160,6 @@ func migrateActionsLog(ctx context.Context, dstStorage storage.ObjectStorage) er
 	})
 }
 
-func migrateActionsArtifacts(ctx context.Context, dstStorage storage.ObjectStorage) error {
-	return db.Iterate(ctx, nil, func(ctx context.Context, artifact *actions_model.ActionArtifact) error {
-		_, err := storage.Copy(dstStorage, artifact.ArtifactPath, storage.ActionsArtifacts, artifact.ArtifactPath)
-		return err
-	})
-}
-
 func runMigrateStorage(ctx *cli.Context) error {
 	stdCtx, cancel := installSignals()
 	defer cancel()
@@ -230,14 +223,13 @@ func runMigrateStorage(ctx *cli.Context) error {
 	}
 
 	migratedMethods := map[string]func(context.Context, storage.ObjectStorage) error{
-		"attachments":       migrateAttachments,
-		"lfs":               migrateLFS,
-		"avatars":           migrateAvatars,
-		"repo-avatars":      migrateRepoAvatars,
-		"repo-archivers":    migrateRepoArchivers,
-		"packages":          migratePackages,
-		"actions-log":       migrateActionsLog,
-		"actions-artifacts": migrateActionsArtifacts,
+		"attachments":    migrateAttachments,
+		"lfs":            migrateLFS,
+		"avatars":        migrateAvatars,
+		"repo-avatars":   migrateRepoAvatars,
+		"repo-archivers": migrateRepoArchivers,
+		"packages":       migratePackages,
+		"actions-log":    migrateActionsLog,
 	}
 
 	tp := strings.ToLower(ctx.String("type"))

cmd/serv.go

@@ -178,7 +178,7 @@ func runServ(c *cli.Context) error {
 	}
 
 	if len(words) < 2 {
-		if git.DefaultFeatures().SupportProcReceive {
+		if git.CheckGitVersionAtLeast("2.29") == nil {
 			// for AGit Flow
 			if cmd == "ssh_info" {
 				fmt.Print(`{"type":"gitea","version":1}`)

custom/conf/app.example.ini

@@ -2035,17 +2035,6 @@ LEVEL = Info
 ;;   or only create new users if UPDATE_EXISTING is set to false
 ;UPDATE_EXISTING = true
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Cleanup expired actions assets
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;[cron.cleanup_actions]
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;ENABLED = true
-;RUN_AT_START = true
-;SCHEDULE = @midnight
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Clean-up deleted branches

docs/content/administration/config-cheat-sheet.en-us.md

@@ -214,9 +214,9 @@ The following configuration set `Content-Type: application/vnd.android.package-a
 - `SITEMAP_PAGING_NUM`: **20**: Number of items that are displayed in a single subsitemap.
 - `GRAPH_MAX_COMMIT_NUM`: **100**: Number of maximum commits shown in the commit graph.
 - `CODE_COMMENT_LINES`: **4**: Number of line of codes shown for a code comment.
-- `DEFAULT_THEME`: **gitea-auto**: Set the default theme for the Gitea installation, custom themes could be provided by `{CustomPath}/public/assets/css/theme-*.css`.
+- `DEFAULT_THEME`: **gitea-auto**: Set the default theme for the Gitea installation, custom themes could be provided by "{CustomPath}/public/assets/css/theme-*.css".
 - `SHOW_USER_EMAIL`: **true**: Whether the email of the user should be shown in the Explore Users page.
-- `THEMES`: **_empty_**: All available themes by `{CustomPath}/public/assets/css/theme-*.css`. Allow users select personalized themes.
+- `THEMES`: **_empty_**: All available themes by "{CustomPath}/public/assets/css/theme-*.css". Allow users select personalized themes.
 - `MAX_DISPLAY_FILE_SIZE`: **8388608**: Max size of files to be displayed (default is 8MiB)
 - `AMBIGUOUS_UNICODE_DETECTION`: **true**: Detect ambiguous unicode characters in file contents and show warnings on the UI
 - `REACTIONS`: All available reactions users can choose on issues/prs and comments
@@ -974,20 +974,12 @@ Default templates for project boards:
 - `SCHEDULE`: **@midnight** : Interval as a duration between each synchronization, it will always attempt synchronization when the instance starts.
 - `UPDATE_EXISTING`: **true**: Create new users, update existing user data and disable users that are not in external source anymore (default) or only create new users if UPDATE_EXISTING is set to false.
 
-#### Cron - Cleanup Expired Actions Assets (`cron.cleanup_actions`)
+## Cron - Cleanup Expired Actions Assets (`cron.cleanup_actions`)
 
 - `ENABLED`: **true**: Enable cleanup expired actions assets job.
 - `RUN_AT_START`: **true**: Run job at start time (if ENABLED).
 - `SCHEDULE`: **@midnight** : Cron syntax for the job.
 
-#### Cron - Cleanup Deleted Branches (`cron.deleted_branches_cleanup`)
-
-- `ENABLED`: **true**: Enable deleted branches cleanup.
-- `RUN_AT_START`: **true**: Run job at start time (if ENABLED).
-- `NOTICE_ON_SUCCESS`: **false**: Set to true to log a success message.
-- `SCHEDULE`: **@midnight**: Cron syntax for scheduling deleted branches cleanup.
-- `OLDER_THAN`: **24h**: Branches deleted OLDER_THAN ago will be cleaned up.
-
 ### Extended cron tasks (not enabled by default)
 
 #### Cron - Garbage collect all repositories (`cron.git_gc_repos`)

docs/content/administration/config-cheat-sheet.zh-cn.md

@@ -212,9 +212,9 @@ menu:
 - `SITEMAP_PAGING_NUM`: **20**: 在单个子SiteMap中显示的项数。
 - `GRAPH_MAX_COMMIT_NUM`: **100**: 提交图中显示的最大commit数量。
 - `CODE_COMMENT_LINES`: **4**: 在代码评论中能够显示的最大代码行数。
-- `DEFAULT_THEME`: **gitea-auto**: 在Gitea安装时候设置的默认主题，自定义的主题可以通过 `{CustomPath}/public/assets/css/theme-*.css` 提供。
+- `DEFAULT_THEME`: **gitea-auto**: 在Gitea安装时候设置的默认主题，自定义的主题可以通过 "{CustomPath}/public/assets/css/theme-*.css" 提供。
 - `SHOW_USER_EMAIL`: **true**: 用户的电子邮件是否应该显示在`Explore Users`页面中。
-- `THEMES`:  **_empty_**: 所有可用的主题（由 `{CustomPath}/public/assets/css/theme-*.css` 提供）。允许用户选择个性化的主题，
+- `THEMES`:  **_empty_**: 所有可用的主题（由 "{CustomPath}/public/assets/css/theme-*.css" 提供）。允许用户选择个性化的主题，
 - `MAX_DISPLAY_FILE_SIZE`: **8388608**: 能够显示文件的最大大小（默认为8MiB）。
 - `REACTIONS`: 用户可以在问题（Issue）、Pull Request（PR）以及评论中选择的所有可选的反应。
     这些值可以是表情符号别名（例如：:smile:）或Unicode表情符号。

docs/content/administration/reverse-proxies.en-us.md

@@ -17,35 +17,15 @@ menu:
 
 # Reverse Proxies
 
-## General configuration
-
-1. Set `[server] ROOT_URL = https://git.example.com/` in your `app.ini` file.
-2. Make the reverse-proxy pass `https://git.example.com/foo` to `http://gitea:3000/foo`.
-3. Make sure the reverse-proxy does not decode the URI. The request `https://git.example.com/a%2Fb` should be passed as `http://gitea:3000/a%2Fb`.
-4. Make sure `Host` and `X-Fowarded-Proto` headers are correctly passed to Gitea to make Gitea see the real URL being visited.
-
-### Use a sub-path
-
-Usually it's **not recommended** to put Gitea in a sub-path, it's not widely used and may have some issues in rare cases.
-
-To make Gitea work with a sub-path (eg: `https://common.example.com/gitea/`),
-there are some extra requirements besides the general configuration above:
-
-1. Use `[server] ROOT_URL = https://common.example.com/gitea/` in your `app.ini` file.
-2. Make the reverse-proxy pass `https://common.example.com/gitea/foo` to `http://gitea:3000/foo`.
-3. The container registry requires a fixed sub-path `/v2` at the root level which must be configured:
-   - Make the reverse-proxy pass `https://common.example.com/v2` to `http://gitea:3000/v2`.
-   - Make sure the URI and headers are also correctly passed (see the general configuration above).
-
 ## Nginx
 
-If you want Nginx to serve your Gitea instance, add the following `server` section to the `http` section of `nginx.conf`.
+If you want Nginx to serve your Gitea instance, add the following `server` section to the `http` section of `nginx.conf`:
 
-Make sure `client_max_body_size` is large enough, otherwise there would be "413 Request Entity Too Large" error when uploading large files.
-
-```nginx
+```
 server {
-    ...
+    listen 80;
+    server_name git.example.com;
+
     location / {
         client_max_body_size 512M;
         proxy_pass http://localhost:3000;
@@ -59,35 +39,37 @@ server {
 }
 ```
 
+### Resolving Error: 413 Request Entity Too Large
+
+This error indicates nginx is configured to restrict the file upload size,
+it affects attachment uploading, form posting, package uploading and LFS pushing, etc.
+You can fine tune the `client_max_body_size` option according to [nginx document](http://nginx.org/en/docs/http/ngx_http_core_module.html#client_max_body_size).
+
 ## Nginx with a sub-path
 
-In case you already have a site, and you want Gitea to share the domain name,
-you can setup Nginx to serve Gitea under a sub-path by adding the following `server` section
-into the `http` section of `nginx.conf`:
+In case you already have a site, and you want Gitea to share the domain name, you can setup Nginx to serve Gitea under a sub-path by adding the following `server` section inside the `http` section of `nginx.conf`:
 
-```nginx
+```
 server {
-    ...
-    location ~ ^/(gitea|v2)($|/) {
+    listen 80;
+    server_name git.example.com;
+
+    # Note: Trailing slash
+    location /gitea/ {
         client_max_body_size 512M;
 
-        # make nginx use unescaped URI, keep "%2F" as-is, remove the "/gitea" sub-path prefix, pass "/v2" as-is.
+        # make nginx use unescaped URI, keep "%2F" as is
         rewrite ^ $request_uri;
-        rewrite ^(/gitea)?(/.*) $2 break;
+        rewrite ^/gitea(/.*) $1 break;
         proxy_pass http://127.0.0.1:3000$uri;
 
         # other common HTTP headers, see the "Nginx" config section above
-        proxy_set_header Connection $http_connection;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header ...
     }
 }
 ```
 
-Then you **MUST** set something like `[server] ROOT_URL = http://git.example.com/gitea/` correctly in your configuration.
+Then you **MUST** set something like `[server] ROOT_URL = http://git.example.com/git/` correctly in your configuration.
 
 ## Nginx and serve static resources directly
 
@@ -111,7 +93,7 @@ or use a cdn for the static files.
 
 Set `[server] STATIC_URL_PREFIX = /_/static` in your configuration.
 
-```nginx
+```apacheconf
 server {
     listen 80;
     server_name git.example.com;
@@ -130,7 +112,7 @@ server {
 
 Set `[server] STATIC_URL_PREFIX = http://cdn.example.com/gitea` in your configuration.
 
-```nginx
+```apacheconf
 # application server running Gitea
 server {
     listen 80;
@@ -142,7 +124,7 @@ server {
 }
 ```
 
-```nginx
+```apacheconf
 # static content delivery server
 server {
     listen 80;
@@ -169,8 +151,6 @@ If you want Apache HTTPD to serve your Gitea instance, you can add the following
     ProxyRequests off
     AllowEncodedSlashes NoDecode
     ProxyPass / http://localhost:3000/ nocanon
-    ProxyPreserveHost On
-    RequestHeader set "X-Forwarded-Proto" expr=%{REQUEST_SCHEME}
 </VirtualHost>
 ```
 
@@ -192,8 +172,6 @@ In case you already have a site, and you want Gitea to share the domain name, yo
     AllowEncodedSlashes NoDecode
     # Note: no trailing slash after either /git or port
     ProxyPass /git http://localhost:3000 nocanon
-    ProxyPreserveHost On
-    RequestHeader set "X-Forwarded-Proto" expr=%{REQUEST_SCHEME}
 </VirtualHost>
 ```
 
@@ -205,7 +183,7 @@ Note: The following Apache HTTPD mods must be enabled: `proxy`, `proxy_http`.
 
 If you want Caddy to serve your Gitea instance, you can add the following server block to your Caddyfile:
 
-```
+```apacheconf
 git.example.com {
     reverse_proxy localhost:3000
 }
@@ -215,7 +193,7 @@ git.example.com {
 
 In case you already have a site, and you want Gitea to share the domain name, you can setup Caddy to serve Gitea under a sub-path by adding the following to your server block in your Caddyfile:
 
-```
+```apacheconf
 git.example.com {
     route /git/* {
         uri strip_prefix /git
@@ -393,3 +371,19 @@ gitea:
 This config assumes that you are handling HTTPS on the traefik side and using HTTP between Gitea and traefik.
 
 Then you **MUST** set something like `[server] ROOT_URL = http://example.com/gitea/` correctly in your configuration.
+
+## General sub-path configuration
+
+Usually it's not recommended to put Gitea in a sub-path, it's not widely used and may have some issues in rare cases.
+
+If you really need to do so, to make Gitea works with sub-path (eg: `http://example.com/gitea/`), here are the requirements:
+
+1. Set `[server] ROOT_URL = http://example.com/gitea/` in your `app.ini` file.
+2. Make the reverse-proxy pass `http://example.com/gitea/foo` to `http://gitea-server:3000/foo`.
+3. Make sure the reverse-proxy not decode the URI, the request `http://example.com/gitea/a%2Fb` should be passed as `http://gitea-server:3000/a%2Fb`.
+
+## Docker / Container Registry
+
+The container registry uses a fixed sub-path `/v2` which can't be changed.
+Even if you deploy Gitea with a different sub-path, `/v2` will be used by the `docker` client.
+Therefore you may need to add an additional route to your reverse proxy configuration.

docs/content/usage/actions/comparison.en-us.md

@@ -108,10 +108,6 @@ See [Creating an annotation for an error](https://docs.github.com/en/actions/usi
 
 It's ignored by Gitea Actions now.
 
-### Expressions
-
-For [expressions](https://docs.github.com/en/actions/learn-github-actions/expressions), only [`always()`](https://docs.github.com/en/actions/learn-github-actions/expressions#always) is supported.
-
 ## Missing UI features
 
 ### Pre and Post steps

docs/content/usage/actions/comparison.zh-cn.md

@@ -108,10 +108,6 @@ Gitea Actions目前不支持此功能。
 
 Gitea Actions目前不支持此功能。
 
-### 表达式
-
-对于 [表达式](https://docs.github.com/en/actions/learn-github-actions/expressions), 当前仅 [`always()`](https://docs.github.com/en/actions/learn-github-actions/expressions#always) 被支持。
-
 ## 缺失的UI功能
 
 ### 预处理和后处理步骤

docs/content/usage/packages/npm.en-us.md

@@ -30,7 +30,7 @@ The following examples use the `npm` tool with the scope `@test`.
 To register the package registry you need to configure a new package source.
 
 ```shell
-npm config set {scope}:registry=https://gitea.example.com/api/packages/{owner}/npm/
+npm config set {scope}:registry https://gitea.example.com/api/packages/{owner}/npm/
 npm config set -- '//gitea.example.com/api/packages/{owner}/npm/:_authToken' "{token}"
 ```
 
@@ -43,7 +43,7 @@ npm config set -- '//gitea.example.com/api/packages/{owner}/npm/:_authToken' "{t
 For example:
 
 ```shell
-npm config set @test:registry=https://gitea.example.com/api/packages/testuser/npm/
+npm config set @test:registry https://gitea.example.com/api/packages/testuser/npm/
 npm config set -- '//gitea.example.com/api/packages/testuser/npm/:_authToken' "personal_access_token"
 ```
 

docs/content/usage/packages/npm.zh-cn.md

@@ -30,7 +30,7 @@ menu:
 要注册软件包注册表，您需要配置一个新的软件包源。
 
 ```shell
-npm config set {scope}:registry=https://gitea.example.com/api/packages/{owner}/npm/
+npm config set {scope}:registry https://gitea.example.com/api/packages/{owner}/npm/
 npm config set -- '//gitea.example.com/api/packages/{owner}/npm/:_authToken' "{token}"
 ```
 
@@ -43,7 +43,7 @@ npm config set -- '//gitea.example.com/api/packages/{owner}/npm/:_authToken' "{t
 例如：
 
 ```shell
-npm config set @test:registry=https://gitea.example.com/api/packages/testuser/npm/
+npm config set @test:registry https://gitea.example.com/api/packages/testuser/npm/
 npm config set -- '//gitea.example.com/api/packages/testuser/npm/:_authToken' "personal_access_token"
 ```
 

docs/content/usage/repo-mirror.en-us.md

@@ -58,7 +58,7 @@ The repository now gets mirrored periodically to the remote repository. You can
 
 To set up a mirror from Gitea to GitHub, you need to follow these steps:
 
-1. Create a [GitHub personal access token](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) with the *public_repo* box checked. Also check the **workflow** checkbox in case your repo uses GitHub Actions for continuous integration.
+1. Create a [GitHub personal access token](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) with the *public_repo* box checked. Also check the **workflow** checkbox in case your repo using act for continuous integration.
 2. Create a repository with that name on GitHub. Unlike Gitea, GitHub does not support creating repositories by pushing to the remote. You can also use an existing remote repo if it has the same commit history as your Gitea repo.
 3. In the settings of your Gitea repo, fill in the **Git Remote Repository URL**: `https://github.com/<your_github_group>/<your_github_project>.git`.
 4. Fill in the **Authorization** fields with your GitHub username and the personal access token as **Password**.
@@ -91,10 +91,10 @@ The repository pushes shortly thereafter. To force a push, select the **Synchron
 
 ### Mirror an existing ssh repository
 
-Currently Gitea supports no ssh push mirrors. You can work around this by adding a `post-receive` hook to your Gitea repository that pushes manually.
+Currently gitea supports no ssh push mirrors. You can work around this by adding a `post-receive` hook to your gitea repository that pushes manually.
 
-1. Make sure the user running Gitea has access to the git repo you are trying to mirror to from shell.
-2. On the web interface at the repository settings > git hooks add a post-receive hook for the mirror. I.e.
+1. Make sure the user running gitea has access to the git repo you are trying to mirror to from shell.
+2. On the Webinterface at the repository settings > git hooks add a post-receive hook for the mirror. I.e.
 
 ```
 #!/usr/bin/env bash

go.mod

@@ -8,7 +8,7 @@ require (
 	code.gitea.io/sdk/gitea v0.17.1
 	codeberg.org/gusted/mcaptcha v0.0.0-20220723083913-4f3072e1d570
 	connectrpc.com/connect v1.15.0
-	gitea.com/go-chi/binding v0.0.0-20240430071103-39a851e106ed
+	gitea.com/go-chi/binding v0.0.0-20240316035258-17450c5f3028
 	gitea.com/go-chi/cache v0.2.0
 	gitea.com/go-chi/captcha v0.0.0-20240315150714-fb487f629098
 	gitea.com/go-chi/session v0.0.0-20240316035857-16768d98ec96

go.sum

@@ -20,8 +20,8 @@ git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078 h1:cliQ4H
 git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078/go.mod h1:g/V2Hjas6Z1UHUp4yIx6bATpNzJ7DYtD0FG3+xARWxs=
 gitea.com/gitea/act v0.259.1 h1:8GG1o/xtUHl3qjn5f0h/2FXrT5ubBn05TJOM5ry+FBw=
 gitea.com/gitea/act v0.259.1/go.mod h1:UxZWRYqQG2Yj4+4OqfGWW5a3HELwejyWFQyU7F1jUD8=
-gitea.com/go-chi/binding v0.0.0-20240430071103-39a851e106ed h1:EZZBtilMLSZNWtHHcgq2mt6NSGhJSZBuduAlinMEmso=
-gitea.com/go-chi/binding v0.0.0-20240430071103-39a851e106ed/go.mod h1:E3i3cgB04dDx0v3CytCgRTTn9Z/9x891aet3r456RVw=
+gitea.com/go-chi/binding v0.0.0-20240316035258-17450c5f3028 h1:6/QAx4+s0dyRwdaTFPTnhGppuiuu0OqxIH9szyTpvKw=
+gitea.com/go-chi/binding v0.0.0-20240316035258-17450c5f3028/go.mod h1:E3i3cgB04dDx0v3CytCgRTTn9Z/9x891aet3r456RVw=
 gitea.com/go-chi/cache v0.2.0 h1:E0npuTfDW6CT1yD8NMDVc1SK6IeRjfmRL2zlEsCEd7w=
 gitea.com/go-chi/cache v0.2.0/go.mod h1:iQlVK2aKTZ/rE9UcHyz9pQWGvdP9i1eI2spOpzgCrtE=
 gitea.com/go-chi/captcha v0.0.0-20240315150714-fb487f629098 h1:p2ki+WK0cIeNQuqjR98IP2KZQKRzJJiV7aTeMAFwaWo=

models/activities/action.go

@@ -524,12 +524,7 @@ func activityQueryCondition(ctx context.Context, opts GetFeedsOptions) (builder.
 	}
 
 	if opts.RequestedRepo != nil {
-		// repo's actions could have duplicate items, see the comment of NotifyWatchers
-		// so here we only filter the "original items", aka: user_id == act_user_id
-		cond = cond.And(
-			builder.Eq{"`action`.repo_id": opts.RequestedRepo.ID},
-			builder.Expr("`action`.user_id = `action`.act_user_id"),
-		)
+		cond = cond.And(builder.Eq{"repo_id": opts.RequestedRepo.ID})
 	}
 
 	if opts.RequestedTeam != nil {
@@ -582,10 +577,6 @@ func DeleteOldActions(ctx context.Context, olderThan time.Duration) (err error)
 }
 
 // NotifyWatchers creates batch of actions for every watcher.
-// It could insert duplicate actions for a repository action, like this:
-// * Original action: UserID=1 (the real actor), ActUserID=1
-// * Organization action: UserID=100 (the repo's org), ActUserID=1
-// * Watcher action: UserID=20 (a user who is watching a repo), ActUserID=1
 func NotifyWatchers(ctx context.Context, actions ...*Action) error {
 	var watchers []*repo_model.Watch
 	var repo *repo_model.Repository

models/activities/action_test.go

@@ -318,24 +318,3 @@ func TestDeleteIssueActions(t *testing.T) {
 	assert.NoError(t, activities_model.DeleteIssueActions(db.DefaultContext, issue.RepoID, issue.ID, issue.Index))
 	unittest.AssertCount(t, &activities_model.Action{}, 0)
 }
-
-func TestRepoActions(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	_ = db.TruncateBeans(db.DefaultContext, &activities_model.Action{})
-	for i := 0; i < 3; i++ {
-		_ = db.Insert(db.DefaultContext, &activities_model.Action{
-			UserID:    2 + int64(i),
-			ActUserID: 2,
-			RepoID:    repo.ID,
-			OpType:    activities_model.ActionCommentIssue,
-		})
-	}
-	count, _ := db.Count[activities_model.Action](db.DefaultContext, &db.ListOptions{})
-	assert.EqualValues(t, 3, count)
-	actions, _, err := activities_model.GetFeeds(db.DefaultContext, activities_model.GetFeedsOptions{
-		RequestedRepo: repo,
-	})
-	assert.NoError(t, err)
-	assert.Len(t, actions, 1)
-}

models/db/engine.go

@@ -57,7 +57,6 @@ type Engine interface {
 	SumInt(bean any, columnName string) (res int64, err error)
 	Sync(...any) error
 	Select(string) *xorm.Session
-	SetExpr(string, any) *xorm.Session
 	NotIn(string, ...any) *xorm.Session
 	OrderBy(any, ...any) *xorm.Session
 	Exist(...any) (bool, error)

models/fixtures/branch.yml

@@ -45,39 +45,3 @@
   is_deleted: false
   deleted_by_id: 0
   deleted_unix: 0
-
--
-  id: 5
-  repo_id: 10
-  name: 'master'
-  commit_id: '65f1bf27bc3bf70f64657658635e66094edbcb4d'
-  commit_message: 'Initial commit'
-  commit_time: 1489927679
-  pusher_id: 12
-  is_deleted: false
-  deleted_by_id: 0
-  deleted_unix: 0
-
--
-  id: 6
-  repo_id: 10
-  name: 'outdated-new-branch'
-  commit_id: 'cb24c347e328d83c1e0c3c908a6b2c0a2fcb8a3d'
-  commit_message: 'add'
-  commit_time: 1489927679
-  pusher_id: 12
-  is_deleted: false
-  deleted_by_id: 0
-  deleted_unix: 0
-
--
-  id: 14
-  repo_id: 11
-  name: 'master'
-  commit_id: '65f1bf27bc3bf70f64657658635e66094edbcb4d'
-  commit_message: 'Initial commit'
-  commit_time: 1489927679
-  pusher_id: 13
-  is_deleted: false
-  deleted_by_id: 0
-  deleted_unix: 0

models/fixtures/issue_index.yml

@@ -1,35 +1,27 @@
 -
   group_id: 1
   max_index: 5
-
 -
   group_id: 2
   max_index: 2
-
 -
   group_id: 3
   max_index: 2
-
 -
   group_id: 10
   max_index: 1
-
 -
   group_id: 32
   max_index: 2
-
 -
   group_id: 48
   max_index: 1
-
 -
   group_id: 42
   max_index: 1
-
 -
   group_id: 50
   max_index: 1
-
 -
   group_id: 51
   max_index: 1

models/fixtures/org_user.yml

@@ -117,15 +117,3 @@
   uid: 40
   org_id: 41
   is_public: true
-
--
-  id: 21
-  uid: 12
-  org_id: 25
-  is_public: true
-
--
-  id: 22
-  uid: 2
-  org_id: 35
-  is_public: true

models/fixtures/protected_tag.yml

@@ -1,24 +0,0 @@
--
-  id: 1
-  repo_id: 4
-  name_pattern: /v.+/
-  allowlist_user_i_ds: []
-  allowlist_team_i_ds: []
-  created_unix: 1715596037
-  updated_unix: 1715596037
--
-  id: 2
-  repo_id: 1
-  name_pattern: v-*
-  allowlist_user_i_ds: []
-  allowlist_team_i_ds: []
-  created_unix: 1715596037
-  updated_unix: 1715596037
--
-  id: 3
-  repo_id: 1
-  name_pattern: v-1.1
-  allowlist_user_i_ds: [2]
-  allowlist_team_i_ds: []
-  created_unix: 1715596037
-  updated_unix: 1715596037

models/fixtures/repository.yml

@@ -327,7 +327,7 @@
   is_archived: false
   is_mirror: false
   status: 0
-  is_fork: true
+  is_fork: false
   fork_id: 10
   is_template: false
   template_id: 0

models/fixtures/team.yml

@@ -239,25 +239,3 @@
   num_members: 2
   includes_all_repositories: false
   can_create_org_repo: false
-
--
-  id: 23
-  org_id: 25
-  lower_name: owners
-  name: Owners
-  authorize: 4 # owner
-  num_repos: 0
-  num_members: 1
-  includes_all_repositories: false
-  can_create_org_repo: true
-
--
-  id: 24
-  org_id: 35
-  lower_name: team24
-  name: team24
-  authorize: 2 # write
-  num_repos: 0
-  num_members: 1
-  includes_all_repositories: true
-  can_create_org_repo: false

models/fixtures/team_unit.yml

@@ -322,21 +322,3 @@
   team_id: 22
   type: 3
   access_mode: 1
-
--
-  id: 55
-  team_id: 18
-  type: 1 # code
-  access_mode: 4
-
--
-  id: 56
-  team_id: 23
-  type: 1 # code
-  access_mode: 4
-
--
-  id: 57
-  team_id: 24
-  type: 1 # code
-  access_mode: 2

models/fixtures/team_user.yml

@@ -147,15 +147,3 @@
   org_id: 41
   team_id: 22
   uid: 39
-
--
-  id: 26
-  org_id: 25
-  team_id: 23
-  uid: 12
-
--
-  id: 27
-  org_id: 35
-  team_id: 24
-  uid: 2

models/fixtures/user.yml

@@ -918,8 +918,8 @@
   num_following: 0
   num_stars: 0
   num_repos: 0
-  num_teams: 2
-  num_members: 2
+  num_teams: 1
+  num_members: 1
   visibility: 0
   repo_admin_change_team_access: false
   theme: ""
@@ -1289,8 +1289,8 @@
   num_following: 0
   num_stars: 0
   num_repos: 0
-  num_teams: 2
-  num_members: 2
+  num_teams: 1
+  num_members: 1
   visibility: 2
   repo_admin_change_team_access: false
   theme: ""

models/git/branch.go

@@ -10,11 +10,9 @@ import (
 
 	"code.gitea.io/gitea/models/db"
 	repo_model "code.gitea.io/gitea/models/repo"
-	"code.gitea.io/gitea/models/unit"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
-	"code.gitea.io/gitea/modules/optional"
 	"code.gitea.io/gitea/modules/timeutil"
 	"code.gitea.io/gitea/modules/util"
 
@@ -104,9 +102,8 @@ func (err ErrBranchesEqual) Unwrap() error {
 // for pagination, keyword search and filtering
 type Branch struct {
 	ID            int64
-	RepoID        int64                  `xorm:"UNIQUE(s)"`
-	Repo          *repo_model.Repository `xorm:"-"`
-	Name          string                 `xorm:"UNIQUE(s) NOT NULL"` // git's ref-name is case-sensitive internally, however, in some databases (mssql, mysql, by default), it's case-insensitive at the moment
+	RepoID        int64  `xorm:"UNIQUE(s)"`
+	Name          string `xorm:"UNIQUE(s) NOT NULL"` // git's ref-name is case-sensitive internally, however, in some databases (mssql, mysql, by default), it's case-insensitive at the moment
 	CommitID      string
 	CommitMessage string `xorm:"TEXT"` // it only stores the message summary (the first line)
 	PusherID      int64
@@ -142,14 +139,6 @@ func (b *Branch) LoadPusher(ctx context.Context) (err error) {
 	return err
 }
 
-func (b *Branch) LoadRepo(ctx context.Context) (err error) {
-	if b.Repo != nil || b.RepoID == 0 {
-		return nil
-	}
-	b.Repo, err = repo_model.GetRepositoryByID(ctx, b.RepoID)
-	return err
-}
-
 func init() {
 	db.RegisterModel(new(Branch))
 	db.RegisterModel(new(RenamedBranch))
@@ -411,111 +400,24 @@ func RenameBranch(ctx context.Context, repo *repo_model.Repository, from, to str
 	return committer.Commit()
 }
 
-type FindRecentlyPushedNewBranchesOptions struct {
-	Repo            *repo_model.Repository
-	BaseRepo        *repo_model.Repository
-	CommitAfterUnix int64
-	MaxCount        int
-}
-
-type RecentlyPushedNewBranch struct {
-	BranchDisplayName string
-	BranchLink        string
-	BranchCompareURL  string
-	CommitTime        timeutil.TimeStamp
-}
-
-// FindRecentlyPushedNewBranches return at most 2 new branches pushed by the user in 2 hours which has no opened PRs created
-// if opts.CommitAfterUnix is 0, we will find the branches that were committed to in the last 2 hours
-// if opts.ListOptions is not set, we will only display top 2 latest branch
-func FindRecentlyPushedNewBranches(ctx context.Context, doer *user_model.User, opts *FindRecentlyPushedNewBranchesOptions) ([]*RecentlyPushedNewBranch, error) {
-	if doer == nil {
-		return []*RecentlyPushedNewBranch{}, nil
-	}
-
-	// find all related repo ids
-	repoOpts := repo_model.SearchRepoOptions{
-		Actor:      doer,
-		Private:    true,
-		AllPublic:  false, // Include also all public repositories of users and public organisations
-		AllLimited: false, // Include also all public repositories of limited organisations
-		Fork:       optional.Some(true),
-		ForkFrom:   opts.BaseRepo.ID,
-		Archived:   optional.Some(false),
-	}
-	repoCond := repo_model.SearchRepositoryCondition(&repoOpts).And(repo_model.AccessibleRepositoryCondition(doer, unit.TypeCode))
-	if opts.Repo.ID == opts.BaseRepo.ID {
-		// should also include the base repo's branches
-		repoCond = repoCond.Or(builder.Eq{"id": opts.BaseRepo.ID})
-	} else {
-		// in fork repo, we only detect the fork repo's branch
-		repoCond = repoCond.And(builder.Eq{"id": opts.Repo.ID})
-	}
-	repoIDs := builder.Select("id").From("repository").Where(repoCond)
-
-	if opts.CommitAfterUnix == 0 {
-		opts.CommitAfterUnix = time.Now().Add(-time.Hour * 2).Unix()
-	}
-
-	baseBranch, err := GetBranch(ctx, opts.BaseRepo.ID, opts.BaseRepo.DefaultBranch)
-	if err != nil {
-		return nil, err
-	}
-
-	// find all related branches, these branches may already created PRs, we will check later
-	var branches []*Branch
-	if err := db.GetEngine(ctx).
-		Where(builder.And(
-			builder.Eq{
-				"pusher_id":  doer.ID,
-				"is_deleted": false,
-			},
-			builder.Gte{"commit_time": opts.CommitAfterUnix},
-			builder.In("repo_id", repoIDs),
-			// newly created branch have no changes, so skip them
-			builder.Neq{"commit_id": baseBranch.CommitID},
-		)).
-		OrderBy(db.SearchOrderByRecentUpdated.String()).
-		Find(&branches); err != nil {
-		return nil, err
-	}
-
-	newBranches := make([]*RecentlyPushedNewBranch, 0, len(branches))
-	if opts.MaxCount == 0 {
-		// by default we display 2 recently pushed new branch
-		opts.MaxCount = 2
-	}
-	for _, branch := range branches {
-		// whether branch have already created PR
-		count, err := db.GetEngine(ctx).Table("pull_request").
-			// we should not only use branch name here, because if there are branches with same name in other repos,
-			// we can not detect them correctly
-			Where(builder.Eq{"head_repo_id": branch.RepoID, "head_branch": branch.Name}).Count()
-		if err != nil {
-			return nil, err
-		}
-
-		// if no PR, we add to the result
-		if count == 0 {
-			if err := branch.LoadRepo(ctx); err != nil {
-				return nil, err
-			}
-
-			branchDisplayName := branch.Name
-			if branch.Repo.ID != opts.BaseRepo.ID && branch.Repo.ID != opts.Repo.ID {
-				branchDisplayName = fmt.Sprintf("%s:%s", branch.Repo.FullName(), branchDisplayName)
-			}
-			newBranches = append(newBranches, &RecentlyPushedNewBranch{
-				BranchDisplayName: branchDisplayName,
-				BranchLink:        fmt.Sprintf("%s/src/branch/%s", branch.Repo.Link(), util.PathEscapeSegments(branch.Name)),
-				BranchCompareURL:  branch.Repo.ComposeBranchCompareURL(opts.BaseRepo, branch.Name),
-				CommitTime:        branch.CommitTime,
-			})
-		}
-		if len(newBranches) == opts.MaxCount {
-			break
-		}
-	}
-
-	return newBranches, nil
+// FindRecentlyPushedNewBranches return at most 2 new branches pushed by the user in 6 hours which has no opened PRs created
+// except the indicate branch
+func FindRecentlyPushedNewBranches(ctx context.Context, repoID, userID int64, excludeBranchName string) (BranchList, error) {
+	branches := make(BranchList, 0, 2)
+	subQuery := builder.Select("head_branch").From("pull_request").
+		InnerJoin("issue", "issue.id = pull_request.issue_id").
+		Where(builder.Eq{
+			"pull_request.head_repo_id": repoID,
+			"issue.is_closed":           false,
+		})
+	err := db.GetEngine(ctx).
+		Where("pusher_id=? AND is_deleted=?", userID, false).
+		And("name <> ?", excludeBranchName).
+		And("repo_id = ?", repoID).
+		And("commit_time >= ?", time.Now().Add(-time.Hour*6).Unix()).
+		NotIn("name", subQuery).
+		OrderBy("branch.commit_time DESC").
+		Limit(2).
+		Find(&branches)
+	return branches, err
 }

models/git/branch_list.go

@@ -7,7 +7,6 @@ import (
 	"context"
 
 	"code.gitea.io/gitea/models/db"
-	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/container"
 	"code.gitea.io/gitea/modules/optional"
@@ -60,24 +59,6 @@ func (branches BranchList) LoadPusher(ctx context.Context) error {
 	return nil
 }
 
-func (branches BranchList) LoadRepo(ctx context.Context) error {
-	ids := container.FilterSlice(branches, func(branch *Branch) (int64, bool) {
-		return branch.RepoID, branch.RepoID > 0 && branch.Repo == nil
-	})
-
-	reposMap := make(map[int64]*repo_model.Repository, len(ids))
-	if err := db.GetEngine(ctx).In("id", ids).Find(&reposMap); err != nil {
-		return err
-	}
-	for _, branch := range branches {
-		if branch.RepoID <= 0 || branch.Repo != nil {
-			continue
-		}
-		branch.Repo = reposMap[branch.RepoID]
-	}
-	return nil
-}
-
 type FindBranchOptions struct {
 	db.ListOptions
 	RepoID             int64

models/git/commit_status.go

@@ -397,16 +397,36 @@ func GetLatestCommitStatusForRepoCommitIDs(ctx context.Context, repoID int64, co
 
 // FindRepoRecentCommitStatusContexts returns repository's recent commit status contexts
 func FindRepoRecentCommitStatusContexts(ctx context.Context, repoID int64, before time.Duration) ([]string, error) {
-	start := timeutil.TimeStampNow().AddDuration(-before)
+	type result struct {
+		Index int64
+		SHA   string
+	}
+	getBase := func() *xorm.Session {
+		return db.GetEngine(ctx).Table(&CommitStatus{}).Where("repo_id = ?", repoID)
+	}
 
-	var contexts []string
-	if err := db.GetEngine(ctx).Table("commit_status").
-		Where("repo_id = ?", repoID).And("updated_unix >= ?", start).
-		Cols("context").Distinct().Find(&contexts); err != nil {
+	start := timeutil.TimeStampNow().AddDuration(-before)
+	results := make([]result, 0, 10)
+
+	sess := getBase().And("updated_unix >= ?", start).
+		Select("max( `index` ) as `index`, sha").
+		GroupBy("context_hash, sha").OrderBy("max( `index` ) desc")
+
+	err := sess.Find(&results)
+	if err != nil {
 		return nil, err
 	}
 
-	return contexts, nil
+	contexts := make([]string, 0, len(results))
+	if len(results) == 0 {
+		return contexts, nil
+	}
+
+	conds := make([]builder.Cond, 0, len(results))
+	for _, result := range results {
+		conds = append(conds, builder.Eq{"`index`": result.Index, "sha": result.SHA})
+	}
+	return contexts, getBase().And(builder.Or(conds...)).Select("context").Find(&contexts)
 }
 
 // NewCommitStatusOptions holds options for creating a CommitStatus

models/git/commit_status_test.go

@@ -5,15 +5,11 @@ package git_test
 
 import (
 	"testing"
-	"time"
 
 	"code.gitea.io/gitea/models/db"
 	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
-	user_model "code.gitea.io/gitea/models/user"
-	"code.gitea.io/gitea/modules/git"
-	"code.gitea.io/gitea/modules/gitrepo"
 	"code.gitea.io/gitea/modules/structs"
 
 	"github.com/stretchr/testify/assert"
@@ -179,55 +175,3 @@ func Test_CalcCommitStatus(t *testing.T) {
 		assert.Equal(t, kase.expected, git_model.CalcCommitStatus(kase.statuses))
 	}
 }
-
-func TestFindRepoRecentCommitStatusContexts(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
-	user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-	gitRepo, err := gitrepo.OpenRepository(git.DefaultContext, repo2)
-	assert.NoError(t, err)
-	defer gitRepo.Close()
-
-	commit, err := gitRepo.GetBranchCommit(repo2.DefaultBranch)
-	assert.NoError(t, err)
-
-	defer func() {
-		_, err := db.DeleteByBean(db.DefaultContext, &git_model.CommitStatus{
-			RepoID:    repo2.ID,
-			CreatorID: user2.ID,
-			SHA:       commit.ID.String(),
-		})
-		assert.NoError(t, err)
-	}()
-
-	err = git_model.NewCommitStatus(db.DefaultContext, git_model.NewCommitStatusOptions{
-		Repo:    repo2,
-		Creator: user2,
-		SHA:     commit.ID,
-		CommitStatus: &git_model.CommitStatus{
-			State:     structs.CommitStatusFailure,
-			TargetURL: "https://example.com/tests/",
-			Context:   "compliance/lint-backend",
-		},
-	})
-	assert.NoError(t, err)
-
-	err = git_model.NewCommitStatus(db.DefaultContext, git_model.NewCommitStatusOptions{
-		Repo:    repo2,
-		Creator: user2,
-		SHA:     commit.ID,
-		CommitStatus: &git_model.CommitStatus{
-			State:     structs.CommitStatusSuccess,
-			TargetURL: "https://example.com/tests/",
-			Context:   "compliance/lint-backend",
-		},
-	})
-	assert.NoError(t, err)
-
-	contexts, err := git_model.FindRepoRecentCommitStatusContexts(db.DefaultContext, repo2.ID, time.Hour)
-	assert.NoError(t, err)
-	if assert.Len(t, contexts, 1) {
-		assert.Equal(t, "compliance/lint-backend", contexts[0])
-	}
-}

models/issues/issue_project.go

@@ -5,11 +5,11 @@ package issues
 
 import (
 	"context"
+	"fmt"
 
 	"code.gitea.io/gitea/models/db"
 	project_model "code.gitea.io/gitea/models/project"
 	user_model "code.gitea.io/gitea/models/user"
-	"code.gitea.io/gitea/modules/util"
 )
 
 // LoadProject load the project the issue was assigned to
@@ -90,73 +90,58 @@ func LoadIssuesFromBoardList(ctx context.Context, bs project_model.BoardList) (m
 	return issuesMap, nil
 }
 
-// IssueAssignOrRemoveProject changes the project associated with an issue
-// If newProjectID is 0, the issue is removed from the project
-func IssueAssignOrRemoveProject(ctx context.Context, issue *Issue, doer *user_model.User, newProjectID, newColumnID int64) error {
-	return db.WithTx(ctx, func(ctx context.Context) error {
-		oldProjectID := issue.projectID(ctx)
+// ChangeProjectAssign changes the project associated with an issue
+func ChangeProjectAssign(ctx context.Context, issue *Issue, doer *user_model.User, newProjectID int64) error {
+	ctx, committer, err := db.TxContext(ctx)
+	if err != nil {
+		return err
+	}
+	defer committer.Close()
 
-		if err := issue.LoadRepo(ctx); err != nil {
+	if err := addUpdateIssueProject(ctx, issue, doer, newProjectID); err != nil {
+		return err
+	}
+
+	return committer.Commit()
+}
+
+func addUpdateIssueProject(ctx context.Context, issue *Issue, doer *user_model.User, newProjectID int64) error {
+	oldProjectID := issue.projectID(ctx)
+
+	if err := issue.LoadRepo(ctx); err != nil {
+		return err
+	}
+
+	// Only check if we add a new project and not remove it.
+	if newProjectID > 0 {
+		newProject, err := project_model.GetProjectByID(ctx, newProjectID)
+		if err != nil {
 			return err
 		}
-
-		// Only check if we add a new project and not remove it.
-		if newProjectID > 0 {
-			newProject, err := project_model.GetProjectByID(ctx, newProjectID)
-			if err != nil {
-				return err
-			}
-			if !newProject.CanBeAccessedByOwnerRepo(issue.Repo.OwnerID, issue.Repo) {
-				return util.NewPermissionDeniedErrorf("issue %d can't be accessed by project %d", issue.ID, newProject.ID)
-			}
-			if newColumnID == 0 {
-				newDefaultColumn, err := newProject.GetDefaultBoard(ctx)
-				if err != nil {
-					return err
-				}
-				newColumnID = newDefaultColumn.ID
-			}
+		if newProject.RepoID != issue.RepoID && newProject.OwnerID != issue.Repo.OwnerID {
+			return fmt.Errorf("issue's repository is not the same as project's repository")
 		}
+	}
 
-		if _, err := db.GetEngine(ctx).Where("project_issue.issue_id=?", issue.ID).Delete(&project_model.ProjectIssue{}); err != nil {
+	if _, err := db.GetEngine(ctx).Where("project_issue.issue_id=?", issue.ID).Delete(&project_model.ProjectIssue{}); err != nil {
+		return err
+	}
+
+	if oldProjectID > 0 || newProjectID > 0 {
+		if _, err := CreateComment(ctx, &CreateCommentOptions{
+			Type:         CommentTypeProject,
+			Doer:         doer,
+			Repo:         issue.Repo,
+			Issue:        issue,
+			OldProjectID: oldProjectID,
+			ProjectID:    newProjectID,
+		}); err != nil {
 			return err
 		}
+	}
 
-		if oldProjectID > 0 || newProjectID > 0 {
-			if _, err := CreateComment(ctx, &CreateCommentOptions{
-				Type:         CommentTypeProject,
-				Doer:         doer,
-				Repo:         issue.Repo,
-				Issue:        issue,
-				OldProjectID: oldProjectID,
-				ProjectID:    newProjectID,
-			}); err != nil {
-				return err
-			}
-		}
-		if newProjectID == 0 {
-			return nil
-		}
-		if newColumnID == 0 {
-			panic("newColumnID must not be zero") // shouldn't happen
-		}
-
-		res := struct {
-			MaxSorting int64
-			IssueCount int64
-		}{}
-		if _, err := db.GetEngine(ctx).Select("max(sorting) as max_sorting, count(*) as issue_count").Table("project_issue").
-			Where("project_id=?", newProjectID).
-			And("project_board_id=?", newColumnID).
-			Get(&res); err != nil {
-			return err
-		}
-		newSorting := util.Iif(res.IssueCount > 0, res.MaxSorting+1, 0)
-		return db.Insert(ctx, &project_model.ProjectIssue{
-			IssueID:        issue.ID,
-			ProjectID:      newProjectID,
-			ProjectBoardID: newColumnID,
-			Sorting:        newSorting,
-		})
+	return db.Insert(ctx, &project_model.ProjectIssue{
+		IssueID:   issue.ID,
+		ProjectID: newProjectID,
 	})
 }

models/issues/issue_update.go

@@ -429,6 +429,62 @@ func UpdateIssueMentions(ctx context.Context, issueID int64, mentions []*user_mo
 	return nil
 }
 
+// UpdateIssueByAPI updates all allowed fields of given issue.
+// If the issue status is changed a statusChangeComment is returned
+// similarly if the title is changed the titleChanged bool is set to true
+func UpdateIssueByAPI(ctx context.Context, issue *Issue, doer *user_model.User) (statusChangeComment *Comment, titleChanged bool, err error) {
+	ctx, committer, err := db.TxContext(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+	defer committer.Close()
+
+	if err := issue.LoadRepo(ctx); err != nil {
+		return nil, false, fmt.Errorf("loadRepo: %w", err)
+	}
+
+	// Reload the issue
+	currentIssue, err := GetIssueByID(ctx, issue.ID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	if _, err := db.GetEngine(ctx).ID(issue.ID).Cols(
+		"name", "content", "milestone_id", "priority",
+		"deadline_unix", "updated_unix", "is_locked").
+		Update(issue); err != nil {
+		return nil, false, err
+	}
+
+	titleChanged = currentIssue.Title != issue.Title
+	if titleChanged {
+		opts := &CreateCommentOptions{
+			Type:     CommentTypeChangeTitle,
+			Doer:     doer,
+			Repo:     issue.Repo,
+			Issue:    issue,
+			OldTitle: currentIssue.Title,
+			NewTitle: issue.Title,
+		}
+		_, err := CreateComment(ctx, opts)
+		if err != nil {
+			return nil, false, fmt.Errorf("createComment: %w", err)
+		}
+	}
+
+	if currentIssue.IsClosed != issue.IsClosed {
+		statusChangeComment, err = doChangeIssueStatus(ctx, issue, doer, false)
+		if err != nil {
+			return nil, false, err
+		}
+	}
+
+	if err := issue.AddCrossReferences(ctx, doer, true); err != nil {
+		return nil, false, err
+	}
+	return statusChangeComment, titleChanged, committer.Commit()
+}
+
 // UpdateIssueDeadline updates an issue deadline and adds comments. Setting a deadline to 0 means deleting it.
 func UpdateIssueDeadline(ctx context.Context, issue *Issue, deadlineUnix timeutil.TimeStamp, doer *user_model.User) (err error) {
 	// if the deadline hasn't changed do nothing

models/issues/pull.go

@@ -430,21 +430,6 @@ func (pr *PullRequest) GetGitHeadBranchRefName() string {
 	return fmt.Sprintf("%s%s", git.BranchPrefix, pr.HeadBranch)
 }
 
-// GetReviewCommentsCount returns the number of review comments made on the diff of a PR review (not including comments on commits or issues in a PR)
-func (pr *PullRequest) GetReviewCommentsCount(ctx context.Context) int {
-	opts := FindCommentsOptions{
-		Type:    CommentTypeReview,
-		IssueID: pr.IssueID,
-	}
-	conds := opts.ToConds()
-
-	count, err := db.GetEngine(ctx).Where(conds).Count(new(Comment))
-	if err != nil {
-		return 0
-	}
-	return int(count)
-}
-
 // IsChecking returns true if this pull request is still checking conflict.
 func (pr *PullRequest) IsChecking() bool {
 	return pr.Status == PullRequestStatusChecking

models/issues/review.go

@@ -155,14 +155,14 @@ func (r *Review) LoadCodeComments(ctx context.Context) (err error) {
 	if r.CodeComments != nil {
 		return err
 	}
-	if err = r.LoadIssue(ctx); err != nil {
+	if err = r.loadIssue(ctx); err != nil {
 		return err
 	}
 	r.CodeComments, err = fetchCodeCommentsByReview(ctx, r.Issue, nil, r, false)
 	return err
 }
 
-func (r *Review) LoadIssue(ctx context.Context) (err error) {
+func (r *Review) loadIssue(ctx context.Context) (err error) {
 	if r.Issue != nil {
 		return err
 	}
@@ -199,7 +199,7 @@ func (r *Review) LoadReviewerTeam(ctx context.Context) (err error) {
 
 // LoadAttributes loads all attributes except CodeComments
 func (r *Review) LoadAttributes(ctx context.Context) (err error) {
-	if err = r.LoadIssue(ctx); err != nil {
+	if err = r.loadIssue(ctx); err != nil {
 		return err
 	}
 	if err = r.LoadCodeComments(ctx); err != nil {

models/migrations/fixtures/Test_RepositoryFormat/review_state.yml

@@ -1,5 +1,3 @@
 -
   id: 1
-  user_id: 1
-  pull_id: 1
   commit_sha: 19fe5caf872476db265596eaac1dc35ad1c6422d

models/migrations/v1_22/v286.go

@@ -36,9 +36,9 @@ func expandHashReferencesToSha256(x *xorm.Engine) error {
 		if setting.Database.Type.IsMSSQL() {
 			// drop indexes that need to be re-created afterwards
 			droppedIndexes := []string{
-				"DROP INDEX [IDX_commit_status_context_hash] ON [commit_status]",
-				"DROP INDEX [UQE_review_state_pull_commit_user] ON [review_state]",
-				"DROP INDEX [UQE_repo_archiver_s] ON [repo_archiver]",
+				"DROP INDEX IF EXISTS [IDX_commit_status_context_hash] ON [commit_status]",
+				"DROP INDEX IF EXISTS [UQE_review_state_pull_commit_user] ON [review_state]",
+				"DROP INDEX IF EXISTS [UQE_repo_archiver_s] ON [repo_archiver]",
 			}
 			for _, s := range droppedIndexes {
 				_, err := db.Exec(s)

models/migrations/v1_22/v286_test.go

@@ -19,21 +19,21 @@ func PrepareOldRepository(t *testing.T) (*xorm.Engine, func()) {
 
 	type CommitStatus struct {
 		ID          int64
-		ContextHash string `xorm:"char(40) index"`
+		ContextHash string
 	}
 
 	type RepoArchiver struct {
 		ID       int64
-		RepoID   int64  `xorm:"index unique(s)"`
-		Type     int    `xorm:"unique(s)"`
-		CommitID string `xorm:"VARCHAR(40) unique(s)"`
+		RepoID   int64
+		Type     int
+		CommitID string
 	}
 
 	type ReviewState struct {
 		ID        int64
-		UserID    int64  `xorm:"NOT NULL UNIQUE(pull_commit_user)"`
-		PullID    int64  `xorm:"NOT NULL INDEX UNIQUE(pull_commit_user) DEFAULT 0"`
-		CommitSHA string `xorm:"NOT NULL VARCHAR(40) UNIQUE(pull_commit_user)"`
+		CommitSHA string
+		UserID    int64
+		PullID    int64
 	}
 
 	type Comment struct {

models/organization/org_user_test.go

@@ -81,7 +81,7 @@ func TestUserListIsPublicMember(t *testing.T) {
 		{3, map[int64]bool{2: true, 4: false, 28: true}},
 		{6, map[int64]bool{5: true, 28: true}},
 		{7, map[int64]bool{5: false}},
-		{25, map[int64]bool{12: true, 24: true}},
+		{25, map[int64]bool{24: true}},
 		{22, map[int64]bool{}},
 	}
 	for _, v := range tt {
@@ -108,8 +108,8 @@ func TestUserListIsUserOrgOwner(t *testing.T) {
 		{3, map[int64]bool{2: true, 4: false, 28: false}},
 		{6, map[int64]bool{5: true, 28: false}},
 		{7, map[int64]bool{5: true}},
-		{25, map[int64]bool{12: true, 24: false}}, // ErrTeamNotExist
-		{22, map[int64]bool{}},                    // No member
+		{25, map[int64]bool{24: false}}, // ErrTeamNotExist
+		{22, map[int64]bool{}},          // No member
 	}
 	for _, v := range tt {
 		t.Run(fmt.Sprintf("IsUserOrgOwnerOfOrgId%d", v.orgid), func(t *testing.T) {

models/project/board.go

@@ -5,14 +5,12 @@ package project
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"regexp"
 
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/timeutil"
-	"code.gitea.io/gitea/modules/util"
 
 	"xorm.io/builder"
 )
@@ -84,17 +82,6 @@ func (b *Board) NumIssues(ctx context.Context) int {
 	return int(c)
 }
 
-func (b *Board) GetIssues(ctx context.Context) ([]*ProjectIssue, error) {
-	issues := make([]*ProjectIssue, 0, 5)
-	if err := db.GetEngine(ctx).Where("project_id=?", b.ProjectID).
-		And("project_board_id=?", b.ID).
-		OrderBy("sorting, id").
-		Find(&issues); err != nil {
-		return nil, err
-	}
-	return issues, nil
-}
-
 func init() {
 	db.RegisterModel(new(Board))
 }
@@ -163,27 +150,12 @@ func createBoardsForProjectsType(ctx context.Context, project *Project) error {
 	return db.Insert(ctx, boards)
 }
 
-// maxProjectColumns max columns allowed in a project, this should not bigger than 127
-// because sorting is int8 in database
-const maxProjectColumns = 20
-
 // NewBoard adds a new project board to a given project
 func NewBoard(ctx context.Context, board *Board) error {
 	if len(board.Color) != 0 && !BoardColorPattern.MatchString(board.Color) {
 		return fmt.Errorf("bad color code: %s", board.Color)
 	}
-	res := struct {
-		MaxSorting  int64
-		ColumnCount int64
-	}{}
-	if _, err := db.GetEngine(ctx).Select("max(sorting) as max_sorting, count(*) as column_count").Table("project_board").
-		Where("project_id=?", board.ProjectID).Get(&res); err != nil {
-		return err
-	}
-	if res.ColumnCount >= maxProjectColumns {
-		return fmt.Errorf("NewBoard: maximum number of columns reached")
-	}
-	board.Sorting = int8(util.Iif(res.ColumnCount > 0, res.MaxSorting+1, 0))
+
 	_, err := db.GetEngine(ctx).Insert(board)
 	return err
 }
@@ -217,17 +189,7 @@ func deleteBoardByID(ctx context.Context, boardID int64) error {
 		return fmt.Errorf("deleteBoardByID: cannot delete default board")
 	}
 
-	// move all issues to the default column
-	project, err := GetProjectByID(ctx, board.ProjectID)
-	if err != nil {
-		return err
-	}
-	defaultColumn, err := project.GetDefaultBoard(ctx)
-	if err != nil {
-		return err
-	}
-
-	if err = board.moveIssuesToAnotherColumn(ctx, defaultColumn); err != nil {
+	if err = board.removeIssues(ctx); err != nil {
 		return err
 	}
 
@@ -280,15 +242,21 @@ func UpdateBoard(ctx context.Context, board *Board) error {
 // GetBoards fetches all boards related to a project
 func (p *Project) GetBoards(ctx context.Context) (BoardList, error) {
 	boards := make([]*Board, 0, 5)
-	if err := db.GetEngine(ctx).Where("project_id=?", p.ID).OrderBy("sorting, id").Find(&boards); err != nil {
+
+	if err := db.GetEngine(ctx).Where("project_id=? AND `default`=?", p.ID, false).OrderBy("sorting").Find(&boards); err != nil {
 		return nil, err
 	}
 
-	return boards, nil
+	defaultB, err := p.getDefaultBoard(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return append([]*Board{defaultB}, boards...), nil
 }
 
-// GetDefaultBoard return default board and ensure only one exists
-func (p *Project) GetDefaultBoard(ctx context.Context) (*Board, error) {
+// getDefaultBoard return default board and ensure only one exists
+func (p *Project) getDefaultBoard(ctx context.Context) (*Board, error) {
 	var board Board
 	has, err := db.GetEngine(ctx).
 		Where("project_id=? AND `default` = ?", p.ID, true).
@@ -348,42 +316,3 @@ func UpdateBoardSorting(ctx context.Context, bs BoardList) error {
 		return nil
 	})
 }
-
-func GetColumnsByIDs(ctx context.Context, projectID int64, columnsIDs []int64) (BoardList, error) {
-	columns := make([]*Board, 0, 5)
-	if err := db.GetEngine(ctx).
-		Where("project_id =?", projectID).
-		In("id", columnsIDs).
-		OrderBy("sorting").Find(&columns); err != nil {
-		return nil, err
-	}
-	return columns, nil
-}
-
-// MoveColumnsOnProject sorts columns in a project
-func MoveColumnsOnProject(ctx context.Context, project *Project, sortedColumnIDs map[int64]int64) error {
-	return db.WithTx(ctx, func(ctx context.Context) error {
-		sess := db.GetEngine(ctx)
-		columnIDs := util.ValuesOfMap(sortedColumnIDs)
-		movedColumns, err := GetColumnsByIDs(ctx, project.ID, columnIDs)
-		if err != nil {
-			return err
-		}
-		if len(movedColumns) != len(sortedColumnIDs) {
-			return errors.New("some columns do not exist")
-		}
-
-		for _, column := range movedColumns {
-			if column.ProjectID != project.ID {
-				return fmt.Errorf("column[%d]'s projectID is not equal to project's ID [%d]", column.ProjectID, project.ID)
-			}
-		}
-
-		for sorting, columnID := range sortedColumnIDs {
-			if _, err := sess.Exec("UPDATE `project_board` SET sorting=? WHERE id=?", sorting, columnID); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}

models/project/board_test.go

@@ -4,8 +4,6 @@
 package project
 
 import (
-	"fmt"
-	"strings"
 	"testing"
 
 	"code.gitea.io/gitea/models/db"
@@ -21,7 +19,7 @@ func TestGetDefaultBoard(t *testing.T) {
 	assert.NoError(t, err)
 
 	// check if default board was added
-	board, err := projectWithoutDefault.GetDefaultBoard(db.DefaultContext)
+	board, err := projectWithoutDefault.getDefaultBoard(db.DefaultContext)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(5), board.ProjectID)
 	assert.Equal(t, "Uncategorized", board.Title)
@@ -30,7 +28,7 @@ func TestGetDefaultBoard(t *testing.T) {
 	assert.NoError(t, err)
 
 	// check if multiple defaults were removed
-	board, err = projectWithMultipleDefaults.GetDefaultBoard(db.DefaultContext)
+	board, err = projectWithMultipleDefaults.getDefaultBoard(db.DefaultContext)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(6), board.ProjectID)
 	assert.Equal(t, int64(9), board.ID)
@@ -44,84 +42,3 @@ func TestGetDefaultBoard(t *testing.T) {
 	assert.Equal(t, int64(6), board.ProjectID)
 	assert.False(t, board.Default)
 }
-
-func Test_moveIssuesToAnotherColumn(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	column1 := unittest.AssertExistsAndLoadBean(t, &Board{ID: 1, ProjectID: 1})
-
-	issues, err := column1.GetIssues(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, issues, 1)
-	assert.EqualValues(t, 1, issues[0].ID)
-
-	column2 := unittest.AssertExistsAndLoadBean(t, &Board{ID: 2, ProjectID: 1})
-	issues, err = column2.GetIssues(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, issues, 1)
-	assert.EqualValues(t, 3, issues[0].ID)
-
-	err = column1.moveIssuesToAnotherColumn(db.DefaultContext, column2)
-	assert.NoError(t, err)
-
-	issues, err = column1.GetIssues(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, issues, 0)
-
-	issues, err = column2.GetIssues(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, issues, 2)
-	assert.EqualValues(t, 3, issues[0].ID)
-	assert.EqualValues(t, 0, issues[0].Sorting)
-	assert.EqualValues(t, 1, issues[1].ID)
-	assert.EqualValues(t, 1, issues[1].Sorting)
-}
-
-func Test_MoveColumnsOnProject(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	project1 := unittest.AssertExistsAndLoadBean(t, &Project{ID: 1})
-	columns, err := project1.GetBoards(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, columns, 3)
-	assert.EqualValues(t, 0, columns[0].Sorting) // even if there is no default sorting, the code should also work
-	assert.EqualValues(t, 0, columns[1].Sorting)
-	assert.EqualValues(t, 0, columns[2].Sorting)
-
-	err = MoveColumnsOnProject(db.DefaultContext, project1, map[int64]int64{
-		0: columns[1].ID,
-		1: columns[2].ID,
-		2: columns[0].ID,
-	})
-	assert.NoError(t, err)
-
-	columnsAfter, err := project1.GetBoards(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, columnsAfter, 3)
-	assert.EqualValues(t, columns[1].ID, columnsAfter[0].ID)
-	assert.EqualValues(t, columns[2].ID, columnsAfter[1].ID)
-	assert.EqualValues(t, columns[0].ID, columnsAfter[2].ID)
-}
-
-func Test_NewBoard(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	project1 := unittest.AssertExistsAndLoadBean(t, &Project{ID: 1})
-	columns, err := project1.GetBoards(db.DefaultContext)
-	assert.NoError(t, err)
-	assert.Len(t, columns, 3)
-
-	for i := 0; i < maxProjectColumns-3; i++ {
-		err := NewBoard(db.DefaultContext, &Board{
-			Title:     fmt.Sprintf("board-%d", i+4),
-			ProjectID: project1.ID,
-		})
-		assert.NoError(t, err)
-	}
-	err = NewBoard(db.DefaultContext, &Board{
-		Title:     "board-21",
-		ProjectID: project1.ID,
-	})
-	assert.Error(t, err)
-	assert.True(t, strings.Contains(err.Error(), "maximum number of columns reached"))
-}

models/project/issue.go

@@ -9,7 +9,6 @@ import (
 
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/modules/log"
-	"code.gitea.io/gitea/modules/util"
 )
 
 // ProjectIssue saves relation from issue to a project
@@ -18,7 +17,7 @@ type ProjectIssue struct { //revive:disable-line:exported
 	IssueID   int64 `xorm:"INDEX"`
 	ProjectID int64 `xorm:"INDEX"`
 
-	// ProjectBoardID should not be zero since 1.22. If it's zero, the issue will not be displayed on UI and it might result in errors.
+	// If 0, then it has not been added to a specific board in the project
 	ProjectBoardID int64 `xorm:"INDEX"`
 
 	// the sorting order on the board
@@ -80,8 +79,11 @@ func (p *Project) NumOpenIssues(ctx context.Context) int {
 func MoveIssuesOnProjectBoard(ctx context.Context, board *Board, sortedIssueIDs map[int64]int64) error {
 	return db.WithTx(ctx, func(ctx context.Context) error {
 		sess := db.GetEngine(ctx)
-		issueIDs := util.ValuesOfMap(sortedIssueIDs)
 
+		issueIDs := make([]int64, 0, len(sortedIssueIDs))
+		for _, issueID := range sortedIssueIDs {
+			issueIDs = append(issueIDs, issueID)
+		}
 		count, err := sess.Table(new(ProjectIssue)).Where("project_id=?", board.ProjectID).In("issue_id", issueIDs).Count()
 		if err != nil {
 			return err
@@ -100,44 +102,7 @@ func MoveIssuesOnProjectBoard(ctx context.Context, board *Board, sortedIssueIDs
 	})
 }
 
-func (b *Board) moveIssuesToAnotherColumn(ctx context.Context, newColumn *Board) error {
-	if b.ProjectID != newColumn.ProjectID {
-		return fmt.Errorf("columns have to be in the same project")
-	}
-
-	if b.ID == newColumn.ID {
-		return nil
-	}
-
-	res := struct {
-		MaxSorting int64
-		IssueCount int64
-	}{}
-	if _, err := db.GetEngine(ctx).Select("max(sorting) as max_sorting, count(*) as issue_count").
-		Table("project_issue").
-		Where("project_id=?", newColumn.ProjectID).
-		And("project_board_id=?", newColumn.ID).
-		Get(&res); err != nil {
-		return err
-	}
-
-	issues, err := b.GetIssues(ctx)
-	if err != nil {
-		return err
-	}
-	if len(issues) == 0 {
-		return nil
-	}
-
-	nextSorting := util.Iif(res.IssueCount > 0, res.MaxSorting+1, 0)
-	return db.WithTx(ctx, func(ctx context.Context) error {
-		for i, issue := range issues {
-			issue.ProjectBoardID = newColumn.ID
-			issue.Sorting = nextSorting + int64(i)
-			if _, err := db.GetEngine(ctx).ID(issue.ID).Cols("project_board_id", "sorting").Update(issue); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
+func (b *Board) removeIssues(ctx context.Context) error {
+	_, err := db.GetEngine(ctx).Exec("UPDATE `project_issue` SET project_board_id = 0 WHERE project_board_id = ? ", b.ID)
+	return err
 }

models/project/project.go

@@ -161,13 +161,6 @@ func (p *Project) IsRepositoryProject() bool {
 	return p.Type == TypeRepository
 }
 
-func (p *Project) CanBeAccessedByOwnerRepo(ownerID int64, repo *repo_model.Repository) bool {
-	if p.Type == TypeRepository {
-		return repo != nil && p.RepoID == repo.ID // if a project belongs to a repository, then its OwnerID is 0 and can be ignored
-	}
-	return p.OwnerID == ownerID && p.RepoID == 0
-}
-
 func init() {
 	db.RegisterModel(new(Project))
 }

models/repo/avatar.go

@@ -9,10 +9,10 @@ import (
 	"image/png"
 	"io"
 	"net/url"
+	"strings"
 
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/modules/avatar"
-	"code.gitea.io/gitea/modules/httplib"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/storage"
@@ -84,7 +84,13 @@ func (repo *Repository) relAvatarLink(ctx context.Context) string {
 	return setting.AppSubURL + "/repo-avatars/" + url.PathEscape(repo.Avatar)
 }
 
-// AvatarLink returns the full avatar url with http host. TODO: refactor it to a relative URL, but it is still used in API response at the moment
+// AvatarLink returns a link to the repository's avatar.
 func (repo *Repository) AvatarLink(ctx context.Context) string {
-	return httplib.MakeAbsoluteURL(ctx, repo.relAvatarLink(ctx))
+	link := repo.relAvatarLink(ctx)
+	// we only prepend our AppURL to our known (relative, internal) avatar link to get an absolute URL
+	if strings.HasPrefix(link, "/") && !strings.HasPrefix(link, "//") {
+		return setting.AppURL + strings.TrimPrefix(link, setting.AppSubURL)[1:]
+	}
+	// otherwise, return the link as it is
+	return link
 }

models/repo/repo_list.go

@@ -175,8 +175,6 @@ type SearchRepoOptions struct {
 	// True -> include just forks
 	// False -> include just non-forks
 	Fork optional.Option[bool]
-	// If Fork option is True, you can use this option to limit the forks of a special repo by repo id.
-	ForkFrom int64
 	// None -> include templates AND non-templates
 	// True -> include just templates
 	// False -> include just non-templates
@@ -516,10 +514,6 @@ func SearchRepositoryCondition(opts *SearchRepoOptions) builder.Cond {
 			cond = cond.And(builder.Eq{"is_fork": false})
 		} else {
 			cond = cond.And(builder.Eq{"is_fork": opts.Fork.Value()})
-
-			if opts.ForkFrom > 0 && opts.Fork.Value() {
-				cond = cond.And(builder.Eq{"fork_id": opts.ForkFrom})
-			}
 		}
 	}
 

models/repo/search.go

@@ -8,14 +8,14 @@ import "code.gitea.io/gitea/models/db"
 // SearchOrderByMap represents all possible search order
 var SearchOrderByMap = map[string]map[string]db.SearchOrderBy{
 	"asc": {
-		"alpha":   "owner_name ASC, name ASC",
+		"alpha":   db.SearchOrderByAlphabetically,
 		"created": db.SearchOrderByOldest,
 		"updated": db.SearchOrderByLeastUpdated,
 		"size":    db.SearchOrderBySize,
 		"id":      db.SearchOrderByID,
 	},
 	"desc": {
-		"alpha":   "owner_name DESC, name DESC",
+		"alpha":   db.SearchOrderByAlphabeticallyReverse,
 		"created": db.SearchOrderByNewest,
 		"updated": db.SearchOrderByRecentUpdated,
 		"size":    db.SearchOrderBySizeReverse,

models/repo/user_repo.go

@@ -130,10 +130,7 @@ func GetRepoAssignees(ctx context.Context, repo *Repository) (_ []*user_model.Us
 	// and just waste 1 unit is cheaper than re-allocate memory once.
 	users := make([]*user_model.User, 0, len(uniqueUserIDs)+1)
 	if len(userIDs) > 0 {
-		if err = e.In("id", uniqueUserIDs.Values()).
-			Where(builder.Eq{"`user`.is_active": true}).
-			OrderBy(user_model.GetOrderByName()).
-			Find(&users); err != nil {
+		if err = e.In("id", uniqueUserIDs.Values()).OrderBy(user_model.GetOrderByName()).Find(&users); err != nil {
 			return nil, err
 		}
 	}
@@ -155,8 +152,7 @@ func GetReviewers(ctx context.Context, repo *Repository, doerID, posterID int64)
 		return nil, err
 	}
 
-	cond := builder.And(builder.Neq{"`user`.id": posterID}).
-		And(builder.Eq{"`user`.is_active": true})
+	cond := builder.And(builder.Neq{"`user`.id": posterID})
 
 	if repo.IsPrivate || repo.Owner.Visibility == api.VisibleTypePrivate {
 		// This a private repository:

models/repo/user_repo_test.go

@@ -9,7 +9,6 @@ import (
 	"code.gitea.io/gitea/models/db"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
-	user_model "code.gitea.io/gitea/models/user"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -26,17 +25,8 @@ func TestRepoAssignees(t *testing.T) {
 	repo21 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 21})
 	users, err = repo_model.GetRepoAssignees(db.DefaultContext, repo21)
 	assert.NoError(t, err)
-	if assert.Len(t, users, 4) {
-		assert.ElementsMatch(t, []int64{10, 15, 16, 18}, []int64{users[0].ID, users[1].ID, users[2].ID, users[3].ID})
-	}
-
-	// do not return deactivated users
-	assert.NoError(t, user_model.UpdateUserCols(db.DefaultContext, &user_model.User{ID: 15, IsActive: false}, "is_active"))
-	users, err = repo_model.GetRepoAssignees(db.DefaultContext, repo21)
-	assert.NoError(t, err)
-	if assert.Len(t, users, 3) {
-		assert.NotContains(t, []int64{users[0].ID, users[1].ID, users[2].ID}, 15)
-	}
+	assert.Len(t, users, 4)
+	assert.ElementsMatch(t, []int64{10, 15, 16, 18}, []int64{users[0].ID, users[1].ID, users[2].ID, users[3].ID})
 }
 
 func TestRepoGetReviewers(t *testing.T) {
@@ -48,19 +38,17 @@ func TestRepoGetReviewers(t *testing.T) {
 	ctx := db.DefaultContext
 	reviewers, err := repo_model.GetReviewers(ctx, repo1, 2, 2)
 	assert.NoError(t, err)
-	if assert.Len(t, reviewers, 3) {
-		assert.ElementsMatch(t, []int64{1, 4, 11}, []int64{reviewers[0].ID, reviewers[1].ID, reviewers[2].ID})
-	}
+	assert.Len(t, reviewers, 4)
 
 	// should include doer if doer is not PR poster.
 	reviewers, err = repo_model.GetReviewers(ctx, repo1, 11, 2)
 	assert.NoError(t, err)
-	assert.Len(t, reviewers, 3)
+	assert.Len(t, reviewers, 4)
 
 	// should not include PR poster, if PR poster would be otherwise eligible
 	reviewers, err = repo_model.GetReviewers(ctx, repo1, 11, 4)
 	assert.NoError(t, err)
-	assert.Len(t, reviewers, 2)
+	assert.Len(t, reviewers, 3)
 
 	// test private user repo
 	repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})

models/unit/unit.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"strings"
-	"sync/atomic"
 
 	"code.gitea.io/gitea/models/perm"
 	"code.gitea.io/gitea/modules/container"
@@ -107,23 +106,10 @@ var (
 		TypeExternalTracker,
 	}
 
-	disabledRepoUnitsAtomic atomic.Pointer[[]Type] // the units that have been globally disabled
+	// DisabledRepoUnits contains the units that have been globally disabled
+	DisabledRepoUnits = []Type{}
 )
 
-// DisabledRepoUnitsGet returns the globally disabled units, it is a quick patch to fix data-race during testing.
-// Because the queue worker might read when a test is mocking the value. FIXME: refactor to a clear solution later.
-func DisabledRepoUnitsGet() []Type {
-	v := disabledRepoUnitsAtomic.Load()
-	if v == nil {
-		return nil
-	}
-	return *v
-}
-
-func DisabledRepoUnitsSet(v []Type) {
-	disabledRepoUnitsAtomic.Store(&v)
-}
-
 // Get valid set of default repository units from settings
 func validateDefaultRepoUnits(defaultUnits, settingDefaultUnits []Type) []Type {
 	units := defaultUnits
@@ -141,7 +127,7 @@ func validateDefaultRepoUnits(defaultUnits, settingDefaultUnits []Type) []Type {
 	}
 
 	// Remove disabled units
-	for _, disabledUnit := range DisabledRepoUnitsGet() {
+	for _, disabledUnit := range DisabledRepoUnits {
 		for i, unit := range units {
 			if unit == disabledUnit {
 				units = append(units[:i], units[i+1:]...)
@@ -154,11 +140,11 @@ func validateDefaultRepoUnits(defaultUnits, settingDefaultUnits []Type) []Type {
 
 // LoadUnitConfig load units from settings
 func LoadUnitConfig() error {
-	disabledRepoUnits, invalidKeys := FindUnitTypes(setting.Repository.DisabledRepoUnits...)
+	var invalidKeys []string
+	DisabledRepoUnits, invalidKeys = FindUnitTypes(setting.Repository.DisabledRepoUnits...)
 	if len(invalidKeys) > 0 {
 		log.Warn("Invalid keys in disabled repo units: %s", strings.Join(invalidKeys, ", "))
 	}
-	DisabledRepoUnitsSet(disabledRepoUnits)
 
 	setDefaultRepoUnits, invalidKeys := FindUnitTypes(setting.Repository.DefaultRepoUnits...)
 	if len(invalidKeys) > 0 {
@@ -181,7 +167,7 @@ func LoadUnitConfig() error {
 
 // UnitGlobalDisabled checks if unit type is global disabled
 func (u Type) UnitGlobalDisabled() bool {
-	for _, ud := range DisabledRepoUnitsGet() {
+	for _, ud := range DisabledRepoUnits {
 		if u == ud {
 			return true
 		}

models/unit/unit_test.go

@@ -14,10 +14,10 @@ import (
 func TestLoadUnitConfig(t *testing.T) {
 	t.Run("regular", func(t *testing.T) {
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []Type) {
-			DisabledRepoUnitsSet(disabledRepoUnits)
+			DisabledRepoUnits = disabledRepoUnits
 			DefaultRepoUnits = defaultRepoUnits
 			DefaultForkRepoUnits = defaultForkRepoUnits
-		}(DisabledRepoUnitsGet(), DefaultRepoUnits, DefaultForkRepoUnits)
+		}(DisabledRepoUnits, DefaultRepoUnits, DefaultForkRepoUnits)
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []string) {
 			setting.Repository.DisabledRepoUnits = disabledRepoUnits
 			setting.Repository.DefaultRepoUnits = defaultRepoUnits
@@ -28,16 +28,16 @@ func TestLoadUnitConfig(t *testing.T) {
 		setting.Repository.DefaultRepoUnits = []string{"repo.code", "repo.releases", "repo.issues", "repo.pulls"}
 		setting.Repository.DefaultForkRepoUnits = []string{"repo.releases"}
 		assert.NoError(t, LoadUnitConfig())
-		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnitsGet())
+		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnits)
 		assert.Equal(t, []Type{TypeCode, TypeReleases, TypePullRequests}, DefaultRepoUnits)
 		assert.Equal(t, []Type{TypeReleases}, DefaultForkRepoUnits)
 	})
 	t.Run("invalid", func(t *testing.T) {
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []Type) {
-			DisabledRepoUnitsSet(disabledRepoUnits)
+			DisabledRepoUnits = disabledRepoUnits
 			DefaultRepoUnits = defaultRepoUnits
 			DefaultForkRepoUnits = defaultForkRepoUnits
-		}(DisabledRepoUnitsGet(), DefaultRepoUnits, DefaultForkRepoUnits)
+		}(DisabledRepoUnits, DefaultRepoUnits, DefaultForkRepoUnits)
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []string) {
 			setting.Repository.DisabledRepoUnits = disabledRepoUnits
 			setting.Repository.DefaultRepoUnits = defaultRepoUnits
@@ -48,16 +48,16 @@ func TestLoadUnitConfig(t *testing.T) {
 		setting.Repository.DefaultRepoUnits = []string{"repo.code", "invalid.2", "repo.releases", "repo.issues", "repo.pulls"}
 		setting.Repository.DefaultForkRepoUnits = []string{"invalid.3", "repo.releases"}
 		assert.NoError(t, LoadUnitConfig())
-		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnitsGet())
+		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnits)
 		assert.Equal(t, []Type{TypeCode, TypeReleases, TypePullRequests}, DefaultRepoUnits)
 		assert.Equal(t, []Type{TypeReleases}, DefaultForkRepoUnits)
 	})
 	t.Run("duplicate", func(t *testing.T) {
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []Type) {
-			DisabledRepoUnitsSet(disabledRepoUnits)
+			DisabledRepoUnits = disabledRepoUnits
 			DefaultRepoUnits = defaultRepoUnits
 			DefaultForkRepoUnits = defaultForkRepoUnits
-		}(DisabledRepoUnitsGet(), DefaultRepoUnits, DefaultForkRepoUnits)
+		}(DisabledRepoUnits, DefaultRepoUnits, DefaultForkRepoUnits)
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []string) {
 			setting.Repository.DisabledRepoUnits = disabledRepoUnits
 			setting.Repository.DefaultRepoUnits = defaultRepoUnits
@@ -68,16 +68,16 @@ func TestLoadUnitConfig(t *testing.T) {
 		setting.Repository.DefaultRepoUnits = []string{"repo.code", "repo.releases", "repo.issues", "repo.pulls", "repo.code"}
 		setting.Repository.DefaultForkRepoUnits = []string{"repo.releases", "repo.releases"}
 		assert.NoError(t, LoadUnitConfig())
-		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnitsGet())
+		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnits)
 		assert.Equal(t, []Type{TypeCode, TypeReleases, TypePullRequests}, DefaultRepoUnits)
 		assert.Equal(t, []Type{TypeReleases}, DefaultForkRepoUnits)
 	})
 	t.Run("empty_default", func(t *testing.T) {
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []Type) {
-			DisabledRepoUnitsSet(disabledRepoUnits)
+			DisabledRepoUnits = disabledRepoUnits
 			DefaultRepoUnits = defaultRepoUnits
 			DefaultForkRepoUnits = defaultForkRepoUnits
-		}(DisabledRepoUnitsGet(), DefaultRepoUnits, DefaultForkRepoUnits)
+		}(DisabledRepoUnits, DefaultRepoUnits, DefaultForkRepoUnits)
 		defer func(disabledRepoUnits, defaultRepoUnits, defaultForkRepoUnits []string) {
 			setting.Repository.DisabledRepoUnits = disabledRepoUnits
 			setting.Repository.DefaultRepoUnits = defaultRepoUnits
@@ -88,7 +88,7 @@ func TestLoadUnitConfig(t *testing.T) {
 		setting.Repository.DefaultRepoUnits = []string{}
 		setting.Repository.DefaultForkRepoUnits = []string{"repo.releases", "repo.releases"}
 		assert.NoError(t, LoadUnitConfig())
-		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnitsGet())
+		assert.Equal(t, []Type{TypeIssues}, DisabledRepoUnits)
 		assert.ElementsMatch(t, []Type{TypeCode, TypePullRequests, TypeReleases, TypeWiki, TypePackages, TypeProjects, TypeActions}, DefaultRepoUnits)
 		assert.Equal(t, []Type{TypeReleases}, DefaultForkRepoUnits)
 	})

models/user/avatar.go

@@ -9,11 +9,11 @@ import (
 	"fmt"
 	"image/png"
 	"io"
+	"strings"
 
 	"code.gitea.io/gitea/models/avatars"
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/modules/avatar"
-	"code.gitea.io/gitea/modules/httplib"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/storage"
@@ -89,9 +89,13 @@ func (u *User) AvatarLinkWithSize(ctx context.Context, size int) string {
 	return avatars.GenerateEmailAvatarFastLink(ctx, u.AvatarEmail, size)
 }
 
-// AvatarLink returns the full avatar url with http host. TODO: refactor it to a relative URL, but it is still used in API response at the moment
+// AvatarLink returns the full avatar link with http host
 func (u *User) AvatarLink(ctx context.Context) string {
-	return httplib.MakeAbsoluteURL(ctx, u.AvatarLinkWithSize(ctx, 0))
+	link := u.AvatarLinkWithSize(ctx, 0)
+	if !strings.HasPrefix(link, "//") && !strings.Contains(link, "://") {
+		return setting.AppURL + strings.TrimPrefix(link, setting.AppSubURL+"/")
+	}
+	return link
 }
 
 // IsUploadAvatarChanged returns true if the current user's avatar would be changed with the provided data

models/user/email_address.go

@@ -10,7 +10,6 @@ import (
 	"net/mail"
 	"regexp"
 	"strings"
-	"time"
 
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/modules/base"
@@ -354,12 +353,14 @@ func ChangeInactivePrimaryEmail(ctx context.Context, uid int64, oldEmailAddr, ne
 
 // VerifyActiveEmailCode verifies active email code when active account
 func VerifyActiveEmailCode(ctx context.Context, code, email string) *EmailAddress {
+	minutes := setting.Service.ActiveCodeLives
+
 	if user := GetVerifyUser(ctx, code); user != nil {
 		// time limit code
 		prefix := code[:base.TimeLimitCodeLength]
 		data := fmt.Sprintf("%d%s%s%s%s", user.ID, email, user.LowerName, user.Passwd, user.Rands)
 
-		if base.VerifyTimeLimitCode(time.Now(), data, setting.Service.ActiveCodeLives, prefix) {
+		if base.VerifyTimeLimitCode(data, minutes, prefix) {
 			emailAddress := &EmailAddress{UID: user.ID, Email: email}
 			if has, _ := db.GetEngine(ctx).Get(emailAddress); has {
 				return emailAddress

models/user/user.go

@@ -304,7 +304,7 @@ func (u *User) OrganisationLink() string {
 func (u *User) GenerateEmailActivateCode(email string) string {
 	code := base.CreateTimeLimitCode(
 		fmt.Sprintf("%d%s%s%s%s", u.ID, email, u.LowerName, u.Passwd, u.Rands),
-		setting.Service.ActiveCodeLives, time.Now(), nil)
+		setting.Service.ActiveCodeLives, nil)
 
 	// Add tail hex username
 	code += hex.EncodeToString([]byte(u.LowerName))
@@ -791,11 +791,14 @@ func GetVerifyUser(ctx context.Context, code string) (user *User) {
 
 // VerifyUserActiveCode verifies active code when active account
 func VerifyUserActiveCode(ctx context.Context, code string) (user *User) {
+	minutes := setting.Service.ActiveCodeLives
+
 	if user = GetVerifyUser(ctx, code); user != nil {
 		// time limit code
 		prefix := code[:base.TimeLimitCodeLength]
 		data := fmt.Sprintf("%d%s%s%s%s", user.ID, user.Email, user.LowerName, user.Passwd, user.Rands)
-		if base.VerifyTimeLimitCode(time.Now(), data, setting.Service.ActiveCodeLives, prefix) {
+
+		if base.VerifyTimeLimitCode(data, minutes, prefix) {
 			return user
 		}
 	}

models/user/user_test.go

@@ -5,8 +5,8 @@ package user_test
 
 import (
 	"context"
+	"crypto/rand"
 	"fmt"
-	"math/rand"
 	"strings"
 	"testing"
 	"time"

modules/auth/password/pwn/pwn_test.go

@@ -4,9 +4,8 @@
 package pwn
 
 import (
-	"math/rand"
+	"math/rand/v2"
 	"net/http"
-	"os"
 	"strings"
 	"testing"
 	"time"
@@ -18,11 +17,6 @@ var client = New(WithHTTP(&http.Client{
 	Timeout: time.Second * 2,
 }))
 
-func TestMain(m *testing.M) {
-	rand.Seed(time.Now().Unix())
-	os.Exit(m.Run())
-}
-
 func TestPassword(t *testing.T) {
 	// Check input error
 	_, err := client.CheckPassword("", false)
@@ -81,24 +75,24 @@ func testPassword() string {
 
 	// Set special character
 	for i := 0; i < 5; i++ {
-		random := rand.Intn(len(specialCharSet))
+		random := rand.IntN(len(specialCharSet))
 		password.WriteString(string(specialCharSet[random]))
 	}
 
 	// Set numeric
 	for i := 0; i < 5; i++ {
-		random := rand.Intn(len(numberSet))
+		random := rand.IntN(len(numberSet))
 		password.WriteString(string(numberSet[random]))
 	}
 
 	// Set uppercase
 	for i := 0; i < 5; i++ {
-		random := rand.Intn(len(upperCharSet))
+		random := rand.IntN(len(upperCharSet))
 		password.WriteString(string(upperCharSet[random]))
 	}
 
 	for i := 0; i < 5; i++ {
-		random := rand.Intn(len(allCharSet))
+		random := rand.IntN(len(allCharSet))
 		password.WriteString(string(allCharSet[random]))
 	}
 	inRune := []rune(password.String())

modules/base/tool.go

@@ -4,15 +4,12 @@
 package base
 
 import (
-	"crypto/hmac"
 	"crypto/sha1"
 	"crypto/sha256"
-	"crypto/subtle"
 	"encoding/base64"
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"hash"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -28,6 +25,13 @@ import (
 	"github.com/dustin/go-humanize"
 )
 
+// EncodeSha1 string to sha1 hex value.
+func EncodeSha1(str string) string {
+	h := sha1.New()
+	_, _ = h.Write([]byte(str))
+	return hex.EncodeToString(h.Sum(nil))
+}
+
 // EncodeSha256 string to sha256 hex value.
 func EncodeSha256(str string) string {
 	h := sha256.New()
@@ -58,62 +62,63 @@ func BasicAuthDecode(encoded string) (string, string, error) {
 }
 
 // VerifyTimeLimitCode verify time limit code
-func VerifyTimeLimitCode(now time.Time, data string, minutes int, code string) bool {
+func VerifyTimeLimitCode(data string, minutes int, code string) bool {
 	if len(code) <= 18 {
 		return false
 	}
 
-	startTimeStr := code[:12]
-	aliveTimeStr := code[12:18]
-	aliveTime, _ := strconv.Atoi(aliveTimeStr) // no need to check err, if anything wrong, the following code check will fail soon
+	// split code
+	start := code[:12]
+	lives := code[12:18]
+	if d, err := strconv.ParseInt(lives, 10, 0); err == nil {
+		minutes = int(d)
+	}
 
-	// check code
-	retCode := CreateTimeLimitCode(data, aliveTime, startTimeStr, nil)
-	if subtle.ConstantTimeCompare([]byte(retCode), []byte(code)) != 1 {
-		retCode = CreateTimeLimitCode(data, aliveTime, startTimeStr, sha1.New()) // TODO: this is only for the support of legacy codes, remove this in/after 1.23
-		if subtle.ConstantTimeCompare([]byte(retCode), []byte(code)) != 1 {
-			return false
+	// right active code
+	retCode := CreateTimeLimitCode(data, minutes, start)
+	if retCode == code && minutes > 0 {
+		// check time is expired or not
+		before, _ := time.ParseInLocation("200601021504", start, time.Local)
+		now := time.Now()
+		if before.Add(time.Minute*time.Duration(minutes)).Unix() > now.Unix() {
+			return true
 		}
 	}
 
-	// check time is expired or not: startTime <= now && now < startTime + minutes
-	startTime, _ := time.ParseInLocation("200601021504", startTimeStr, time.Local)
-	return (startTime.Before(now) || startTime.Equal(now)) && now.Before(startTime.Add(time.Minute*time.Duration(minutes)))
+	return false
 }
 
 // TimeLimitCodeLength default value for time limit code
 const TimeLimitCodeLength = 12 + 6 + 40
 
-// CreateTimeLimitCode create a time-limited code.
-// Format: 12 length date time string + 6 minutes string (not used) + 40 hash string, some other code depends on this fixed length
-// If h is nil, then use the default hmac hash.
-func CreateTimeLimitCode[T time.Time | string](data string, minutes int, startTimeGeneric T, h hash.Hash) string {
-	const format = "200601021504"
+// CreateTimeLimitCode create a time limit code
+// code format: 12 length date time string + 6 minutes string + 40 sha1 encoded string
+func CreateTimeLimitCode(data string, minutes int, startInf any) string {
+	format := "200601021504"
 
-	var start time.Time
-	var startTimeAny any = startTimeGeneric
-	if t, ok := startTimeAny.(time.Time); ok {
-		start = t
+	var start, end time.Time
+	var startStr, endStr string
+
+	if startInf == nil {
+		// Use now time create code
+		start = time.Now()
+		startStr = start.Format(format)
 	} else {
-		var err error
-		start, err = time.ParseInLocation(format, startTimeAny.(string), time.Local)
-		if err != nil {
-			return "" // return an invalid code because the "parse" failed
-		}
+		// use start string create code
+		startStr = startInf.(string)
+		start, _ = time.ParseInLocation(format, startStr, time.Local)
+		startStr = start.Format(format)
 	}
-	startStr := start.Format(format)
-	end := start.Add(time.Minute * time.Duration(minutes))
 
-	if h == nil {
-		h = hmac.New(sha1.New, setting.GetGeneralTokenSigningSecret())
-	}
-	_, _ = fmt.Fprintf(h, "%s%s%s%s%d", data, hex.EncodeToString(setting.GetGeneralTokenSigningSecret()), startStr, end.Format(format), minutes)
-	encoded := hex.EncodeToString(h.Sum(nil))
+	end = start.Add(time.Minute * time.Duration(minutes))
+	endStr = end.Format(format)
+
+	// create sha1 encode string
+	sh := sha1.New()
+	_, _ = sh.Write([]byte(fmt.Sprintf("%s%s%s%s%d", data, hex.EncodeToString(setting.GetGeneralTokenSigningSecret()), startStr, endStr, minutes)))
+	encoded := hex.EncodeToString(sh.Sum(nil))
 
 	code := fmt.Sprintf("%s%06d%s", startStr, minutes, encoded)
-	if len(code) != TimeLimitCodeLength {
-		panic("there is a hard requirement for the length of time-limited code") // it shouldn't happen
-	}
 	return code
 }
 

modules/base/tool_test.go

@@ -4,18 +4,20 @@
 package base
 
 import (
-	"crypto/sha1"
-	"fmt"
 	"os"
 	"testing"
 	"time"
 
-	"code.gitea.io/gitea/modules/setting"
-	"code.gitea.io/gitea/modules/test"
-
 	"github.com/stretchr/testify/assert"
 )
 
+func TestEncodeSha1(t *testing.T) {
+	assert.Equal(t,
+		"8843d7f92416211de9ebb963ff4ce28125932878",
+		EncodeSha1("foobar"),
+	)
+}
+
 func TestEncodeSha256(t *testing.T) {
 	assert.Equal(t,
 		"c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2",
@@ -44,54 +46,43 @@ func TestBasicAuthDecode(t *testing.T) {
 }
 
 func TestVerifyTimeLimitCode(t *testing.T) {
-	defer test.MockVariableValue(&setting.InstallLock, true)()
-	initGeneralSecret := func(secret string) {
-		setting.InstallLock = true
-		setting.CfgProvider, _ = setting.NewConfigProviderFromData(fmt.Sprintf(`
-[oauth2]
-JWT_SECRET = %s
-`, secret))
-		setting.LoadCommonSettings()
+	tc := []struct {
+		data    string
+		minutes int
+		code    string
+		valid   bool
+	}{{
+		data:    "data",
+		minutes: 2,
+		code:    testCreateTimeLimitCode(t, "data", 2),
+		valid:   true,
+	}, {
+		data:    "abc123-ß",
+		minutes: 1,
+		code:    testCreateTimeLimitCode(t, "abc123-ß", 1),
+		valid:   true,
+	}, {
+		data:    "data",
+		minutes: 2,
+		code:    "2021012723240000005928251dac409d2c33a6eb82c63410aaad569bed",
+		valid:   false,
+	}}
+	for _, test := range tc {
+		actualValid := VerifyTimeLimitCode(test.data, test.minutes, test.code)
+		assert.Equal(t, test.valid, actualValid, "data: '%s' code: '%s' should be valid: %t", test.data, test.code, test.valid)
 	}
+}
 
-	initGeneralSecret("KZb_QLUd4fYVyxetjxC4eZkrBgWM2SndOOWDNtgUUko")
-	now := time.Now()
+func testCreateTimeLimitCode(t *testing.T, data string, m int) string {
+	result0 := CreateTimeLimitCode(data, m, nil)
+	result1 := CreateTimeLimitCode(data, m, time.Now().Format("200601021504"))
+	result2 := CreateTimeLimitCode(data, m, time.Unix(time.Now().Unix()+int64(time.Minute)*int64(m), 0).Format("200601021504"))
 
-	t.Run("TestGenericParameter", func(t *testing.T) {
-		time2000 := time.Date(2000, 1, 2, 3, 4, 5, 0, time.Local)
-		assert.Equal(t, "2000010203040000026fa5221b2731b7cf80b1b506f5e39e38c115fee5", CreateTimeLimitCode("test-sha1", 2, time2000, sha1.New()))
-		assert.Equal(t, "2000010203040000026fa5221b2731b7cf80b1b506f5e39e38c115fee5", CreateTimeLimitCode("test-sha1", 2, "200001020304", sha1.New()))
-		assert.Equal(t, "2000010203040000024842227a2f87041ff82025199c0187410a9297bf", CreateTimeLimitCode("test-hmac", 2, time2000, nil))
-		assert.Equal(t, "2000010203040000024842227a2f87041ff82025199c0187410a9297bf", CreateTimeLimitCode("test-hmac", 2, "200001020304", nil))
-	})
+	assert.Equal(t, result0, result1)
+	assert.NotEqual(t, result0, result2)
 
-	t.Run("TestInvalidCode", func(t *testing.T) {
-		assert.False(t, VerifyTimeLimitCode(now, "data", 2, ""))
-		assert.False(t, VerifyTimeLimitCode(now, "data", 2, "invalid code"))
-	})
-
-	t.Run("TestCreateAndVerify", func(t *testing.T) {
-		code := CreateTimeLimitCode("data", 2, now, nil)
-		assert.False(t, VerifyTimeLimitCode(now.Add(-time.Minute), "data", 2, code)) // not started yet
-		assert.True(t, VerifyTimeLimitCode(now, "data", 2, code))
-		assert.True(t, VerifyTimeLimitCode(now.Add(time.Minute), "data", 2, code))
-		assert.False(t, VerifyTimeLimitCode(now.Add(time.Minute), "DATA", 2, code))   // invalid data
-		assert.False(t, VerifyTimeLimitCode(now.Add(2*time.Minute), "data", 2, code)) // expired
-	})
-
-	t.Run("TestDifferentSecret", func(t *testing.T) {
-		// use another secret to ensure the code is invalid for different secret
-		verifyDataCode := func(c string) bool {
-			return VerifyTimeLimitCode(now, "data", 2, c)
-		}
-		code1 := CreateTimeLimitCode("data", 2, now, sha1.New())
-		code2 := CreateTimeLimitCode("data", 2, now, nil)
-		assert.True(t, verifyDataCode(code1))
-		assert.True(t, verifyDataCode(code2))
-		initGeneralSecret("000_QLUd4fYVyxetjxC4eZkrBgWM2SndOOWDNtgUUko")
-		assert.False(t, verifyDataCode(code1))
-		assert.False(t, verifyDataCode(code2))
-	})
+	assert.True(t, len(result0) != 0)
+	return result0
 }
 
 func TestFileSize(t *testing.T) {

modules/git/blame.go

@@ -132,7 +132,7 @@ func (r *BlameReader) Close() error {
 // CreateBlameReader creates reader for given repository, commit and file
 func CreateBlameReader(ctx context.Context, objectFormat ObjectFormat, repoPath string, commit *Commit, file string, bypassBlameIgnore bool) (*BlameReader, error) {
 	var ignoreRevsFile *string
-	if DefaultFeatures().CheckVersionAtLeast("2.23") && !bypassBlameIgnore {
+	if CheckGitVersionAtLeast("2.23") == nil && !bypassBlameIgnore {
 		ignoreRevsFile = tryCreateBlameIgnoreRevsFile(commit)
 	}
 

modules/git/commit.go

@@ -423,7 +423,7 @@ func (c *Commit) GetSubModule(entryname string) (*SubModule, error) {
 // GetBranchName gets the closest branch name (as returned by 'git name-rev --name-only')
 func (c *Commit) GetBranchName() (string, error) {
 	cmd := NewCommand(c.repo.Ctx, "name-rev")
-	if DefaultFeatures().CheckVersionAtLeast("2.13.0") {
+	if CheckGitVersionAtLeast("2.13.0") == nil {
 		cmd.AddArguments("--exclude", "refs/tags/*")
 	}
 	cmd.AddArguments("--name-only", "--no-undefined").AddDynamicArguments(c.ID.String())

modules/git/git.go

@@ -22,63 +22,42 @@ import (
 	"github.com/hashicorp/go-version"
 )
 
-const RequiredVersion = "2.0.0" // the minimum Git version required
-
-type Features struct {
-	gitVersion *version.Version
-
-	UsingGogit             bool
-	SupportProcReceive     bool           // >= 2.29
-	SupportHashSha256      bool           // >= 2.42, SHA-256 repositories no longer an ‘experimental curiosity’
-	SupportedObjectFormats []ObjectFormat // sha1, sha256
-}
+// RequiredVersion is the minimum Git version required
+const RequiredVersion = "2.0.0"
 
 var (
-	GitExecutable   = "git"         // the command name of git, will be updated to an absolute path during initialization
-	DefaultContext  context.Context // the default context to run git commands in, must be initialized by git.InitXxx
-	defaultFeatures *Features
+	// GitExecutable is the command name of git
+	// Could be updated to an absolute path while initialization
+	GitExecutable = "git"
+
+	// DefaultContext is the default context to run git commands in, must be initialized by git.InitXxx
+	DefaultContext context.Context
+
+	DefaultFeatures struct {
+		GitVersion *version.Version
+
+		SupportProcReceive bool // >= 2.29
+		SupportHashSha256  bool // >= 2.42, SHA-256 repositories no longer an ‘experimental curiosity’
+	}
 )
 
-func (f *Features) CheckVersionAtLeast(atLeast string) bool {
-	return f.gitVersion.Compare(version.Must(version.NewVersion(atLeast))) >= 0
-}
-
-// VersionInfo returns git version information
-func (f *Features) VersionInfo() string {
-	return f.gitVersion.Original()
-}
-
-func DefaultFeatures() *Features {
-	if defaultFeatures == nil {
-		if !setting.IsProd || setting.IsInTesting {
-			log.Warn("git.DefaultFeatures is called before git.InitXxx, initializing with default values")
-		}
-		if err := InitSimple(context.Background()); err != nil {
-			log.Fatal("git.InitSimple failed: %v", err)
-		}
+// loadGitVersion tries to get the current git version and stores it into a global variable
+func loadGitVersion() error {
+	// doesn't need RWMutex because it's executed by Init()
+	if DefaultFeatures.GitVersion != nil {
+		return nil
 	}
-	return defaultFeatures
-}
 
-func loadGitVersionFeatures() (*Features, error) {
 	stdout, _, runErr := NewCommand(DefaultContext, "version").RunStdString(nil)
 	if runErr != nil {
-		return nil, runErr
+		return runErr
 	}
 
 	ver, err := parseGitVersionLine(strings.TrimSpace(stdout))
-	if err != nil {
-		return nil, err
+	if err == nil {
+		DefaultFeatures.GitVersion = ver
 	}
-
-	features := &Features{gitVersion: ver, UsingGogit: isGogit}
-	features.SupportProcReceive = features.CheckVersionAtLeast("2.29")
-	features.SupportHashSha256 = features.CheckVersionAtLeast("2.42") && !isGogit
-	features.SupportedObjectFormats = []ObjectFormat{Sha1ObjectFormat}
-	if features.SupportHashSha256 {
-		features.SupportedObjectFormats = append(features.SupportedObjectFormats, Sha256ObjectFormat)
-	}
-	return features, nil
+	return err
 }
 
 func parseGitVersionLine(s string) (*version.Version, error) {
@@ -106,24 +85,56 @@ func SetExecutablePath(path string) error {
 		return fmt.Errorf("git not found: %w", err)
 	}
 	GitExecutable = absPath
-	return nil
-}
 
-func ensureGitVersion() error {
-	if !DefaultFeatures().CheckVersionAtLeast(RequiredVersion) {
+	if err = loadGitVersion(); err != nil {
+		return fmt.Errorf("unable to load git version: %w", err)
+	}
+
+	versionRequired, err := version.NewVersion(RequiredVersion)
+	if err != nil {
+		return err
+	}
+
+	if DefaultFeatures.GitVersion.LessThan(versionRequired) {
 		moreHint := "get git: https://git-scm.com/download/"
 		if runtime.GOOS == "linux" {
 			// there are a lot of CentOS/RHEL users using old git, so we add a special hint for them
-			if _, err := os.Stat("/etc/redhat-release"); err == nil {
+			if _, err = os.Stat("/etc/redhat-release"); err == nil {
 				// ius.io is the recommended official(git-scm.com) method to install git
 				moreHint = "get git: https://git-scm.com/download/linux and https://ius.io"
 			}
 		}
-		return fmt.Errorf("installed git version %q is not supported, Gitea requires git version >= %q, %s", DefaultFeatures().gitVersion.Original(), RequiredVersion, moreHint)
+		return fmt.Errorf("installed git version %q is not supported, Gitea requires git version >= %q, %s", DefaultFeatures.GitVersion.Original(), RequiredVersion, moreHint)
 	}
 
-	if err := checkGitVersionCompatibility(DefaultFeatures().gitVersion); err != nil {
-		return fmt.Errorf("installed git version %s has a known compatibility issue with Gitea: %w, please upgrade (or downgrade) git", DefaultFeatures().gitVersion.String(), err)
+	if err = checkGitVersionCompatibility(DefaultFeatures.GitVersion); err != nil {
+		return fmt.Errorf("installed git version %s has a known compatibility issue with Gitea: %w, please upgrade (or downgrade) git", DefaultFeatures.GitVersion.String(), err)
+	}
+	return nil
+}
+
+// VersionInfo returns git version information
+func VersionInfo() string {
+	if DefaultFeatures.GitVersion == nil {
+		return "(git not found)"
+	}
+	format := "%s"
+	args := []any{DefaultFeatures.GitVersion.Original()}
+	// Since git wire protocol has been released from git v2.18
+	if setting.Git.EnableAutoGitWireProtocol && CheckGitVersionAtLeast("2.18") == nil {
+		format += ", Wire Protocol %s Enabled"
+		args = append(args, "Version 2") // for focus color
+	}
+
+	return fmt.Sprintf(format, args...)
+}
+
+func checkInit() error {
+	if setting.Git.HomePath == "" {
+		return errors.New("unable to init Git's HomeDir, incorrect initialization of the setting and git modules")
+	}
+	if DefaultContext != nil {
+		log.Warn("git module has been initialized already, duplicate init may work but it's better to fix it")
 	}
 	return nil
 }
@@ -143,12 +154,8 @@ func HomeDir() string {
 // InitSimple initializes git module with a very simple step, no config changes, no global command arguments.
 // This method doesn't change anything to filesystem. At the moment, it is only used by some Gitea sub-commands.
 func InitSimple(ctx context.Context) error {
-	if setting.Git.HomePath == "" {
-		return errors.New("unable to init Git's HomeDir, incorrect initialization of the setting and git modules")
-	}
-
-	if DefaultContext != nil && (!setting.IsProd || setting.IsInTesting) {
-		log.Warn("git module has been initialized already, duplicate init may work but it's better to fix it")
+	if err := checkInit(); err != nil {
+		return err
 	}
 
 	DefaultContext = ctx
@@ -158,24 +165,7 @@ func InitSimple(ctx context.Context) error {
 		defaultCommandExecutionTimeout = time.Duration(setting.Git.Timeout.Default) * time.Second
 	}
 
-	if err := SetExecutablePath(setting.Git.Path); err != nil {
-		return err
-	}
-
-	var err error
-	defaultFeatures, err = loadGitVersionFeatures()
-	if err != nil {
-		return err
-	}
-	if err = ensureGitVersion(); err != nil {
-		return err
-	}
-
-	// when git works with gnupg (commit signing), there should be a stable home for gnupg commands
-	if _, ok := os.LookupEnv("GNUPGHOME"); !ok {
-		_ = os.Setenv("GNUPGHOME", filepath.Join(HomeDir(), ".gnupg"))
-	}
-	return nil
+	return SetExecutablePath(setting.Git.Path)
 }
 
 // InitFull initializes git module with version check and change global variables, sync gitconfig.
@@ -185,18 +175,30 @@ func InitFull(ctx context.Context) (err error) {
 		return err
 	}
 
+	// when git works with gnupg (commit signing), there should be a stable home for gnupg commands
+	if _, ok := os.LookupEnv("GNUPGHOME"); !ok {
+		_ = os.Setenv("GNUPGHOME", filepath.Join(HomeDir(), ".gnupg"))
+	}
+
 	// Since git wire protocol has been released from git v2.18
-	if setting.Git.EnableAutoGitWireProtocol && DefaultFeatures().CheckVersionAtLeast("2.18") {
+	if setting.Git.EnableAutoGitWireProtocol && CheckGitVersionAtLeast("2.18") == nil {
 		globalCommandArgs = append(globalCommandArgs, "-c", "protocol.version=2")
 	}
 
 	// Explicitly disable credential helper, otherwise Git credentials might leak
-	if DefaultFeatures().CheckVersionAtLeast("2.9") {
+	if CheckGitVersionAtLeast("2.9") == nil {
 		globalCommandArgs = append(globalCommandArgs, "-c", "credential.helper=")
 	}
+	DefaultFeatures.SupportProcReceive = CheckGitVersionAtLeast("2.29") == nil
+	DefaultFeatures.SupportHashSha256 = CheckGitVersionAtLeast("2.42") == nil && !isGogit
+	if DefaultFeatures.SupportHashSha256 {
+		SupportedObjectFormats = append(SupportedObjectFormats, Sha256ObjectFormat)
+	} else {
+		log.Warn("sha256 hash support is disabled - requires Git >= 2.42. Gogit is currently unsupported")
+	}
 
 	if setting.LFS.StartServer {
-		if !DefaultFeatures().CheckVersionAtLeast("2.1.2") {
+		if CheckGitVersionAtLeast("2.1.2") != nil {
 			return errors.New("LFS server support requires Git >= 2.1.2")
 		}
 		globalCommandArgs = append(globalCommandArgs, "-c", "filter.lfs.required=", "-c", "filter.lfs.smudge=", "-c", "filter.lfs.clean=")
@@ -236,13 +238,13 @@ func syncGitConfig() (err error) {
 		return err
 	}
 
-	if DefaultFeatures().CheckVersionAtLeast("2.10") {
+	if CheckGitVersionAtLeast("2.10") == nil {
 		if err := configSet("receive.advertisePushOptions", "true"); err != nil {
 			return err
 		}
 	}
 
-	if DefaultFeatures().CheckVersionAtLeast("2.18") {
+	if CheckGitVersionAtLeast("2.18") == nil {
 		if err := configSet("core.commitGraph", "true"); err != nil {
 			return err
 		}
@@ -254,7 +256,7 @@ func syncGitConfig() (err error) {
 		}
 	}
 
-	if DefaultFeatures().SupportProcReceive {
+	if DefaultFeatures.SupportProcReceive {
 		// set support for AGit flow
 		if err := configAddNonExist("receive.procReceiveRefs", "refs/for"); err != nil {
 			return err
@@ -292,7 +294,7 @@ func syncGitConfig() (err error) {
 	}
 
 	// By default partial clones are disabled, enable them from git v2.22
-	if !setting.Git.DisablePartialClone && DefaultFeatures().CheckVersionAtLeast("2.22") {
+	if !setting.Git.DisablePartialClone && CheckGitVersionAtLeast("2.22") == nil {
 		if err = configSet("uploadpack.allowfilter", "true"); err != nil {
 			return err
 		}
@@ -307,6 +309,21 @@ func syncGitConfig() (err error) {
 	return err
 }
 
+// CheckGitVersionAtLeast check git version is at least the constraint version
+func CheckGitVersionAtLeast(atLeast string) error {
+	if DefaultFeatures.GitVersion == nil {
+		panic("git module is not initialized") // it shouldn't happen
+	}
+	atLeastVersion, err := version.NewVersion(atLeast)
+	if err != nil {
+		return err
+	}
+	if DefaultFeatures.GitVersion.Compare(atLeastVersion) < 0 {
+		return fmt.Errorf("installed git binary version %s is not at least %s", DefaultFeatures.GitVersion.Original(), atLeast)
+	}
+	return nil
+}
+
 func checkGitVersionCompatibility(gitVer *version.Version) error {
 	badVersions := []struct {
 		Version *version.Version

modules/git/grep.go

@@ -29,7 +29,6 @@ type GrepOptions struct {
 	ContextLineNumber int
 	IsFuzzy           bool
 	MaxLineLength     int // the maximum length of a line to parse, exceeding chars will be truncated
-	PathspecList      []string
 }
 
 func GrepSearch(ctx context.Context, repo *Repository, search string, opts GrepOptions) ([]*GrepResult, error) {
@@ -63,7 +62,6 @@ func GrepSearch(ctx context.Context, repo *Repository, search string, opts GrepO
 		cmd.AddOptionValues("-e", strings.TrimLeft(search, "-"))
 	}
 	cmd.AddDynamicArguments(util.IfZero(opts.RefName, "HEAD"))
-	cmd.AddDashesAndList(opts.PathspecList...)
 	opts.MaxResultLimit = util.IfZero(opts.MaxResultLimit, 50)
 	stderr := bytes.Buffer{}
 	err = cmd.Run(&RunOpts{

modules/git/grep_test.go

@@ -31,26 +31,6 @@ func TestGrepSearch(t *testing.T) {
 		},
 	}, res)
 
-	res, err = GrepSearch(context.Background(), repo, "void", GrepOptions{PathspecList: []string{":(glob)java-hello/*"}})
-	assert.NoError(t, err)
-	assert.Equal(t, []*GrepResult{
-		{
-			Filename:    "java-hello/main.java",
-			LineNumbers: []int{3},
-			LineCodes:   []string{" public static void main(String[] args)"},
-		},
-	}, res)
-
-	res, err = GrepSearch(context.Background(), repo, "void", GrepOptions{PathspecList: []string{":(glob,exclude)java-hello/*"}})
-	assert.NoError(t, err)
-	assert.Equal(t, []*GrepResult{
-		{
-			Filename:    "main.vendor.java",
-			LineNumbers: []int{3},
-			LineCodes:   []string{" public static void main(String[] args)"},
-		},
-	}, res)
-
 	res, err = GrepSearch(context.Background(), repo, "void", GrepOptions{MaxResultLimit: 1})
 	assert.NoError(t, err)
 	assert.Equal(t, []*GrepResult{

modules/git/object_format.go

@@ -120,8 +120,12 @@ var (
 	Sha256ObjectFormat ObjectFormat = Sha256ObjectFormatImpl{}
 )
 
+var SupportedObjectFormats = []ObjectFormat{
+	Sha1ObjectFormat,
+}
+
 func ObjectFormatFromName(name string) ObjectFormat {
-	for _, objectFormat := range DefaultFeatures().SupportedObjectFormats {
+	for _, objectFormat := range SupportedObjectFormats {
 		if name == objectFormat.Name() {
 			return objectFormat
 		}

modules/git/object_id.go

@@ -54,7 +54,7 @@ func (*Sha256Hash) Type() ObjectFormat { return Sha256ObjectFormat }
 
 func NewIDFromString(hexHash string) (ObjectID, error) {
 	var theObjectFormat ObjectFormat
-	for _, objectFormat := range DefaultFeatures().SupportedObjectFormats {
+	for _, objectFormat := range SupportedObjectFormats {
 		if len(hexHash) == objectFormat.FullLength() {
 			theObjectFormat = objectFormat
 			break

modules/git/remote.go

@@ -12,7 +12,7 @@ import (
 // GetRemoteAddress returns remote url of git repository in the repoPath with special remote name
 func GetRemoteAddress(ctx context.Context, repoPath, remoteName string) (string, error) {
 	var cmd *Command
-	if DefaultFeatures().CheckVersionAtLeast("2.7") {
+	if CheckGitVersionAtLeast("2.7") == nil {
 		cmd = NewCommand(ctx, "remote", "get-url").AddDynamicArguments(remoteName)
 	} else {
 		cmd = NewCommand(ctx, "config", "--get").AddDynamicArguments("remote." + remoteName + ".url")

modules/git/repo.go

@@ -7,6 +7,7 @@ package git
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/url"
@@ -62,6 +63,32 @@ func IsRepoURLAccessible(ctx context.Context, url string) bool {
 	return err == nil
 }
 
+// GetObjectFormatOfRepo returns the hash type of repository at a given path
+func GetObjectFormatOfRepo(ctx context.Context, repoPath string) (ObjectFormat, error) {
+	var stdout, stderr strings.Builder
+
+	err := NewCommand(ctx, "hash-object", "--stdin").Run(&RunOpts{
+		Dir:    repoPath,
+		Stdout: &stdout,
+		Stderr: &stderr,
+		Stdin:  &strings.Reader{},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if stderr.Len() > 0 {
+		return nil, errors.New(stderr.String())
+	}
+
+	h, err := NewIDFromString(strings.TrimRight(stdout.String(), "\n"))
+	if err != nil {
+		return nil, err
+	}
+
+	return h.Type(), nil
+}
+
 // InitRepository initializes a new Git repository.
 func InitRepository(ctx context.Context, repoPath string, bare bool, objectFormatName string) error {
 	err := os.MkdirAll(repoPath, os.ModePerm)
@@ -74,7 +101,7 @@ func InitRepository(ctx context.Context, repoPath string, bare bool, objectForma
 	if !IsValidObjectFormat(objectFormatName) {
 		return fmt.Errorf("invalid object format: %s", objectFormatName)
 	}
-	if DefaultFeatures().SupportHashSha256 {
+	if DefaultFeatures.SupportHashSha256 {
 		cmd.AddOptionValues("--object-format", objectFormatName)
 	}
 

modules/git/repo_base.go

@@ -0,0 +1,6 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+var isGogit bool

modules/git/repo_base_gogit.go

@@ -22,7 +22,9 @@ import (
 	"github.com/go-git/go-git/v5/storage/filesystem"
 )
 
-const isGogit = true
+func init() {
+	isGogit = true
+}
 
 // Repository represents a Git repository.
 type Repository struct {

modules/git/repo_base_nogogit.go

@@ -15,7 +15,9 @@ import (
 	"code.gitea.io/gitea/modules/util"
 )
 
-const isGogit = false
+func init() {
+	isGogit = false
+}
 
 // Repository represents a Git repository.
 type Repository struct {

modules/git/repo_commit.go

@@ -438,7 +438,7 @@ func (repo *Repository) getCommitsBeforeLimit(id ObjectID, num int) ([]*Commit,
 }
 
 func (repo *Repository) getBranches(commit *Commit, limit int) ([]string, error) {
-	if DefaultFeatures().CheckVersionAtLeast("2.7.0") {
+	if CheckGitVersionAtLeast("2.7.0") == nil {
 		stdout, _, err := NewCommand(repo.Ctx, "for-each-ref", "--format=%(refname:strip=2)").
 			AddOptionFormat("--count=%d", limit).
 			AddOptionValues("--contains", commit.ID.String(), BranchPrefix).

modules/git/repo_commitgraph.go

@@ -11,7 +11,7 @@ import (
 // WriteCommitGraph write commit graph to speed up repo access
 // this requires git v2.18 to be installed
 func WriteCommitGraph(ctx context.Context, repoPath string) error {
-	if DefaultFeatures().CheckVersionAtLeast("2.18") {
+	if CheckGitVersionAtLeast("2.18") == nil {
 		if _, _, err := NewCommand(ctx, "commit-graph", "write").RunStdString(&RunOpts{Dir: repoPath}); err != nil {
 			return fmt.Errorf("unable to write commit-graph for '%s' : %w", repoPath, err)
 		}

modules/git/utils.go

@@ -4,8 +4,6 @@
 package git
 
 import (
-	"crypto/sha1"
-	"encoding/hex"
 	"fmt"
 	"io"
 	"os"
@@ -130,9 +128,3 @@ func (l *LimitedReaderCloser) Read(p []byte) (n int, err error) {
 func (l *LimitedReaderCloser) Close() error {
 	return l.C.Close()
 }
-
-func HashFilePathForWebUI(s string) string {
-	h := sha1.New()
-	_, _ = h.Write([]byte(s))
-	return hex.EncodeToString(h.Sum(nil))
-}

modules/git/utils_test.go

@@ -1,17 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package git
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestHashFilePathForWebUI(t *testing.T) {
-	assert.Equal(t,
-		"8843d7f92416211de9ebb963ff4ce28125932878",
-		HashFilePathForWebUI("foobar"),
-	)
-}

modules/httplib/serve.go

@@ -17,14 +17,11 @@ import (
 	"time"
 
 	charsetModule "code.gitea.io/gitea/modules/charset"
-	"code.gitea.io/gitea/modules/container"
 	"code.gitea.io/gitea/modules/httpcache"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/typesniffer"
 	"code.gitea.io/gitea/modules/util"
-
-	"github.com/klauspost/compress/gzhttp"
 )
 
 type ServeHeaderOptions struct {
@@ -41,11 +38,6 @@ type ServeHeaderOptions struct {
 func ServeSetHeaders(w http.ResponseWriter, opts *ServeHeaderOptions) {
 	header := w.Header()
 
-	skipCompressionExts := container.SetOf(".gz", ".bz2", ".zip", ".xz", ".zst", ".deb", ".apk", ".jar", ".png", ".jpg", ".webp")
-	if skipCompressionExts.Contains(strings.ToLower(path.Ext(opts.Filename))) {
-		w.Header().Add(gzhttp.HeaderNoCompression, "1")
-	}
-
 	contentType := typesniffer.ApplicationOctetStream
 	if opts.ContentType != "" {
 		if opts.ContentTypeCharset != "" {

modules/httplib/url.go

@@ -4,8 +4,6 @@
 package httplib
 
 import (
-	"context"
-	"net/http"
 	"net/url"
 	"strings"
 
@@ -13,10 +11,6 @@ import (
 	"code.gitea.io/gitea/modules/util"
 )
 
-type RequestContextKeyStruct struct{}
-
-var RequestContextKey = RequestContextKeyStruct{}
-
 func urlIsRelative(s string, u *url.URL) bool {
 	// Unfortunately browsers consider a redirect Location with preceding "//", "\\", "/\" and "\/" as meaning redirect to "http(s)://REST_OF_PATH"
 	// Therefore we should ignore these redirect locations to prevent open redirects
@@ -32,65 +26,7 @@ func IsRelativeURL(s string) bool {
 	return err == nil && urlIsRelative(s, u)
 }
 
-func getRequestScheme(req *http.Request) string {
-	// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto
-	if s := req.Header.Get("X-Forwarded-Proto"); s != "" {
-		return s
-	}
-	if s := req.Header.Get("X-Forwarded-Protocol"); s != "" {
-		return s
-	}
-	if s := req.Header.Get("X-Url-Scheme"); s != "" {
-		return s
-	}
-	if s := req.Header.Get("Front-End-Https"); s != "" {
-		return util.Iif(s == "on", "https", "http")
-	}
-	if s := req.Header.Get("X-Forwarded-Ssl"); s != "" {
-		return util.Iif(s == "on", "https", "http")
-	}
-	return ""
-}
-
-func getForwardedHost(req *http.Request) string {
-	// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Host
-	return req.Header.Get("X-Forwarded-Host")
-}
-
-// GuessCurrentAppURL tries to guess the current full URL by http headers. It always has a '/' suffix, exactly the same as setting.AppURL
-func GuessCurrentAppURL(ctx context.Context) string {
-	req, ok := ctx.Value(RequestContextKey).(*http.Request)
-	if !ok {
-		return setting.AppURL
-	}
-	// If no scheme provided by reverse proxy, then do not guess the AppURL, use the configured one.
-	// At the moment, if site admin doesn't configure the proxy headers correctly, then Gitea would guess wrong.
-	// There are some cases:
-	// 1. The reverse proxy is configured correctly, it passes "X-Forwarded-Proto/Host" headers. Perfect, Gitea can handle it correctly.
-	// 2. The reverse proxy is not configured correctly, doesn't pass "X-Forwarded-Proto/Host" headers, eg: only one "proxy_pass http://gitea:3000" in Nginx.
-	// 3. There is no reverse proxy.
-	// Without an extra config option, Gitea is impossible to distinguish between case 2 and case 3,
-	// then case 2 would result in wrong guess like guessed AppURL becomes "http://gitea:3000/", which is not accessible by end users.
-	// So in the future maybe it should introduce a new config option, to let site admin decide how to guess the AppURL.
-	reqScheme := getRequestScheme(req)
-	if reqScheme == "" {
-		return setting.AppURL
-	}
-	reqHost := getForwardedHost(req)
-	if reqHost == "" {
-		reqHost = req.Host
-	}
-	return reqScheme + "://" + reqHost + setting.AppSubURL + "/"
-}
-
-func MakeAbsoluteURL(ctx context.Context, s string) string {
-	if IsRelativeURL(s) {
-		return GuessCurrentAppURL(ctx) + strings.TrimPrefix(s, "/")
-	}
-	return s
-}
-
-func IsCurrentGiteaSiteURL(ctx context.Context, s string) bool {
+func IsCurrentGiteaSiteURL(s string) bool {
 	u, err := url.Parse(s)
 	if err != nil {
 		return false
@@ -109,6 +45,5 @@ func IsCurrentGiteaSiteURL(ctx context.Context, s string) bool {
 	if u.Path == "" {
 		u.Path = "/"
 	}
-	urlLower := strings.ToLower(u.String())
-	return strings.HasPrefix(urlLower, strings.ToLower(setting.AppURL)) || strings.HasPrefix(urlLower, strings.ToLower(GuessCurrentAppURL(ctx)))
+	return strings.HasPrefix(strings.ToLower(u.String()), strings.ToLower(setting.AppURL))
 }

modules/httplib/url_test.go

@@ -4,8 +4,6 @@
 package httplib
 
 import (
-	"context"
-	"net/http"
 	"testing"
 
 	"code.gitea.io/gitea/modules/setting"
@@ -39,44 +37,9 @@ func TestIsRelativeURL(t *testing.T) {
 	}
 }
 
-func TestMakeAbsoluteURL(t *testing.T) {
-	defer test.MockVariableValue(&setting.Protocol, "http")()
-	defer test.MockVariableValue(&setting.AppURL, "http://cfg-host/sub/")()
-	defer test.MockVariableValue(&setting.AppSubURL, "/sub")()
-
-	ctx := context.Background()
-	assert.Equal(t, "http://cfg-host/sub/", MakeAbsoluteURL(ctx, ""))
-	assert.Equal(t, "http://cfg-host/sub/foo", MakeAbsoluteURL(ctx, "foo"))
-	assert.Equal(t, "http://cfg-host/sub/foo", MakeAbsoluteURL(ctx, "/foo"))
-	assert.Equal(t, "http://other/foo", MakeAbsoluteURL(ctx, "http://other/foo"))
-
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{
-		Host: "user-host",
-	})
-	assert.Equal(t, "http://cfg-host/sub/foo", MakeAbsoluteURL(ctx, "/foo"))
-
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{
-		Host: "user-host",
-		Header: map[string][]string{
-			"X-Forwarded-Host": {"forwarded-host"},
-		},
-	})
-	assert.Equal(t, "http://cfg-host/sub/foo", MakeAbsoluteURL(ctx, "/foo"))
-
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{
-		Host: "user-host",
-		Header: map[string][]string{
-			"X-Forwarded-Host":  {"forwarded-host"},
-			"X-Forwarded-Proto": {"https"},
-		},
-	})
-	assert.Equal(t, "https://forwarded-host/sub/foo", MakeAbsoluteURL(ctx, "/foo"))
-}
-
 func TestIsCurrentGiteaSiteURL(t *testing.T) {
 	defer test.MockVariableValue(&setting.AppURL, "http://localhost:3000/sub/")()
 	defer test.MockVariableValue(&setting.AppSubURL, "/sub")()
-	ctx := context.Background()
 	good := []string{
 		"?key=val",
 		"/sub",
@@ -87,7 +50,7 @@ func TestIsCurrentGiteaSiteURL(t *testing.T) {
 		"http://localhost:3000/sub/",
 	}
 	for _, s := range good {
-		assert.True(t, IsCurrentGiteaSiteURL(ctx, s), "good = %q", s)
+		assert.True(t, IsCurrentGiteaSiteURL(s), "good = %q", s)
 	}
 	bad := []string{
 		".",
@@ -101,23 +64,13 @@ func TestIsCurrentGiteaSiteURL(t *testing.T) {
 		"http://other/",
 	}
 	for _, s := range bad {
-		assert.False(t, IsCurrentGiteaSiteURL(ctx, s), "bad = %q", s)
+		assert.False(t, IsCurrentGiteaSiteURL(s), "bad = %q", s)
 	}
 
 	setting.AppURL = "http://localhost:3000/"
 	setting.AppSubURL = ""
-	assert.False(t, IsCurrentGiteaSiteURL(ctx, "//"))
-	assert.False(t, IsCurrentGiteaSiteURL(ctx, "\\\\"))
-	assert.False(t, IsCurrentGiteaSiteURL(ctx, "http://localhost"))
-	assert.True(t, IsCurrentGiteaSiteURL(ctx, "http://localhost:3000?key=val"))
-
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{
-		Host: "user-host",
-		Header: map[string][]string{
-			"X-Forwarded-Host":  {"forwarded-host"},
-			"X-Forwarded-Proto": {"https"},
-		},
-	})
-	assert.True(t, IsCurrentGiteaSiteURL(ctx, "http://localhost:3000"))
-	assert.True(t, IsCurrentGiteaSiteURL(ctx, "https://forwarded-host"))
+	assert.False(t, IsCurrentGiteaSiteURL("//"))
+	assert.False(t, IsCurrentGiteaSiteURL("\\\\"))
+	assert.False(t, IsCurrentGiteaSiteURL("http://localhost"))
+	assert.True(t, IsCurrentGiteaSiteURL("http://localhost:3000?key=val"))
 }

modules/indexer/code/bleve/bleve.go

@@ -39,6 +39,8 @@ import (
 const (
 	unicodeNormalizeName = "unicodeNormalize"
 	maxBatchSize         = 16
+	// fuzzyDenominator determines the levenshtein distance per each character of a keyword
+	fuzzyDenominator = 4
 )
 
 func addUnicodeNormalizeTokenFilter(m *mapping.IndexMappingImpl) error {
@@ -243,7 +245,7 @@ func (b *Indexer) Search(ctx context.Context, opts *internal.SearchOptions) (int
 	phraseQuery.Analyzer = repoIndexerAnalyzer
 	keywordQuery = phraseQuery
 	if opts.IsKeywordFuzzy {
-		phraseQuery.Fuzziness = inner_bleve.GuessFuzzinessByKeyword(opts.Keyword)
+		phraseQuery.Fuzziness = len(opts.Keyword) / fuzzyDenominator
 	}
 
 	if len(opts.RepoIDs) > 0 {

modules/indexer/internal/bleve/util.go

@@ -47,15 +47,3 @@ func openIndexer(path string, latestVersion int) (bleve.Index, int, error) {
 
 	return index, 0, nil
 }
-
-func GuessFuzzinessByKeyword(s string) int {
-	// according to https://github.com/blevesearch/bleve/issues/1563, the supported max fuzziness is 2
-	// magic number 4 was chosen to determine the levenshtein distance per each character of a keyword
-	// BUT, when using CJK (eg: `갃갃갃` `啊啊啊`), it mismatches a lot.
-	for _, r := range s {
-		if r >= 128 {
-			return 0
-		}
-	}
-	return min(2, len(s)/4)
-}

modules/indexer/issues/bleve/bleve.go

@@ -35,7 +35,11 @@ func addUnicodeNormalizeTokenFilter(m *mapping.IndexMappingImpl) error {
 	})
 }
 
-const maxBatchSize = 16
+const (
+	maxBatchSize = 16
+	// fuzzyDenominator determines the levenshtein distance per each character of a keyword
+	fuzzyDenominator = 4
+)
 
 // IndexerData an update to the issue indexer
 type IndexerData internal.IndexerData
@@ -158,7 +162,7 @@ func (b *Indexer) Search(ctx context.Context, options *internal.SearchOptions) (
 	if options.Keyword != "" {
 		fuzziness := 0
 		if options.IsFuzzyKeyword {
-			fuzziness = inner_bleve.GuessFuzzinessByKeyword(options.Keyword)
+			fuzziness = len(options.Keyword) / fuzzyDenominator
 		}
 
 		queries = append(queries, bleve.NewDisjunctionQuery([]query.Query{

modules/issue/template/template.go

@@ -91,9 +91,6 @@ func validateYaml(template *api.IssueTemplate) error {
 			if err := validateOptions(field, idx); err != nil {
 				return err
 			}
-			if err := validateDropdownDefault(position, field.Attributes); err != nil {
-				return err
-			}
 		case api.IssueFormFieldTypeCheckboxes:
 			if err := validateStringItem(position, field.Attributes, false, "description"); err != nil {
 				return err
@@ -252,28 +249,6 @@ func validateBoolItem(position errorPosition, m map[string]any, names ...string)
 	return nil
 }
 
-func validateDropdownDefault(position errorPosition, attributes map[string]any) error {
-	v, ok := attributes["default"]
-	if !ok {
-		return nil
-	}
-	defaultValue, ok := v.(int)
-	if !ok {
-		return position.Errorf("'default' should be an int")
-	}
-
-	options, ok := attributes["options"].([]any)
-	if !ok {
-		// should not happen
-		return position.Errorf("'options' is required and should be a array")
-	}
-	if defaultValue < 0 || defaultValue >= len(options) {
-		return position.Errorf("the value of 'default' is out of range")
-	}
-
-	return nil
-}
-
 type errorPosition string
 
 func (p errorPosition) Errorf(format string, a ...any) error {

modules/issue/template/template_test.go

@@ -355,96 +355,6 @@ body:
 `,
 			wantErr: "body[0](checkboxes), option[1]: can not require a hidden checkbox",
 		},
-		{
-			name: "dropdown default is not an integer",
-			content: `
-name: "test"
-about: "this is about"
-body:
-  - type: dropdown
-    id: "1"
-    attributes:
-      label: Label of dropdown
-      description: Description of dropdown
-      multiple: true
-      options:
-        - Option 1 of dropdown
-        - Option 2 of dropdown
-        - Option 3 of dropdown
-      default: "def"
-    validations:
-      required: true
-`,
-			wantErr: "body[0](dropdown): 'default' should be an int",
-		},
-		{
-			name: "dropdown default is out of range",
-			content: `
-name: "test"
-about: "this is about"
-body:
-  - type: dropdown
-    id: "1"
-    attributes:
-      label: Label of dropdown
-      description: Description of dropdown
-      multiple: true
-      options:
-        - Option 1 of dropdown
-        - Option 2 of dropdown
-        - Option 3 of dropdown
-      default: 3
-    validations:
-      required: true
-`,
-			wantErr: "body[0](dropdown): the value of 'default' is out of range",
-		},
-		{
-			name: "dropdown without default is valid",
-			content: `
-name: "test"
-about: "this is about"
-body:
-  - type: dropdown
-    id: "1"
-    attributes:
-      label: Label of dropdown
-      description: Description of dropdown
-      multiple: true
-      options:
-        - Option 1 of dropdown
-        - Option 2 of dropdown
-        - Option 3 of dropdown
-    validations:
-      required: true
-`,
-			want: &api.IssueTemplate{
-				Name:  "test",
-				About: "this is about",
-				Fields: []*api.IssueFormField{
-					{
-						Type: "dropdown",
-						ID:   "1",
-						Attributes: map[string]any{
-							"label":       "Label of dropdown",
-							"description": "Description of dropdown",
-							"multiple":    true,
-							"options": []any{
-								"Option 1 of dropdown",
-								"Option 2 of dropdown",
-								"Option 3 of dropdown",
-							},
-						},
-						Validations: map[string]any{
-							"required": true,
-						},
-						Visible: []api.IssueFormFieldVisible{api.IssueFormFieldVisibleForm, api.IssueFormFieldVisibleContent},
-					},
-				},
-				FileName: "test.yaml",
-			},
-			wantErr: "",
-		},
 		{
 			name: "valid",
 			content: `
@@ -489,7 +399,6 @@ body:
         - Option 1 of dropdown
         - Option 2 of dropdown
         - Option 3 of dropdown
-      default: 1
     validations:
       required: true
   - type: checkboxes
@@ -566,7 +475,6 @@ body:
 								"Option 2 of dropdown",
 								"Option 3 of dropdown",
 							},
-							"default": 1,
 						},
 						Validations: map[string]any{
 							"required": true,

modules/lfs/pointer_scanner_nogogit.go

@@ -41,7 +41,7 @@ func SearchPointerBlobs(ctx context.Context, repo *git.Repository, pointerChan c
 	go pipeline.BlobsLessThan1024FromCatFileBatchCheck(catFileCheckReader, shasToBatchWriter, &wg)
 
 	// 1. Run batch-check on all objects in the repository
-	if !git.DefaultFeatures().CheckVersionAtLeast("2.6.0") {
+	if git.CheckGitVersionAtLeast("2.6.0") != nil {
 		revListReader, revListWriter := io.Pipe()
 		shasToCheckReader, shasToCheckWriter := io.Pipe()
 		wg.Add(2)

modules/markup/html.go

@@ -10,7 +10,6 @@ import (
 	"path"
 	"path/filepath"
 	"regexp"
-	"slices"
 	"strings"
 	"sync"
 
@@ -55,7 +54,7 @@ var (
 	shortLinkPattern = regexp.MustCompile(`\[\[(.*?)\]\](\w*)`)
 
 	// anyHashPattern splits url containing SHA into parts
-	anyHashPattern = regexp.MustCompile(`https?://(?:\S+/){4,5}([0-9a-f]{40,64})(/[-+~%./\w]+)?(\?[-+~%.\w&=]+)?(#[-+~%.\w]+)?`)
+	anyHashPattern = regexp.MustCompile(`https?://(?:\S+/){4,5}([0-9a-f]{40,64})(/[-+~_%.a-zA-Z0-9/]+)?(#[-+~_%.a-zA-Z0-9]+)?`)
 
 	// comparePattern matches "http://domain/org/repo/compare/COMMIT1...COMMIT2#hash"
 	comparePattern = regexp.MustCompile(`https?://(?:\S+/){4,5}([0-9a-f]{7,64})(\.\.\.?)([0-9a-f]{7,64})?(#[-+~_%.a-zA-Z0-9]+)?`)
@@ -592,17 +591,17 @@ func replaceContentList(node *html.Node, i, j int, newNodes []*html.Node) {
 
 func mentionProcessor(ctx *RenderContext, node *html.Node) {
 	start := 0
-	nodeStop := node.NextSibling
-	for node != nodeStop {
-		found, loc := references.FindFirstMentionBytes(util.UnsafeStringToBytes(node.Data[start:]))
+	next := node.NextSibling
+	for node != nil && node != next && start < len(node.Data) {
+		// We replace only the first mention; other mentions will be addressed later
+		found, loc := references.FindFirstMentionBytes([]byte(node.Data[start:]))
 		if !found {
-			node = node.NextSibling
-			start = 0
-			continue
+			return
 		}
 		loc.Start += start
 		loc.End += start
 		mention := node.Data[loc.Start:loc.End]
+		var teams string
 		teams, ok := ctx.Metas["teams"]
 		// FIXME: util.URLJoin may not be necessary here:
 		// - setting.AppURL is defined to have a terminal '/' so unless mention[1:]
@@ -624,10 +623,10 @@ func mentionProcessor(ctx *RenderContext, node *html.Node) {
 		if DefaultProcessorHelper.IsUsernameMentionable != nil && DefaultProcessorHelper.IsUsernameMentionable(ctx.Ctx, mentionedUsername) {
 			replaceContent(node, loc.Start, loc.End, createLink(util.URLJoin(ctx.Links.Prefix(), mentionedUsername), mention, "mention"))
 			node = node.NextSibling.NextSibling
-			start = 0
 		} else {
-			start = loc.End
+			node = node.NextSibling
 		}
+		start = 0
 	}
 }
 
@@ -964,68 +963,57 @@ func commitCrossReferencePatternProcessor(ctx *RenderContext, node *html.Node) {
 	}
 }
 
-type anyHashPatternResult struct {
-	PosStart  int
-	PosEnd    int
-	FullURL   string
-	CommitID  string
-	SubPath   string
-	QueryHash string
-}
-
-func anyHashPatternExtract(s string) (ret anyHashPatternResult, ok bool) {
-	m := anyHashPattern.FindStringSubmatchIndex(s)
-	if m == nil {
-		return ret, false
-	}
-
-	ret.PosStart, ret.PosEnd = m[0], m[1]
-	ret.FullURL = s[ret.PosStart:ret.PosEnd]
-	if strings.HasSuffix(ret.FullURL, ".") {
-		// if url ends in '.', it's very likely that it is not part of the actual url but used to finish a sentence.
-		ret.PosEnd--
-		ret.FullURL = ret.FullURL[:len(ret.FullURL)-1]
-		for i := 0; i < len(m); i++ {
-			m[i] = min(m[i], ret.PosEnd)
-		}
-	}
-
-	ret.CommitID = s[m[2]:m[3]]
-	if m[5] > 0 {
-		ret.SubPath = s[m[4]:m[5]]
-	}
-
-	lastStart, lastEnd := m[len(m)-2], m[len(m)-1]
-	if lastEnd > 0 {
-		ret.QueryHash = s[lastStart:lastEnd][1:]
-	}
-	return ret, true
-}
-
 // fullHashPatternProcessor renders SHA containing URLs
 func fullHashPatternProcessor(ctx *RenderContext, node *html.Node) {
 	if ctx.Metas == nil {
 		return
 	}
-	nodeStop := node.NextSibling
-	for node != nodeStop {
-		if node.Type != html.TextNode {
-			node = node.NextSibling
-			continue
+
+	next := node.NextSibling
+	for node != nil && node != next {
+		m := anyHashPattern.FindStringSubmatchIndex(node.Data)
+		if m == nil {
+			return
 		}
-		ret, ok := anyHashPatternExtract(node.Data)
-		if !ok {
-			node = node.NextSibling
-			continue
+
+		urlFull := node.Data[m[0]:m[1]]
+		text := base.ShortSha(node.Data[m[2]:m[3]])
+
+		// 3rd capture group matches a optional path
+		subpath := ""
+		if m[5] > 0 {
+			subpath = node.Data[m[4]:m[5]]
 		}
-		text := base.ShortSha(ret.CommitID)
-		if ret.SubPath != "" {
-			text += ret.SubPath
+
+		// 4th capture group matches a optional url hash
+		hash := ""
+		if m[7] > 0 {
+			hash = node.Data[m[6]:m[7]][1:]
 		}
-		if ret.QueryHash != "" {
-			text += " (" + ret.QueryHash + ")"
+
+		start := m[0]
+		end := m[1]
+
+		// If url ends in '.', it's very likely that it is not part of the
+		// actual url but used to finish a sentence.
+		if strings.HasSuffix(urlFull, ".") {
+			end--
+			urlFull = urlFull[:len(urlFull)-1]
+			if hash != "" {
+				hash = hash[:len(hash)-1]
+			} else if subpath != "" {
+				subpath = subpath[:len(subpath)-1]
+			}
 		}
-		replaceContent(node, ret.PosStart, ret.PosEnd, createCodeLink(ret.FullURL, text, "commit"))
+
+		if subpath != "" {
+			text += subpath
+		}
+
+		if hash != "" {
+			text += " (" + hash + ")"
+		}
+		replaceContent(node, start, end, createCodeLink(urlFull, text, "commit"))
 		node = node.NextSibling.NextSibling
 	}
 }
@@ -1034,16 +1022,19 @@ func comparePatternProcessor(ctx *RenderContext, node *html.Node) {
 	if ctx.Metas == nil {
 		return
 	}
-	nodeStop := node.NextSibling
-	for node != nodeStop {
-		if node.Type != html.TextNode {
-			node = node.NextSibling
-			continue
-		}
+
+	next := node.NextSibling
+	for node != nil && node != next {
 		m := comparePattern.FindStringSubmatchIndex(node.Data)
-		if m == nil || slices.Contains(m[:8], -1) { // ensure that every group (m[0]...m[7]) has a match
-			node = node.NextSibling
-			continue
+		if m == nil {
+			return
+		}
+
+		// Ensure that every group (m[0]...m[7]) has a match
+		for i := 0; i < 8; i++ {
+			if m[i] == -1 {
+				return
+			}
 		}
 
 		urlFull := node.Data[m[0]:m[1]]

modules/markup/html_codepreview.go

@@ -42,7 +42,7 @@ func renderCodeBlock(ctx *RenderContext, node *html.Node) (urlPosStart, urlPosSt
 		CommitID:  node.Data[m[6]:m[7]],
 		FilePath:  node.Data[m[8]:m[9]],
 	}
-	if !httplib.IsCurrentGiteaSiteURL(ctx.Ctx, opts.FullURL) {
+	if !httplib.IsCurrentGiteaSiteURL(opts.FullURL) {
 		return 0, 0, "", nil
 	}
 	u, err := url.Parse(opts.FilePath)
@@ -60,8 +60,7 @@ func renderCodeBlock(ctx *RenderContext, node *html.Node) (urlPosStart, urlPosSt
 }
 
 func codePreviewPatternProcessor(ctx *RenderContext, node *html.Node) {
-	nodeStop := node.NextSibling
-	for node != nodeStop {
+	for node != nil {
 		if node.Type != html.TextNode {
 			node = node.NextSibling
 			continue

modules/markup/html_internal_test.go

@@ -399,61 +399,36 @@ func TestRegExp_sha1CurrentPattern(t *testing.T) {
 }
 
 func TestRegExp_anySHA1Pattern(t *testing.T) {
-	testCases := map[string]anyHashPatternResult{
+	testCases := map[string][]string{
 		"https://github.com/jquery/jquery/blob/a644101ed04d0beacea864ce805e0c4f86ba1cd1/test/unit/event.js#L2703": {
-			CommitID:  "a644101ed04d0beacea864ce805e0c4f86ba1cd1",
-			SubPath:   "/test/unit/event.js",
-			QueryHash: "L2703",
+			"a644101ed04d0beacea864ce805e0c4f86ba1cd1",
+			"/test/unit/event.js",
+			"#L2703",
 		},
 		"https://github.com/jquery/jquery/blob/a644101ed04d0beacea864ce805e0c4f86ba1cd1/test/unit/event.js": {
-			CommitID: "a644101ed04d0beacea864ce805e0c4f86ba1cd1",
-			SubPath:  "/test/unit/event.js",
+			"a644101ed04d0beacea864ce805e0c4f86ba1cd1",
+			"/test/unit/event.js",
+			"",
 		},
 		"https://github.com/jquery/jquery/commit/0705be475092aede1eddae01319ec931fb9c65fc": {
-			CommitID: "0705be475092aede1eddae01319ec931fb9c65fc",
+			"0705be475092aede1eddae01319ec931fb9c65fc",
+			"",
+			"",
 		},
 		"https://github.com/jquery/jquery/tree/0705be475092aede1eddae01319ec931fb9c65fc/src": {
-			CommitID: "0705be475092aede1eddae01319ec931fb9c65fc",
-			SubPath:  "/src",
+			"0705be475092aede1eddae01319ec931fb9c65fc",
+			"/src",
+			"",
 		},
 		"https://try.gogs.io/gogs/gogs/commit/d8a994ef243349f321568f9e36d5c3f444b99cae#diff-2": {
-			CommitID:  "d8a994ef243349f321568f9e36d5c3f444b99cae",
-			QueryHash: "diff-2",
-		},
-		"non-url": {},
-		"http://a/b/c/d/e/1234567812345678123456781234567812345678123456781234567812345678?a=b#L1-L2": {
-			CommitID:  "1234567812345678123456781234567812345678123456781234567812345678",
-			QueryHash: "L1-L2",
-		},
-		"http://a/b/c/d/e/1234567812345678123456781234567812345678123456781234567812345678.": {
-			CommitID: "1234567812345678123456781234567812345678123456781234567812345678",
-		},
-		"http://a/b/c/d/e/1234567812345678123456781234567812345678123456781234567812345678/sub.": {
-			CommitID: "1234567812345678123456781234567812345678123456781234567812345678",
-			SubPath:  "/sub",
-		},
-		"http://a/b/c/d/e/1234567812345678123456781234567812345678123456781234567812345678?a=b.": {
-			CommitID: "1234567812345678123456781234567812345678123456781234567812345678",
-		},
-		"http://a/b/c/d/e/1234567812345678123456781234567812345678123456781234567812345678?a=b&c=d": {
-			CommitID: "1234567812345678123456781234567812345678123456781234567812345678",
-		},
-		"http://a/b/c/d/e/1234567812345678123456781234567812345678123456781234567812345678#hash.": {
-			CommitID:  "1234567812345678123456781234567812345678123456781234567812345678",
-			QueryHash: "hash",
+			"d8a994ef243349f321568f9e36d5c3f444b99cae",
+			"",
+			"#diff-2",
 		},
 	}
 
 	for k, v := range testCases {
-		ret, ok := anyHashPatternExtract(k)
-		if v.CommitID == "" {
-			assert.False(t, ok)
-		} else {
-			assert.EqualValues(t, strings.TrimSuffix(k, "."), ret.FullURL)
-			assert.EqualValues(t, v.CommitID, ret.CommitID)
-			assert.EqualValues(t, v.SubPath, ret.SubPath)
-			assert.EqualValues(t, v.QueryHash, ret.QueryHash)
-		}
+		assert.Equal(t, anyHashPattern.FindStringSubmatch(k)[1:], v)
 	}
 }
 

modules/markup/html_test.go

@@ -124,11 +124,6 @@ func TestRender_CrossReferences(t *testing.T) {
 	test(
 		util.URLJoin(markup.TestAppURL, "gogitea", "some-repo-name", "issues", "12345"),
 		`<p><a href="`+util.URLJoin(markup.TestAppURL, "gogitea", "some-repo-name", "issues", "12345")+`" class="ref-issue" rel="nofollow">gogitea/some-repo-name#12345</a></p>`)
-
-	inputURL := "https://host/a/b/commit/0123456789012345678901234567890123456789/foo.txt?a=b#L2-L3"
-	test(
-		inputURL,
-		`<p><a href="`+inputURL+`" rel="nofollow"><code>0123456789/foo.txt (L2-L3)</code></a></p>`)
 }
 
 func TestMisc_IsSameDomain(t *testing.T) {
@@ -700,7 +695,7 @@ func TestIssue18471(t *testing.T) {
 	}, strings.NewReader(data), &res)
 
 	assert.NoError(t, err)
-	assert.Equal(t, `<a href="http://domain/org/repo/compare/783b039...da951ce" class="compare"><code class="nohighlight">783b039...da951ce</code></a>`, res.String())
+	assert.Equal(t, "<a href=\"http://domain/org/repo/compare/783b039...da951ce\" class=\"compare\"><code class=\"nohighlight\">783b039...da951ce</code></a>", res.String())
 }
 
 func TestIsFullURL(t *testing.T) {

modules/private/hook.go

@@ -12,7 +12,6 @@ import (
 
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/optional"
-	"code.gitea.io/gitea/modules/repository"
 	"code.gitea.io/gitea/modules/setting"
 )
 
@@ -55,7 +54,6 @@ type HookOptions struct {
 	GitQuarantinePath               string
 	GitPushOptions                  GitPushOptions
 	PullRequestID                   int64
-	PushTrigger                     repository.PushTrigger
 	DeployKeyID                     int64 // if the pusher is a DeployKey, then UserID is the repo's org user.
 	IsWiki                          bool
 	ActionPerm                      int

modules/references/references.go

@@ -29,7 +29,7 @@ var (
 	// TODO: fix invalid linking issue
 
 	// mentionPattern matches all mentions in the form of "@user" or "@org/team"
-	mentionPattern = regexp.MustCompile(`(?:\s|^|\(|\[)(@[-\w][-.\w]*?|@[-\w][-.\w]*?/[-\w][-.\w]*?)(?:\s|$|[:,;.?!](\s|$)|'|\)|\])`)
+	mentionPattern = regexp.MustCompile(`(?:\s|^|\(|\[)(@[0-9a-zA-Z-_]+|@[0-9a-zA-Z-_]+\/?[0-9a-zA-Z-_]+|@[0-9a-zA-Z-_][0-9a-zA-Z-_.]+\/?[0-9a-zA-Z-_.]+[0-9a-zA-Z-_])(?:\s|[:,;.?!]\s|[:,;.?!]?$|\)|\])`)
 	// issueNumericPattern matches string that references to a numeric issue, e.g. #1287
 	issueNumericPattern = regexp.MustCompile(`(?:\s|^|\(|\[|\'|\")([#!][0-9]+)(?:\s|$|\)|\]|\'|\"|[:;,.?!]\s|[:;,.?!]$)`)
 	// issueAlphanumericPattern matches string that references to an alphanumeric issue, e.g. ABC-1234

modules/references/references_test.go

@@ -392,7 +392,6 @@ func TestRegExp_mentionPattern(t *testing.T) {
 		{"@gitea,", "@gitea"},
 		{"@gitea;", "@gitea"},
 		{"@gitea/team1;", "@gitea/team1"},
-		{"@user's idea", "@user"},
 	}
 	falseTestCases := []string{
 		"@ 0",
@@ -413,6 +412,7 @@ func TestRegExp_mentionPattern(t *testing.T) {
 
 	for _, testCase := range trueTestCases {
 		found := mentionPattern.FindStringSubmatch(testCase.pat)
+		assert.Len(t, found, 2)
 		assert.Equal(t, testCase.exp, found[1])
 	}
 	for _, testCase := range falseTestCases {

modules/repository/branch.go

@@ -5,7 +5,6 @@ package repository
 
 import (
 	"context"
-	"fmt"
 
 	"code.gitea.io/gitea/models/db"
 	git_model "code.gitea.io/gitea/models/git"
@@ -37,15 +36,6 @@ func SyncRepoBranches(ctx context.Context, repoID, doerID int64) (int64, error)
 }
 
 func SyncRepoBranchesWithRepo(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, doerID int64) (int64, error) {
-	objFmt, err := gitRepo.GetObjectFormat()
-	if err != nil {
-		return 0, fmt.Errorf("GetObjectFormat: %w", err)
-	}
-	_, err = db.GetEngine(ctx).ID(repo.ID).Update(&repo_model.Repository{ObjectFormatName: objFmt.Name()})
-	if err != nil {
-		return 0, fmt.Errorf("UpdateRepository: %w", err)
-	}
-
 	allBranches := container.Set[string]{}
 	{
 		branches, _, err := gitRepo.GetBranchNames(0, 0)

modules/repository/branch_test.go

@@ -1,31 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package repository
-
-import (
-	"testing"
-
-	"code.gitea.io/gitea/models/db"
-	git_model "code.gitea.io/gitea/models/git"
-	repo_model "code.gitea.io/gitea/models/repo"
-	"code.gitea.io/gitea/models/unittest"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSyncRepoBranches(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	_, err := db.GetEngine(db.DefaultContext).ID(1).Update(&repo_model.Repository{ObjectFormatName: "bad-fmt"})
-	assert.NoError(t, db.TruncateBeans(db.DefaultContext, &git_model.Branch{}))
-	assert.NoError(t, err)
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	assert.Equal(t, "bad-fmt", repo.ObjectFormatName)
-	_, err = SyncRepoBranches(db.DefaultContext, 1, 0)
-	assert.NoError(t, err)
-	repo = unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	assert.Equal(t, "sha1", repo.ObjectFormatName)
-	branch, err := git_model.GetBranch(db.DefaultContext, 1, "master")
-	assert.NoError(t, err)
-	assert.EqualValues(t, "master", branch.Name)
-}

modules/repository/env.go

@@ -25,19 +25,11 @@ const (
 	EnvKeyID        = "GITEA_KEY_ID" // public key ID
 	EnvDeployKeyID  = "GITEA_DEPLOY_KEY_ID"
 	EnvPRID         = "GITEA_PR_ID"
-	EnvPushTrigger  = "GITEA_PUSH_TRIGGER"
 	EnvIsInternal   = "GITEA_INTERNAL_PUSH"
 	EnvAppURL       = "GITEA_ROOT_URL"
 	EnvActionPerm   = "GITEA_ACTION_PERM"
 )
 
-type PushTrigger string
-
-const (
-	PushTriggerPRMergeToBase    PushTrigger = "pr-merge-to-base"
-	PushTriggerPRUpdateWithBase PushTrigger = "pr-update-with-base"
-)
-
 // InternalPushingEnvironment returns an os environment to switch off hooks on push
 // It is recommended to avoid using this unless you are pushing within a transaction
 // or if you absolutely are sure that post-receive and pre-receive will do nothing

modules/setting/glob.go

@@ -1,32 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package setting
-
-import "github.com/gobwas/glob"
-
-type GlobMatcher struct {
-	compiledGlob  glob.Glob
-	patternString string
-}
-
-var _ glob.Glob = (*GlobMatcher)(nil)
-
-func (g *GlobMatcher) Match(s string) bool {
-	return g.compiledGlob.Match(s)
-}
-
-func (g *GlobMatcher) PatternString() string {
-	return g.patternString
-}
-
-func GlobMatcherCompile(pattern string, separators ...rune) (*GlobMatcher, error) {
-	g, err := glob.Compile(pattern, separators...)
-	if err != nil {
-		return nil, err
-	}
-	return &GlobMatcher{
-		compiledGlob:  g,
-		patternString: pattern,
-	}, nil
-}

modules/setting/indexer.go

@@ -10,6 +10,8 @@ import (
 	"time"
 
 	"code.gitea.io/gitea/modules/log"
+
+	"github.com/gobwas/glob"
 )
 
 // Indexer settings
@@ -28,8 +30,8 @@ var Indexer = struct {
 	RepoConnStr          string
 	RepoIndexerName      string
 	MaxIndexerFileSize   int64
-	IncludePatterns      []*GlobMatcher
-	ExcludePatterns      []*GlobMatcher
+	IncludePatterns      []glob.Glob
+	ExcludePatterns      []glob.Glob
 	ExcludeVendored      bool
 }{
 	IssueType:        "bleve",
@@ -91,12 +93,12 @@ func loadIndexerFrom(rootCfg ConfigProvider) {
 }
 
 // IndexerGlobFromString parses a comma separated list of patterns and returns a glob.Glob slice suited for repo indexing
-func IndexerGlobFromString(globstr string) []*GlobMatcher {
-	extarr := make([]*GlobMatcher, 0, 10)
+func IndexerGlobFromString(globstr string) []glob.Glob {
+	extarr := make([]glob.Glob, 0, 10)
 	for _, expr := range strings.Split(strings.ToLower(globstr), ",") {
 		expr = strings.TrimSpace(expr)
 		if expr != "" {
-			if g, err := GlobMatcherCompile(expr, '.', '/'); err != nil {
+			if g, err := glob.Compile(expr, '.', '/'); err != nil {
 				log.Info("Invalid glob expression '%s' (skipped): %v", expr, err)
 			} else {
 				extarr = append(extarr, g)

modules/setting/oauth2.go

@@ -126,15 +126,16 @@ func loadOAuth2From(rootCfg ConfigProvider) {
 		OAuth2.Enabled = sec.Key("ENABLE").MustBool(OAuth2.Enabled)
 	}
 
+	if !OAuth2.Enabled {
+		return
+	}
+
+	jwtSecretBase64 := loadSecret(sec, "JWT_SECRET_URI", "JWT_SECRET")
+
 	if !filepath.IsAbs(OAuth2.JWTSigningPrivateKeyFile) {
 		OAuth2.JWTSigningPrivateKeyFile = filepath.Join(AppDataPath, OAuth2.JWTSigningPrivateKeyFile)
 	}
 
-	// FIXME: at the moment, no matter oauth2 is enabled or not, it must generate a "oauth2 JWT_SECRET"
-	// Because this secret is also used as GeneralTokenSigningSecret (as a quick not-that-breaking fix for some legacy problems).
-	// Including: CSRF token, account validation token, etc ...
-	// In main branch, the signing token should be refactored (eg: one unique for LFS/OAuth2/etc ...)
-	jwtSecretBase64 := loadSecret(sec, "JWT_SECRET_URI", "JWT_SECRET")
 	if InstallLock {
 		jwtSecretBytes, err := generate.DecodeJwtSecretBase64(jwtSecretBase64)
 		if err != nil {
@@ -156,6 +157,8 @@ func loadOAuth2From(rootCfg ConfigProvider) {
 	}
 }
 
+// generalSigningSecret is used as container for a []byte value
+// instead of an additional mutex, we use CompareAndSwap func to change the value thread save
 var generalSigningSecret atomic.Pointer[[]byte]
 
 func GetGeneralTokenSigningSecret() []byte {
@@ -163,9 +166,11 @@ func GetGeneralTokenSigningSecret() []byte {
 	if old == nil || len(*old) == 0 {
 		jwtSecret, _, err := generate.NewJwtSecretWithBase64()
 		if err != nil {
-			log.Fatal("Unable to generate general JWT secret: %v", err)
+			log.Fatal("Unable to generate general JWT secret: %s", err.Error())
 		}
 		if generalSigningSecret.CompareAndSwap(old, &jwtSecret) {
+			// FIXME: in main branch, the signing token should be refactored (eg: one unique for LFS/OAuth2/etc ...)
+			LogStartupProblem(1, log.WARN, "OAuth2 is not enabled, unable to use a persistent signing secret, a new one is generated, which is not persistent between restarts and cluster nodes")
 			return jwtSecret
 		}
 		return *generalSigningSecret.Load()

modules/setting/oauth2_test.go

@@ -4,7 +4,6 @@
 package setting
 
 import (
-	"os"
 	"testing"
 
 	"code.gitea.io/gitea/modules/generate"
@@ -15,7 +14,7 @@ import (
 
 func TestGetGeneralSigningSecret(t *testing.T) {
 	// when there is no general signing secret, it should be generated, and keep the same value
-	generalSigningSecret.Store(nil)
+	assert.Nil(t, generalSigningSecret.Load())
 	s1 := GetGeneralTokenSigningSecret()
 	assert.NotNil(t, s1)
 	s2 := GetGeneralTokenSigningSecret()
@@ -34,31 +33,6 @@ JWT_SECRET = BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
 	assert.EqualValues(t, expected, actual)
 }
 
-func TestGetGeneralSigningSecretSave(t *testing.T) {
-	defer test.MockVariableValue(&InstallLock, true)()
-
-	old := GetGeneralTokenSigningSecret()
-	assert.Len(t, old, 32)
-
-	tmpFile := t.TempDir() + "/app.ini"
-	_ = os.WriteFile(tmpFile, nil, 0o644)
-	cfg, _ := NewConfigProviderFromFile(tmpFile)
-	loadOAuth2From(cfg)
-	generated := GetGeneralTokenSigningSecret()
-	assert.Len(t, generated, 32)
-	assert.NotEqual(t, old, generated)
-
-	generalSigningSecret.Store(nil)
-	cfg, _ = NewConfigProviderFromFile(tmpFile)
-	loadOAuth2From(cfg)
-	again := GetGeneralTokenSigningSecret()
-	assert.Equal(t, generated, again)
-
-	iniContent, err := os.ReadFile(tmpFile)
-	assert.NoError(t, err)
-	assert.Contains(t, string(iniContent), "JWT_SECRET = ")
-}
-
 func TestOauth2DefaultApplications(t *testing.T) {
 	cfg, _ := NewConfigProviderFromData(``)
 	loadOAuth2From(cfg)