初始提交: Gitea 项目代码

2026-05-30 22:47:36 +08:00
commit f288f76350
6116 changed files with 776822 additions and 0 deletions
@@ -0,0 +1,90 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+
+	asymkey_model "gitea.dev/models/asymkey"
+	"gitea.dev/models/db"
+	git_model "gitea.dev/models/git"
+	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) {
+	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)
+		}
+	}
+
+	emailUsers, err := user_model.GetUsersByEmails(ctx, emails.Values())
+	if err != nil {
+		return nil, err
+	}
+
+	for _, c := range oldCommits {
+		committerUser := emailUsers.GetByEmail(c.Committer.Email) // FIXME: why ValidateCommitsWithEmails uses "Author", but ParseCommitsWithSignature uses "Committer"?
+		signCommit := &asymkey_model.SignCommit{
+			UserCommit:   c,
+			Verification: asymkey_service.ParseCommitWithSignatureCommitter(ctx, c.Commit, committerUser),
+		}
+
+		isOwnerMemberCollaborator := func(user *user_model.User) (bool, error) {
+			return repo_model.IsOwnerMemberCollaborator(ctx, repo, user.ID)
+		}
+
+		_ = asymkey_model.CalculateTrustStatus(signCommit.Verification, repoTrustModel, isOwnerMemberCollaborator, &keyMap)
+
+		newCommits = append(newCommits, signCommit)
+	}
+	return newCommits, nil
+}
+
+// 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)
+	if err != nil {
+		return nil, err
+	}
+	signedCommits, err := ParseCommitsWithSignature(
+		ctx,
+		repo,
+		validatedCommits,
+		repo.GetTrustModel(),
+	)
+	if err != nil {
+		return nil, err
+	}
+	return ParseCommitsWithStatus(ctx, signedCommits, 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))
+
+	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
+		}
+
+		commit.Statuses = statuses
+		commit.Status = git_model.CalcCommitStatus(statuses)
+		newCommits = append(newCommits, commit)
+	}
+	return newCommits, nil
+}
@@ -0,0 +1,113 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	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
+
+	CompareSeparator string
+
+	// 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 {
+	return ci.BaseRepo.ID == ci.HeadRepo.ID
+}
+
+func (ci *CompareInfo) IsSameRef() bool {
+	return ci.IsSameRepository() && ci.BaseRef == ci.HeadRef
+}
+
+func (ci *CompareInfo) DirectComparison() bool {
+	// FIXME: the design of "DirectComparison" is wrong, it loses the information of `^`
+	// To correctly handle the comparison, developers should use `ci.CompareSeparator` directly, all "DirectComparison" related code should be rewritten.
+	return ci.CompareSeparator == ".."
+}
+
+// GetCompareInfo generates and returns compare information between base and head branches of repositories.
+// 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, "..", "..."),
+	}
+	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
+	// because we will use headGitRepo in the following code
+	if baseRepo.ID != headRepo.ID {
+		exist := headGitRepo.IsReferenceExist(compareInfo.BaseCommitID)
+		if !exist {
+			if err := gitrepo.FetchRemoteCommit(ctx, headRepo, baseRepo, compareInfo.BaseCommitID); err != nil {
+				return compareInfo, fmt.Errorf("FetchRemoteCommit: %w", err)
+			}
+		}
+	}
+
+	if !directComparison {
+		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.CompareBase = compareInfo.BaseCommitID
+	}
+
+	if compareInfo.CompareBase == "" {
+		return compareInfo, nil
+	}
+
+	// We have a common base - therefore we know that ... should work
+	if !fileOnly {
+		// In git log/rev-list, the "..." syntax represents the symmetric difference between two references,
+		// 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.CompareBase+".."+compareInfo.HeadCommitID)
+		if err != nil {
+			return compareInfo, fmt.Errorf("ShowPrettyFormatLogToList: %w", err)
+		}
+	}
+
+	// Count number of changed files.
+	// 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)
+	return compareInfo, err
+}