feat: update gitea vendor

package/gitea/source/services/git/commit.go

@@ -6,25 +6,25 @@ package git
 import (
 	"context"
 
-	asymkey_model "code.gitea.io/gitea/models/asymkey"
-	"code.gitea.io/gitea/models/db"
-	git_model "code.gitea.io/gitea/models/git"
-	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/git"
-	asymkey_service "code.gitea.io/gitea/services/asymkey"
+	asymkey_model "gitea.dev/models/asymkey"
+	git_model "gitea.dev/models/git"
+	"gitea.dev/models/gituser"
+	repo_model "gitea.dev/models/repo"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/container"
+	"gitea.dev/modules/git"
+	asymkey_service "gitea.dev/services/asymkey"
 )
 
 // ParseCommitsWithSignature checks if signaute of commits are corresponding to users gpg keys.
-func ParseCommitsWithSignature(ctx context.Context, repo *repo_model.Repository, oldCommits []*user_model.UserCommit, repoTrustModel repo_model.TrustModelType) ([]*asymkey_model.SignCommit, error) {
+func ParseCommitsWithSignature(ctx context.Context, repo *repo_model.Repository, oldCommits []*gituser.UserCommit, repoTrustModel repo_model.TrustModelType) ([]*asymkey_model.SignCommit, error) {
 	newCommits := make([]*asymkey_model.SignCommit, 0, len(oldCommits))
 	keyMap := map[string]bool{}
 
 	emails := make(container.Set[string])
 	for _, c := range oldCommits {
-		if c.Committer != nil {
-			emails.Add(c.Committer.Email)
+		if c.GitCommit.Committer != nil {
+			emails.Add(c.GitCommit.Committer.Email)
 		}
 	}
 
@@ -34,10 +34,10 @@ func ParseCommitsWithSignature(ctx context.Context, repo *repo_model.Repository,
 	}
 
 	for _, c := range oldCommits {
-		committerUser := emailUsers.GetByEmail(c.Committer.Email) // FIXME: why ValidateCommitsWithEmails uses "Author", but ParseCommitsWithSignature uses "Committer"?
+		committerUser := emailUsers.GetByEmail(c.GitCommit.Committer.Email) // FIXME: why GetUserCommitsByGitCommits uses "Author", but ParseCommitsWithSignature uses "Committer"?
 		signCommit := &asymkey_model.SignCommit{
 			UserCommit:   c,
-			Verification: asymkey_service.ParseCommitWithSignatureCommitter(ctx, c.Commit, committerUser),
+			Verification: asymkey_service.ParseCommitWithSignatureCommitter(ctx, c.GitCommit, committerUser),
 		}
 
 		isOwnerMemberCollaborator := func(user *user_model.User) (bool, error) {
@@ -52,15 +52,15 @@ func ParseCommitsWithSignature(ctx context.Context, repo *repo_model.Repository,
 }
 
 // ConvertFromGitCommit converts git commits into SignCommitWithStatuses
-func ConvertFromGitCommit(ctx context.Context, commits []*git.Commit, repo *repo_model.Repository) ([]*git_model.SignCommitWithStatuses, error) {
-	validatedCommits, err := user_model.ValidateCommitsWithEmails(ctx, commits)
+func ConvertFromGitCommit(ctx context.Context, commits []*git.Commit, repo *repo_model.Repository, currentRef git.RefName) ([]*git_model.SignCommitWithStatuses, error) {
+	userCommits, err := gituser.GetUserCommitsByGitCommits(ctx, commits, repo.Link(), currentRef)
 	if err != nil {
 		return nil, err
 	}
 	signedCommits, err := ParseCommitsWithSignature(
 		ctx,
 		repo,
-		validatedCommits,
+		userCommits,
 		repo.GetTrustModel(),
 	)
 	if err != nil {
@@ -71,20 +71,27 @@ func ConvertFromGitCommit(ctx context.Context, commits []*git.Commit, repo *repo
 
 // ParseCommitsWithStatus checks commits latest statuses and calculates its worst status state
 func ParseCommitsWithStatus(ctx context.Context, oldCommits []*asymkey_model.SignCommit, repo *repo_model.Repository) ([]*git_model.SignCommitWithStatuses, error) {
-	newCommits := make([]*git_model.SignCommitWithStatuses, 0, len(oldCommits))
+	if len(oldCommits) == 0 {
+		return nil, nil
+	}
 
+	commitIDs := make([]string, 0, len(oldCommits))
 	for _, c := range oldCommits {
-		commit := &git_model.SignCommitWithStatuses{
-			SignCommit: c,
-		}
-		statuses, err := git_model.GetLatestCommitStatus(ctx, repo.ID, commit.ID.String(), db.ListOptionsAll)
-		if err != nil {
-			return nil, err
-		}
+		commitIDs = append(commitIDs, c.GitCommit.ID.String())
+	}
+	statusMap, err := git_model.GetLatestCommitStatusForRepoCommitIDs(ctx, repo.ID, commitIDs)
+	if err != nil {
+		return nil, err
+	}
 
-		commit.Statuses = statuses
-		commit.Status = git_model.CalcCommitStatus(statuses)
-		newCommits = append(newCommits, commit)
+	newCommits := make([]*git_model.SignCommitWithStatuses, 0, len(oldCommits))
+	for _, c := range oldCommits {
+		statuses := statusMap[c.GitCommit.ID.String()]
+		newCommits = append(newCommits, &git_model.SignCommitWithStatuses{
+			SignCommit: c,
+			Statuses:   statuses,
+			Status:     git_model.CalcCommitStatus(statuses),
+		})
 	}
 	return newCommits, nil
 }

package/gitea/source/services/git/compare.go

@@ -5,27 +5,34 @@ package git
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
-	repo_model "code.gitea.io/gitea/models/repo"
-	"code.gitea.io/gitea/modules/git"
-	"code.gitea.io/gitea/modules/gitrepo"
-	"code.gitea.io/gitea/modules/util"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/modules/git"
+	"gitea.dev/modules/gitrepo"
+	"gitea.dev/modules/util"
 )
 
 // CompareInfo represents needed information for comparing references.
 type CompareInfo struct {
-	BaseRepo         *repo_model.Repository
-	BaseRef          git.RefName
-	BaseCommitID     string
-	HeadRepo         *repo_model.Repository
-	HeadGitRepo      *git.Repository
-	HeadRef          git.RefName
-	HeadCommitID     string
+	BaseRepo     *repo_model.Repository
+	BaseRef      git.RefName
+	BaseCommitID string
+	HeadRepo     *repo_model.Repository
+	HeadGitRepo  *git.Repository
+	HeadRef      git.RefName
+	HeadCommitID string
+
 	CompareSeparator string
-	MergeBase        string
-	Commits          []*git.Commit
-	NumFiles         int
+
+	// CompareBase is the left-side commit ID used for comparing
+	// for "...": it is merge base (empty for no merge base)
+	// for direct comparison "..": it is base commit ID
+	CompareBase string
+
+	Commits  []*git.Commit
+	NumFiles int
 }
 
 func (ci *CompareInfo) IsSameRepository() bool {
@@ -43,23 +50,23 @@ func (ci *CompareInfo) DirectComparison() bool {
 }
 
 // GetCompareInfo generates and returns compare information between base and head branches of repositories.
-func GetCompareInfo(ctx context.Context, baseRepo, headRepo *repo_model.Repository, headGitRepo *git.Repository, baseRef, headRef git.RefName, directComparison, fileOnly bool) (_ *CompareInfo, err error) {
-	compareInfo := &CompareInfo{
+// It does its best to fill the fields as many as it can.
+// MergeBase can be empty if the base and head are unrelated.
+func GetCompareInfo(ctx context.Context, baseRepo, headRepo *repo_model.Repository, headGitRepo *git.Repository, baseRef, headRef git.RefName, directComparison, fileOnly bool) (compareInfo CompareInfo, err error) {
+	baseCommitID, err1 := gitrepo.GetFullCommitID(ctx, baseRepo, baseRef.String())
+	headCommitID, err2 := gitrepo.GetFullCommitID(ctx, headRepo, headRef.String())
+	compareInfo = CompareInfo{
 		BaseRepo:         baseRepo,
 		BaseRef:          baseRef,
+		BaseCommitID:     baseCommitID,
 		HeadRepo:         headRepo,
 		HeadGitRepo:      headGitRepo,
 		HeadRef:          headRef,
+		HeadCommitID:     headCommitID,
 		CompareSeparator: util.Iif(directComparison, "..", "..."),
 	}
-
-	compareInfo.BaseCommitID, err = gitrepo.GetFullCommitID(ctx, baseRepo, baseRef.String())
-	if err != nil {
-		return nil, err
-	}
-	compareInfo.HeadCommitID, err = gitrepo.GetFullCommitID(ctx, headRepo, headRef.String())
-	if err != nil {
-		return nil, err
+	if err1 != nil || err2 != nil {
+		return compareInfo, errors.Join(err1, err2)
 	}
 
 	// if they are not the same repository, then we need to fetch the base commit into the head repository
@@ -68,18 +75,22 @@ func GetCompareInfo(ctx context.Context, baseRepo, headRepo *repo_model.Reposito
 		exist := headGitRepo.IsReferenceExist(compareInfo.BaseCommitID)
 		if !exist {
 			if err := gitrepo.FetchRemoteCommit(ctx, headRepo, baseRepo, compareInfo.BaseCommitID); err != nil {
-				return nil, fmt.Errorf("FetchRemoteCommit: %w", err)
+				return compareInfo, fmt.Errorf("FetchRemoteCommit: %w", err)
 			}
 		}
 	}
 
 	if !directComparison {
-		compareInfo.MergeBase, err = gitrepo.MergeBase(ctx, headRepo, compareInfo.BaseCommitID, compareInfo.HeadCommitID)
-		if err != nil {
+		compareInfo.CompareBase, err = gitrepo.MergeBase(ctx, headRepo, compareInfo.BaseCommitID, compareInfo.HeadCommitID)
+		if err != nil && !errors.Is(err, util.ErrNotExist) {
 			return compareInfo, fmt.Errorf("MergeBase: %w", err)
 		}
 	} else {
-		compareInfo.MergeBase = compareInfo.BaseCommitID
+		compareInfo.CompareBase = compareInfo.BaseCommitID
+	}
+
+	if compareInfo.CompareBase == "" {
+		return compareInfo, nil
 	}
 
 	// We have a common base - therefore we know that ... should work
@@ -88,20 +99,15 @@ func GetCompareInfo(ctx context.Context, baseRepo, headRepo *repo_model.Reposito
 		// which is different from the meaning of "..." in git diff (where it implies diffing from the merge base).
 		// For listing PR commits, we must use merge-base..head to include only the commits introduced by the head branch.
 		// Otherwise, commits newly pushed to the base branch would also be included, which is incorrect.
-		compareInfo.Commits, err = headGitRepo.ShowPrettyFormatLogToList(ctx, compareInfo.MergeBase+".."+compareInfo.HeadCommitID)
+		compareInfo.Commits, err = headGitRepo.ShowPrettyFormatLogToList(ctx, compareInfo.CompareBase+".."+compareInfo.HeadCommitID)
 		if err != nil {
-			return nil, fmt.Errorf("ShowPrettyFormatLogToList: %w", err)
+			return compareInfo, fmt.Errorf("ShowPrettyFormatLogToList: %w", err)
 		}
-	} else {
-		compareInfo.Commits = []*git.Commit{}
 	}
 
 	// Count number of changed files.
-	// This probably should be removed as we need to use shortstat elsewhere
+	// TODO: This probably should be removed as we need to use shortstat elsewhere
 	// Now there is git diff --shortstat but this appears to be slower than simply iterating with --nameonly
 	compareInfo.NumFiles, err = headGitRepo.GetDiffNumChangedFiles(compareInfo.BaseCommitID, compareInfo.HeadCommitID, directComparison)
-	if err != nil {
-		return nil, err
-	}
-	return compareInfo, nil
+	return compareInfo, err
 }