enhance!: raise minimum git version to 2.34 (#39565)

Raise the minimum git version to 2.34, the version in Ubuntu 22.04,
Debian 12 and RHEL 8 ship newer, and remove the fallbacks it makes
obsolete.

- Always enable AGit
- Use `diff --skip-to` and `apply -3` unconditionally
- Set the default branch of new repos and wikis via `git init
--initial-branch`
- Detect rebase conflicts via `REBASE_HEAD`

services/gitdiff/csv_test.go

@@ -190,7 +190,7 @@ c,d,e`,
 	}
 
 	for n, c := range cases {
-		diff, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(c.diff), "")
+		diff, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(c.diff))
 		assert.NoError(t, err)
 
 		var baseReader *csv.Reader

services/gitdiff/gitdiff.go

@@ -702,8 +702,8 @@ const cmdDiffHead = "diff --git "
 var defaultDiffLineBufferSize = 8 * 1024
 
 // ParsePatch builds a Diff object by parsing git diff output
-func ParsePatch(ctx context.Context, maxLines, maxLineCharacters, maxFiles int, reader io.Reader, skipToFile string) (_ *Diff, retErr error) {
-	log.Debug("ParsePatch(%d, %d, %d, ..., %s)", maxLines, maxLineCharacters, maxFiles, skipToFile)
+func ParsePatch(ctx context.Context, maxLines, maxLineCharacters, maxFiles int, reader io.Reader) (_ *Diff, retErr error) {
+	log.Debug("ParsePatch(%d, %d, %d, ...)", maxLines, maxLineCharacters, maxFiles)
 
 	diff := &Diff{Files: make([]*DiffFile, 0)}
 	readerSize := max(maxLineCharacters, defaultDiffLineBufferSize)
@@ -714,9 +714,8 @@ func ParsePatch(ctx context.Context, maxLines, maxLineCharacters, maxFiles int,
 		return diff, util.Iif(err == io.EOF, nil, err)
 	}
 
-	skipping := skipToFile != ""
 	for {
-		nextLine, err := diff.parseOneDiffFile(ctx, maxLines, maxLineCharacters, maxFiles, &skipping, input, skipToFile, line)
+		nextLine, err := diff.parseOneDiffFile(ctx, maxLines, maxLineCharacters, maxFiles, input, line)
 		if nextLine == "" || err == io.EOF {
 			break
 		} else if err != nil {
@@ -729,7 +728,7 @@ func ParsePatch(ctx context.Context, maxLines, maxLineCharacters, maxFiles int,
 	return diff, nil
 }
 
-func (diff *Diff) parseOneDiffFile(ctx context.Context, maxLines, maxLineCharacters, maxFiles int, skipping *bool, input *bufio.Reader, skipToFile, startLine string) (nextLine string, err error) {
+func (diff *Diff) parseOneDiffFile(ctx context.Context, maxLines, maxLineCharacters, maxFiles int, input *bufio.Reader, startLine string) (nextLine string, err error) {
 	line := startLine
 
 	extractGitDiffHead := func(s, p string) string {
@@ -751,13 +750,6 @@ func (diff *Diff) parseOneDiffFile(ctx context.Context, maxLines, maxLineCharact
 		}
 
 		curFile := createDiffFile(line)
-		if *skipping {
-			if curFile.Name != skipToFile {
-				return skipToNextDiffHead(input)
-			}
-			*skipping = false
-		}
-
 		diff.Files = append(diff.Files, curFile)
 
 		// 2. It is followed by one or more extended header lines:
@@ -962,18 +954,6 @@ func (diff *Diff) postProcessFiles() {
 	}
 }
 
-func skipToNextDiffHead(input *bufio.Reader) (line string, err error) {
-	for {
-		lineBytes, _, err := readGitDiffLineWithDiscard(input)
-		if err != nil {
-			return "", err
-		}
-		if bytes.HasPrefix(lineBytes, []byte(cmdDiffHead)) {
-			return string(lineBytes), nil
-		}
-	}
-}
-
 func newDiffSectionForDiffFile(curFile *DiffFile) *DiffSection {
 	return &DiffSection{
 		language:              &curFile.language,
@@ -1347,13 +1327,8 @@ func getDiffBasic(ctx context.Context, gitRepo *git.Repository, opts *DiffOption
 		AddArguments(opts.WhitespaceBehavior...).
 		AddOptionFormat("--find-renames=%s", setting.Git.DiffRenameSimilarityThreshold)
 
-	// In git 2.31, git diff learned --skip-to which we can use to shortcut skip to file
-	// so if we are using at least this version of git we don't have to tell ParsePatch to do
-	// the skipping for us
-	parsePatchSkipToFile := opts.SkipTo
-	if opts.SkipTo != "" && git.DefaultFeatures().CheckVersionAtLeast("2.31") {
+	if opts.SkipTo != "" {
 		cmdDiff.AddOptionFormat("--skip-to=%s", opts.SkipTo)
-		parsePatchSkipToFile = ""
 	}
 
 	cmdDiff.AddDynamicArguments(beforeCommitID.String(), opts.AfterCommitID)
@@ -1372,7 +1347,7 @@ func getDiffBasic(ctx context.Context, gitRepo *git.Repository, opts *DiffOption
 		}
 	}()
 
-	diff, err := ParsePatch(cmdCtx, opts.MaxLines, opts.MaxLineCharacters, opts.MaxFiles, reader, parsePatchSkipToFile)
+	diff, err := ParsePatch(cmdCtx, opts.MaxLines, opts.MaxLineCharacters, opts.MaxFiles, reader)
 	// Ensure the git process is killed if it didn't exit already
 	cmdCancel()
 	if err != nil {
@@ -1605,7 +1580,7 @@ func SyncUserSpecificDiff(ctx context.Context, userID int64, pull *issues_model.
 // CommentAsDiff returns c.Patch as *Diff
 func CommentAsDiff(ctx context.Context, c *issues_model.Comment) (*Diff, error) {
 	diff, err := ParsePatch(ctx, setting.Git.MaxGitDiffLines,
-		setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(c.Patch), "")
+		setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(c.Patch))
 	if err != nil {
 		log.Error("Unable to parse patch: %v", err)
 		return nil, err

services/gitdiff/gitdiff_render_test.go

@@ -17,7 +17,7 @@ import (
 
 func TestGetDiffForRender(t *testing.T) {
 	repoDir := filepath.Join(t.TempDir(), "temp-repo")
-	require.NoError(t, git.InitRepositoryLocal(t.Context(), repoDir, false, git.Sha1ObjectFormat.Name()))
+	require.NoError(t, git.InitRepositoryLocal(t.Context(), repoDir, false, git.Sha1ObjectFormat.Name(), ""))
 
 	contentLeft := strings.Repeat("a\n", 20) +
 		"mark1\n" +

services/gitdiff/gitdiff_test.go

@@ -24,169 +24,25 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestParsePatch_skipTo(t *testing.T) {
-	type testcase struct {
-		name        string
-		gitdiff     string
-		wantErr     bool
-		addition    int
-		deletion    int
-		oldFilename string
-		filename    string
-		skipTo      string
-	}
-	tests := []testcase{
-		{
-			name: "readme.md2readme.md",
-			gitdiff: `diff --git "a/A \\ B" "b/A \\ B"
---- "a/A \\ B"
-+++ "b/A \\ B"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off
-diff --git "\\a/README.md" "\\b/README.md"
---- "\\a/README.md"
-+++ "\\b/README.md"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off
-`,
-			addition:    4,
-			deletion:    1,
-			filename:    "README.md",
-			oldFilename: "README.md",
-			skipTo:      "README.md",
-		},
-		{
-			name: "A \\ B",
-			gitdiff: `diff --git "a/A \\ B" "b/A \\ B"
---- "a/A \\ B"
-+++ "b/A \\ B"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off`,
-			addition:    4,
-			deletion:    1,
-			filename:    "A \\ B",
-			oldFilename: "A \\ B",
-			skipTo:      "A \\ B",
-		},
-		{
-			name: "A \\ B",
-			gitdiff: `diff --git "\\a/README.md" "\\b/README.md"
---- "\\a/README.md"
-+++ "\\b/README.md"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off
-diff --git "a/A \\ B" "b/A \\ B"
---- "a/A \\ B"
-+++ "b/A \\ B"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off`,
-			addition:    4,
-			deletion:    1,
-			filename:    "A \\ B",
-			oldFilename: "A \\ B",
-			skipTo:      "A \\ B",
-		},
-		{
-			name: "readme.md2readme.md",
-			gitdiff: `diff --git "a/A \\ B" "b/A \\ B"
---- "a/A \\ B"
-+++ "b/A \\ B"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off
-diff --git "a/A \\ B" "b/A \\ B"
---- "a/A \\ B"
-+++ "b/A \\ B"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off
-diff --git "\\a/README.md" "\\b/README.md"
---- "\\a/README.md"
-+++ "\\b/README.md"
-@@ -1,3 +1,6 @@
- # gitea-github-migrator
-+
-+ Build Status
-- Latest Release
- Docker Pulls
-+ cut off
-+ cut off
-`,
-			addition:    4,
-			deletion:    1,
-			filename:    "README.md",
-			oldFilename: "README.md",
-			skipTo:      "README.md",
-		},
-	}
-	for _, testcase := range tests {
-		t.Run(testcase.name, func(t *testing.T) {
-			got, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff), testcase.skipTo)
-			if (err != nil) != testcase.wantErr {
-				t.Errorf("ParsePatch(%q) error = %v, wantErr %v", testcase.name, err, testcase.wantErr)
-				return
-			}
+func TestGetDiffSkipTo(t *testing.T) {
+	repo, err := git.ForceFastImportWithInit(t.Context(), t.TempDir(), []git.FastImportCommit{{Ref: "refs/heads/main", Files: []git.FastImportFile{
+		{Path: "a.txt", Content: "a\n"}, {Path: "b.txt", Content: "b\n"}, {Path: "c.txt", Content: "c\n"},
+	}}})
+	require.NoError(t, err)
+	gitRepo, err := git.OpenRepository(t.Context(), repo)
+	require.NoError(t, err)
+	defer gitRepo.Close()
 
-			gotMarshaled, _ := json.MarshalIndent(got, "", "  ")
-			if len(got.Files) != 1 {
-				t.Errorf("ParsePath(%q) did not receive 1 file:\n%s", testcase.name, string(gotMarshaled))
-				return
-			}
-			file := got.Files[0]
-			if file.Addition != testcase.addition {
-				t.Errorf("ParsePath(%q) does not have correct file addition %d, wanted %d", testcase.name, file.Addition, testcase.addition)
-			}
-			if file.Deletion != testcase.deletion {
-				t.Errorf("ParsePath(%q) did not have correct file deletion %d, wanted %d", testcase.name, file.Deletion, testcase.deletion)
-			}
-			if file.OldName != testcase.oldFilename {
-				t.Errorf("ParsePath(%q) did not have correct OldName %q, wanted %q", testcase.name, file.OldName, testcase.oldFilename)
-			}
-			if file.Name != testcase.filename {
-				t.Errorf("ParsePath(%q) did not have correct Name %q, wanted %q", testcase.name, file.Name, testcase.filename)
-			}
-		})
-	}
+	diff, err := GetDiffForAPI(t.Context(), gitRepo, &DiffOptions{
+		AfterCommitID:     "main",
+		SkipTo:            "b.txt",
+		MaxLines:          setting.Git.MaxGitDiffLines,
+		MaxLineCharacters: setting.Git.MaxGitDiffLineCharacters,
+		MaxFiles:          setting.Git.MaxGitDiffFiles,
+	})
+	require.NoError(t, err)
+	require.Len(t, diff.Files, 2)
+	assert.Equal(t, "b.txt", diff.Files[0].Name)
 }
 
 func TestParsePatch_singlefile(t *testing.T) {
@@ -370,7 +226,7 @@ index 6961180..9ba1a00 100644
 
 	for _, testcase := range tests {
 		t.Run(testcase.name, func(t *testing.T) {
-			got, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff), "")
+			got, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff))
 			if (err != nil) != testcase.wantErr {
 				t.Errorf("ParsePatch(%q) error = %v, wantErr %v", testcase.name, err, testcase.wantErr)
 				return
@@ -413,21 +269,21 @@ index 0000000..6bb8f39
 		diffBuilder.WriteString("+line" + strconv.Itoa(i) + "\n")
 	}
 	diff = diffBuilder.String()
-	result, err := ParsePatch(t.Context(), 20, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff), "")
+	result, err := ParsePatch(t.Context(), 20, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff))
 	if err != nil {
 		t.Errorf("There should not be an error: %v", err)
 	}
 	if !result.Files[0].IsIncomplete {
 		t.Errorf("Files should be incomplete! %v", result.Files[0])
 	}
-	result, err = ParsePatch(t.Context(), 40, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff), "")
+	result, err = ParsePatch(t.Context(), 40, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff))
 	if err != nil {
 		t.Errorf("There should not be an error: %v", err)
 	}
 	if result.Files[0].IsIncomplete {
 		t.Errorf("Files should not be incomplete! %v", result.Files[0])
 	}
-	result, err = ParsePatch(t.Context(), 40, 5, setting.Git.MaxGitDiffFiles, strings.NewReader(diff), "")
+	result, err = ParsePatch(t.Context(), 40, 5, setting.Git.MaxGitDiffFiles, strings.NewReader(diff))
 	if err != nil {
 		t.Errorf("There should not be an error: %v", err)
 	}
@@ -458,14 +314,14 @@ index 0000000..6bb8f39
 	diffBuilder.WriteString("+line" + strconv.Itoa(35) + "\n")
 	diff = diffBuilder.String()
 
-	result, err = ParsePatch(t.Context(), 20, 4096, setting.Git.MaxGitDiffFiles, strings.NewReader(diff), "")
+	result, err = ParsePatch(t.Context(), 20, 4096, setting.Git.MaxGitDiffFiles, strings.NewReader(diff))
 	if err != nil {
 		t.Errorf("There should not be an error: %v", err)
 	}
 	if !result.Files[0].IsIncomplete {
 		t.Errorf("Files should be incomplete! %v", result.Files[0])
 	}
-	result, err = ParsePatch(t.Context(), 40, 4096, setting.Git.MaxGitDiffFiles, strings.NewReader(diff), "")
+	result, err = ParsePatch(t.Context(), 40, 4096, setting.Git.MaxGitDiffFiles, strings.NewReader(diff))
 	if err != nil {
 		t.Errorf("There should not be an error: %v", err)
 	}
@@ -484,7 +340,7 @@ index 0000000..6bb8f39
  Docker Pulls
 + cut off
 + cut off`
-	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff), "")
+	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff))
 	if err != nil {
 		t.Errorf("ParsePatch failed: %s", err)
 	}
@@ -500,7 +356,7 @@ index 0000000..6bb8f39
  Docker Pulls
 + cut off
 + cut off`
-	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff2), "")
+	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff2))
 	if err != nil {
 		t.Errorf("ParsePatch failed: %s", err)
 	}
@@ -516,7 +372,7 @@ index 0000000..6bb8f39
  Docker Pulls
 + cut off
 + cut off`
-	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff2a), "")
+	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff2a))
 	if err != nil {
 		t.Errorf("ParsePatch failed: %s", err)
 	}
@@ -532,7 +388,7 @@ index 0000000..6bb8f39
  Docker Pulls
 + cut off
 + cut off`
-	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff3), "")
+	_, err = ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(diff3))
 	if err != nil {
 		t.Errorf("ParsePatch failed: %s", err)
 	}
@@ -571,8 +427,8 @@ func TestParsePatchLongLines(t *testing.T) {
 					" final",
 					"",
 				}, eol)
-				maxLines, maxFiles, skipToFile := 20, 10, ""
-				diff, err := ParsePatch(t.Context(), maxLines, test.limit, maxFiles, strings.NewReader(patch), skipToFile)
+				maxLines, maxFiles := 20, 10
+				diff, err := ParsePatch(t.Context(), maxLines, test.limit, maxFiles, strings.NewReader(patch))
 				require.NoError(t, err)
 				require.Len(t, diff.Files, 2)
 				file := diff.Files[0]
@@ -615,7 +471,7 @@ func TestParsePatchExactLineLimit(t *testing.T) {
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			patch := "diff --git a/file b/file\n--- a/file\n+++ b/file\n" + test.hunk
-			diff, err := ParsePatch(t.Context(), test.limit, 5000, 10, strings.NewReader(patch), "")
+			diff, err := ParsePatch(t.Context(), test.limit, 5000, 10, strings.NewReader(patch))
 			require.NoError(t, err)
 			require.Len(t, diff.Files, 1)
 			diffFile := diff.Files[0]
@@ -732,7 +588,7 @@ func TestNoCrashes(t *testing.T) {
 	}
 	for _, testcase := range tests {
 		// It shouldn't crash, so don't care about the output.
-		ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff), "")
+		ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff))
 	}
 }
 

services/gitdiff/submodule_test.go

@@ -203,7 +203,7 @@ index 0000000..68972a9
 
 	for _, testcase := range tests {
 		t.Run(testcase.name, func(t *testing.T) {
-			diff, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff), "")
+			diff, err := ParsePatch(t.Context(), setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(testcase.gitdiff))
 			assert.NoError(t, err)
 
 			for i, expected := range testcase.infos {

services/pull/merge_prepare.go

@@ -267,29 +267,8 @@ func rebaseTrackingOnToBase(ctx *mergeContext, mergeStyle repo_model.MergeStyle)
 	if err := ctx.PrepareGitCmd(cmdRebase).
 		RunWithStderr(ctx); err != nil {
 		// Rebase will leave a REBASE_HEAD file in .git if there is a conflict
-		if _, statErr := os.Stat(filepath.Join(ctx.tmpBasePath, ".git", "REBASE_HEAD")); statErr == nil {
-			var commitSha string
-			ok := false
-			failingCommitPaths := []string{
-				filepath.Join(ctx.tmpBasePath, ".git", "rebase-apply", "original-commit"), // Git < 2.26
-				filepath.Join(ctx.tmpBasePath, ".git", "rebase-merge", "stopped-sha"),     // Git >= 2.26
-			}
-			for _, failingCommitPath := range failingCommitPaths {
-				if _, statErr := os.Stat(failingCommitPath); statErr == nil {
-					commitShaBytes, readErr := os.ReadFile(failingCommitPath)
-					if readErr != nil {
-						// Abandon this attempt to handle the error
-						return fmt.Errorf("unable to git rebase staging on to base in temp repo for %v: %w\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), err.Stderr())
-					}
-					commitSha = strings.TrimSpace(string(commitShaBytes))
-					ok = true
-					break
-				}
-			}
-			if !ok {
-				log.Error("Unable to determine failing commit sha for failing rebase in temp repo for %-v. Cannot cast as ErrRebaseConflicts.", ctx.pr)
-				return fmt.Errorf("unable to git rebase staging on to base in temp repo for %v: %w\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), err.Stderr())
-			}
+		if rebaseHead, readErr := os.ReadFile(filepath.Join(ctx.tmpBasePath, ".git", "REBASE_HEAD")); readErr == nil {
+			commitSha := strings.TrimSpace(string(rebaseHead))
 			log.Debug("Conflict when rebasing staging on to base in %-v at %s: %v\n%s\n%s", ctx.pr, commitSha, err, ctx.outbuf.String(), err.Stderr())
 			return ErrRebaseConflicts{
 				CommitSHA: commitSha,

services/pull/temp_repo.go

@@ -84,7 +84,7 @@ func createTemporaryRepoForPR(ctx context.Context, pr *issues_model.PullRequest)
 	baseRepoPath := gitrepo.RepoLocalPath(pr.BaseRepo.CodeStorageRepo())
 	headRepoPath := gitrepo.RepoLocalPath(pr.HeadRepo.CodeStorageRepo())
 
-	if err := git.InitRepositoryLocal(ctx, tmpBasePath, false, pr.BaseRepo.ObjectFormatName); err != nil {
+	if err := git.InitRepositoryLocal(ctx, tmpBasePath, false, pr.BaseRepo.ObjectFormatName, ""); err != nil {
 		return nil, nil, fmt.Errorf("InitRepository[PR:%d]: %w", pr.ID, err)
 	}
 

services/repository/check.go

@@ -189,7 +189,7 @@ func ReinitMissingRepositories(ctx context.Context) error {
 		default:
 		}
 		log.Trace("Initializing %d/%d...", repo.OwnerID, repo.ID)
-		if err := git.InitRepository(ctx, repo, repo.ObjectFormatName); err != nil {
+		if err := git.InitRepository(ctx, repo, repo.ObjectFormatName, repo.DefaultBranch); err != nil {
 			log.Error("Unable (re)initialize repository %d at %s. Error: %v", repo.ID, repo.FullName(), err)
 			if err2 := system_model.CreateRepositoryNotice("InitRepository (%s) [%d]: %v", repo.FullName(), repo.ID, err); err2 != nil {
 				log.Error("CreateRepositoryNotice: %v", err2)

services/repository/create.go

@@ -144,15 +144,16 @@ func prepareRepoCommit(ctx context.Context, repo *repo_model.Repository, tmpDir
 
 // InitRepository initializes README and .gitignore if needed.
 func initRepository(ctx context.Context, u *user_model.User, repo *repo_model.Repository, opts CreateRepoOptions) (err error) {
+	repo.DefaultBranch = util.IfZero(opts.DefaultBranch, setting.Repository.DefaultBranch)
+	repo.DefaultWikiBranch = setting.Repository.DefaultBranch
+
 	// Init git bare new repository.
-	if err = git.InitRepository(ctx, repo, repo.ObjectFormatName); err != nil {
+	if err = git.InitRepository(ctx, repo, repo.ObjectFormatName, repo.DefaultBranch); err != nil {
 		return fmt.Errorf("git.InitRepository: %w", err)
 	} else if err = git.CreateDelegateHooks(ctx, repo); err != nil {
 		return fmt.Errorf("createDelegateHooks: %w", err)
 	}
 
-	repo.DefaultBranch = util.IfZero(opts.DefaultBranch, setting.Repository.DefaultBranch)
-	repo.DefaultWikiBranch = setting.Repository.DefaultBranch
 	if !opts.AutoInit {
 		repo.IsEmpty = true
 	}
@@ -179,10 +180,6 @@ func initRepository(ctx context.Context, u *user_model.User, repo *repo_model.Re
 		}
 	}
 
-	if err = git.SetDefaultBranch(ctx, repo, repo.DefaultBranch); err != nil {
-		return fmt.Errorf("setDefaultBranch: %w", err)
-	}
-
 	// Re-fetch the repository from database before updating it (keep changes that were done earlier with SQL)
 	if repo, err = repo_model.GetRepositoryByID(ctx, repo.ID); err != nil {
 		return fmt.Errorf("getRepositoryByID: %w", err)

services/repository/create_test.go

@@ -24,7 +24,8 @@ func TestCreateRepositoryDirectly(t *testing.T) {
 	testRepoName := "created-repo"
 	t.Run("Success", func(t *testing.T) {
 		createdRepo, err := CreateRepositoryDirectly(t.Context(), user2, user2, CreateRepoOptions{
-			Name: testRepoName,
+			Name:          testRepoName,
+			DefaultBranch: "custom-default",
 		}, true)
 		assert.NoError(t, err)
 		assert.NotNil(t, createdRepo)
@@ -33,6 +34,10 @@ func TestCreateRepositoryDirectly(t *testing.T) {
 		assert.NoError(t, err)
 		assert.True(t, exist)
 
+		branch, err := git.GetDefaultBranch(t.Context(), createdRepo)
+		assert.NoError(t, err)
+		assert.Equal(t, "custom-default", branch)
+
 		unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: user2.Name, Name: createdRepo.Name})
 
 		err = DeleteRepositoryDirectly(t.Context(), createdRepo.ID)

services/repository/files/patch.go

@@ -178,12 +178,8 @@ func ApplyDiffPatch(ctx reqctx.RequestContext, repo *repo_model.Repository, doer
 	}
 	defer t.Close()
 
-	cmdApply := gitcmd.NewCommand("apply", "--index", "--recount", "--cached", "--ignore-whitespace", "--whitespace=fix", "--binary")
-	if git.DefaultFeatures().CheckVersionAtLeast("2.32") {
-		cmdApply.AddArguments("-3")
-	}
-
-	if err := cmdApply.WithRepo(t.gitRepo).
+	if err := gitcmd.NewCommand("apply", "--index", "--recount", "--cached", "--ignore-whitespace", "--whitespace=fix", "--binary", "-3").
+		WithRepo(t.gitRepo).
 		WithStdinBytes([]byte(opts.Content)).
 		RunWithStderr(ctx); err != nil {
 		return nil, fmt.Errorf("git apply error: %w", err)

services/repository/files/temp_repo.go

@@ -86,7 +86,7 @@ func (t *TemporaryUploadRepository) Clone(ctx context.Context, branch string, ba
 
 // Init the repository
 func (t *TemporaryUploadRepository) Init(ctx context.Context, objectFormatName string) error {
-	if err := git.InitRepositoryLocal(ctx, t.basePath, false, objectFormatName); err != nil {
+	if err := git.InitRepositoryLocal(ctx, t.basePath, false, objectFormatName, ""); err != nil {
 		return err
 	}
 	gitRepo, err := git.OpenRepositoryLocal(ctx, t.basePath)
@@ -363,7 +363,7 @@ func (t *TemporaryUploadRepository) DiffIndex(ctx context.Context, oldContent, n
 		WithRepo(t.gitRepo).
 		WithPipelineFunc(func(ctx gitcmd.Context) error {
 			var diffErr error
-			diff, diffErr = gitdiff.ParsePatch(ctx, setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, stdoutReader, "")
+			diff, diffErr = gitdiff.ParsePatch(ctx, setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, stdoutReader)
 			if diffErr != nil {
 				// if the diffErr is not nil, it will be returned as the error of "Run()"
 				return fmt.Errorf("ParsePatch: %w", diffErr)

services/repository/generate.go

@@ -263,7 +263,7 @@ func generateRepoCommit(ctx context.Context, repo, templateRepo, generateRepo *r
 		return fmt.Errorf("readGiteaTemplateFile: %w", err)
 	}
 
-	if err = git.InitRepositoryLocal(ctx, tmpDir, false, templateRepo.ObjectFormatName); err != nil {
+	if err = git.InitRepositoryLocal(ctx, tmpDir, false, templateRepo.ObjectFormatName, ""); err != nil {
 		return err
 	}
 

services/repository/license_test.go

@@ -102,7 +102,7 @@ func Test_resolveLicenses(t *testing.T) {
 	require.NoError(t, err)
 
 	repoDir := filepath.Join(t.TempDir(), "repo.git")
-	require.NoError(t, git.InitRepositoryLocal(t.Context(), repoDir, true, "sha1"))
+	require.NoError(t, git.InitRepositoryLocal(t.Context(), repoDir, true, "sha1", ""))
 	gitRepo, err := git.OpenRepositoryLocal(t.Context(), repoDir)
 	require.NoError(t, err)
 	defer gitRepo.Close()

services/repository/template.go

@@ -122,7 +122,7 @@ func GenerateRepository(ctx context.Context, doer, owner *user_model.User, templ
 	}
 
 	// 3 -Init git bare new repository.
-	if err = git.InitRepository(ctx, generateRepo, generateRepo.ObjectFormatName); err != nil {
+	if err = git.InitRepository(ctx, generateRepo, generateRepo.ObjectFormatName, ""); err != nil {
 		return nil, fmt.Errorf("git.InitRepository: %w", err)
 	} else if err = git.CreateDelegateHooks(ctx, generateRepo); err != nil {
 		return nil, fmt.Errorf("createDelegateHooks: %w", err)

services/wiki/wiki.go

@@ -41,12 +41,10 @@ func InitWiki(ctx context.Context, repo *repo_model.Repository) error {
 	}
 
 	// wiki's object format should be the same as repository's
-	if err := git.InitRepository(ctx, repo.WikiStorageRepo(), repo.ObjectFormatName); err != nil {
+	if err := git.InitRepository(ctx, repo.WikiStorageRepo(), repo.ObjectFormatName, repo.DefaultWikiBranch); err != nil {
 		return fmt.Errorf("InitRepository: %w", err)
 	} else if err = git.CreateDelegateHooks(ctx, repo.WikiStorageRepo()); err != nil {
 		return fmt.Errorf("createDelegateHooks: %w", err)
-	} else if err = git.SetDefaultBranch(ctx, repo.WikiStorageRepo(), repo.DefaultWikiBranch); err != nil {
-		return fmt.Errorf("unable to set default wiki branch to %q: %w", repo.DefaultWikiBranch, err)
 	}
 	return nil
 }

services/wiki/wiki_test.go

@@ -148,8 +148,12 @@ func TestRepository_InitWiki(t *testing.T) {
 
 	// repo2 does not already have a wiki
 	repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
+	repo2.DefaultWikiBranch = "wiki-main"
 	assert.NoError(t, InitWiki(t.Context(), repo2))
 	assert.True(t, repo_service.HasWiki(t.Context(), repo2))
+	branch, err := git.GetDefaultBranch(t.Context(), repo2.WikiStorageRepo())
+	assert.NoError(t, err)
+	assert.Equal(t, "wiki-main", branch)
 }
 
 func TestRepository_AddWikiPage(t *testing.T) {
@@ -301,7 +305,7 @@ func TestPrepareWikiFileName_FirstPage(t *testing.T) {
 	// Now create a temporaryDirectory
 	tmpDir := t.TempDir()
 
-	err := git.InitRepositoryLocal(t.Context(), tmpDir, true, git.Sha1ObjectFormat.Name())
+	err := git.InitRepositoryLocal(t.Context(), tmpDir, true, git.Sha1ObjectFormat.Name(), "")
 	assert.NoError(t, err)
 
 	gitRepo, err := git.OpenRepositoryLocal(t.Context(), tmpDir)