// 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/util" ) type CompareBaseHead struct { BaseRepo *repo_model.Repository BaseGitRepo *git.Repository BaseRef git.RefName HeadRepo *repo_model.Repository HeadGitRepo *git.Repository HeadRef git.RefName } // CompareInfo represents needed information for comparing references. type CompareInfo struct { CompareBaseHead BaseCommitID string 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, bh CompareBaseHead, directComparison, fileOnly bool) (ci CompareInfo, err error) { baseCommitID, err1 := bh.BaseGitRepo.GetRefCommitID(ctx, bh.BaseRef.String()) headCommitID, err2 := bh.HeadGitRepo.GetRefCommitID(ctx, bh.HeadRef.String()) ci = CompareInfo{ CompareBaseHead: bh, BaseCommitID: baseCommitID, HeadCommitID: headCommitID, CompareSeparator: util.Iif(directComparison, "..", "..."), } if err1 != nil || err2 != nil { return ci, 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 the head repository in the following code if bh.BaseRepo.ID != bh.HeadRepo.ID { exist := bh.HeadGitRepo.IsReferenceExist(ctx, ci.BaseCommitID) if !exist { if err := git.FetchRemoteTempCommit(ctx, bh.HeadRepo, bh.BaseRepo, ci.BaseCommitID); err != nil { return ci, fmt.Errorf("FetchRemoteTempCommit: %w", err) } } } if !directComparison { ci.CompareBase, err = git.MergeBase(ctx, bh.HeadRepo, ci.BaseCommitID, ci.HeadCommitID) if err != nil && !errors.Is(err, util.ErrNotExist) { return ci, fmt.Errorf("MergeBase: %w", err) } } else { ci.CompareBase = ci.BaseCommitID } if ci.CompareBase == "" { return ci, 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. ci.Commits, err = bh.HeadGitRepo.ShowPrettyFormatLogToList(ctx, ci.CompareBase+".."+ci.HeadCommitID) if err != nil { return ci, 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 ci.NumFiles, err = bh.HeadGitRepo.GetDiffNumChangedFiles(ctx, ci.BaseCommitID, ci.HeadCommitID, directComparison) return ci, err }