mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-12-23 12:59:11 -05:00
e6706df49d
* 'update' * Send push tag event when release created * send tag create event while release created in UI * update to go v1.13 * fix gofmt error * fix #8576 create pull request on current repository by default
425 lines
13 KiB
Go
425 lines
13 KiB
Go
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package repo
|
|
|
|
import (
|
|
"fmt"
|
|
"path"
|
|
"strings"
|
|
|
|
"code.gitea.io/gitea/models"
|
|
"code.gitea.io/gitea/modules/base"
|
|
"code.gitea.io/gitea/modules/context"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/services/gitdiff"
|
|
)
|
|
|
|
const (
|
|
tplCompare base.TplName = "repo/diff/compare"
|
|
)
|
|
|
|
// setPathsCompareContext sets context data for source and raw paths
|
|
func setPathsCompareContext(ctx *context.Context, base *git.Commit, head *git.Commit, headTarget string) {
|
|
sourcePath := setting.AppSubURL + "/%s/src/commit/%s"
|
|
rawPath := setting.AppSubURL + "/%s/raw/commit/%s"
|
|
|
|
ctx.Data["SourcePath"] = fmt.Sprintf(sourcePath, headTarget, head.ID)
|
|
ctx.Data["RawPath"] = fmt.Sprintf(rawPath, headTarget, head.ID)
|
|
if base != nil {
|
|
baseTarget := path.Join(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
|
|
ctx.Data["BeforeSourcePath"] = fmt.Sprintf(sourcePath, baseTarget, base.ID)
|
|
ctx.Data["BeforeRawPath"] = fmt.Sprintf(rawPath, baseTarget, base.ID)
|
|
}
|
|
}
|
|
|
|
// setImageCompareContext sets context data that is required by image compare template
|
|
func setImageCompareContext(ctx *context.Context, base *git.Commit, head *git.Commit) {
|
|
ctx.Data["IsImageFileInHead"] = head.IsImageFile
|
|
ctx.Data["IsImageFileInBase"] = base.IsImageFile
|
|
ctx.Data["ImageInfoBase"] = func(name string) *git.ImageMetaData {
|
|
if base == nil {
|
|
return nil
|
|
}
|
|
result, err := base.ImageInfo(name)
|
|
if err != nil {
|
|
log.Error("ImageInfo failed: %v", err)
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
ctx.Data["ImageInfo"] = func(name string) *git.ImageMetaData {
|
|
result, err := head.ImageInfo(name)
|
|
if err != nil {
|
|
log.Error("ImageInfo failed: %v", err)
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
}
|
|
|
|
// ParseCompareInfo parse compare info between two commit for preparing comparing references
|
|
func ParseCompareInfo(ctx *context.Context) (*models.User, *models.Repository, *git.Repository, *git.CompareInfo, string, string) {
|
|
baseRepo := ctx.Repo.Repository
|
|
|
|
// Get compared branches information
|
|
// format: <base branch>...[<head repo>:]<head branch>
|
|
// base<-head: master...head:feature
|
|
// same repo: master...feature
|
|
|
|
var (
|
|
headUser *models.User
|
|
headBranch string
|
|
isSameRepo bool
|
|
infoPath string
|
|
err error
|
|
)
|
|
infoPath = ctx.Params("*")
|
|
infos := strings.Split(infoPath, "...")
|
|
if len(infos) != 2 {
|
|
log.Trace("ParseCompareInfo[%d]: not enough compared branches information %s", baseRepo.ID, infos)
|
|
ctx.NotFound("CompareAndPullRequest", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
|
|
baseBranch := infos[0]
|
|
ctx.Data["BaseBranch"] = baseBranch
|
|
|
|
// If there is no head repository, it means compare between same repository.
|
|
headInfos := strings.Split(infos[1], ":")
|
|
if len(headInfos) == 1 {
|
|
isSameRepo = true
|
|
headUser = ctx.Repo.Owner
|
|
headBranch = headInfos[0]
|
|
|
|
} else if len(headInfos) == 2 {
|
|
headUser, err = models.GetUserByName(headInfos[0])
|
|
if err != nil {
|
|
if models.IsErrUserNotExist(err) {
|
|
ctx.NotFound("GetUserByName", nil)
|
|
} else {
|
|
ctx.ServerError("GetUserByName", err)
|
|
}
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
headBranch = headInfos[1]
|
|
isSameRepo = headUser.ID == ctx.Repo.Owner.ID
|
|
} else {
|
|
ctx.NotFound("CompareAndPullRequest", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
ctx.Data["HeadUser"] = headUser
|
|
ctx.Data["HeadBranch"] = headBranch
|
|
ctx.Repo.PullRequest.SameRepo = isSameRepo
|
|
|
|
// Check if base branch is valid.
|
|
baseIsCommit := ctx.Repo.GitRepo.IsCommitExist(baseBranch)
|
|
baseIsBranch := ctx.Repo.GitRepo.IsBranchExist(baseBranch)
|
|
baseIsTag := ctx.Repo.GitRepo.IsTagExist(baseBranch)
|
|
if !baseIsCommit && !baseIsBranch && !baseIsTag {
|
|
// Check if baseBranch is short sha commit hash
|
|
if baseCommit, _ := ctx.Repo.GitRepo.GetCommit(baseBranch); baseCommit != nil {
|
|
baseBranch = baseCommit.ID.String()
|
|
ctx.Data["BaseBranch"] = baseBranch
|
|
baseIsCommit = true
|
|
} else {
|
|
ctx.NotFound("IsRefExist", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
}
|
|
ctx.Data["BaseIsCommit"] = baseIsCommit
|
|
ctx.Data["BaseIsBranch"] = baseIsBranch
|
|
ctx.Data["BaseIsTag"] = baseIsTag
|
|
|
|
// Check if current user has fork of repository or in the same repository.
|
|
headRepo, has := models.HasForkedRepo(headUser.ID, baseRepo.ID)
|
|
if !has && !isSameRepo {
|
|
ctx.Data["PageIsComparePull"] = false
|
|
}
|
|
|
|
var headGitRepo *git.Repository
|
|
if isSameRepo {
|
|
headRepo = ctx.Repo.Repository
|
|
headGitRepo = ctx.Repo.GitRepo
|
|
ctx.Data["BaseName"] = headUser.Name
|
|
} else {
|
|
headGitRepo, err = git.OpenRepository(models.RepoPath(headUser.Name, headRepo.Name))
|
|
ctx.Data["BaseName"] = baseRepo.OwnerName
|
|
if err != nil {
|
|
ctx.ServerError("OpenRepository", err)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
}
|
|
|
|
// user should have permission to read baseRepo's codes and pulls, NOT headRepo's
|
|
permBase, err := models.GetUserRepoPermission(baseRepo, ctx.User)
|
|
if err != nil {
|
|
ctx.ServerError("GetUserRepoPermission", err)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
if !permBase.CanRead(models.UnitTypeCode) {
|
|
if log.IsTrace() {
|
|
log.Trace("Permission Denied: User: %-v cannot read code in Repo: %-v\nUser in baseRepo has Permissions: %-+v",
|
|
ctx.User,
|
|
baseRepo,
|
|
permBase)
|
|
}
|
|
ctx.NotFound("ParseCompareInfo", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
|
|
// user should have permission to read headrepo's codes
|
|
permHead, err := models.GetUserRepoPermission(headRepo, ctx.User)
|
|
if err != nil {
|
|
ctx.ServerError("GetUserRepoPermission", err)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
if !permHead.CanRead(models.UnitTypeCode) {
|
|
if log.IsTrace() {
|
|
log.Trace("Permission Denied: User: %-v cannot read code in Repo: %-v\nUser in headRepo has Permissions: %-+v",
|
|
ctx.User,
|
|
headRepo,
|
|
permHead)
|
|
}
|
|
ctx.NotFound("ParseCompareInfo", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
|
|
// Check if head branch is valid.
|
|
headIsCommit := ctx.Repo.GitRepo.IsCommitExist(headBranch)
|
|
headIsBranch := headGitRepo.IsBranchExist(headBranch)
|
|
headIsTag := headGitRepo.IsTagExist(headBranch)
|
|
if !headIsCommit && !headIsBranch && !headIsTag {
|
|
// Check if headBranch is short sha commit hash
|
|
if headCommit, _ := ctx.Repo.GitRepo.GetCommit(headBranch); headCommit != nil {
|
|
headBranch = headCommit.ID.String()
|
|
ctx.Data["HeadBranch"] = headBranch
|
|
headIsCommit = true
|
|
} else {
|
|
ctx.NotFound("IsRefExist", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
}
|
|
ctx.Data["HeadIsCommit"] = headIsCommit
|
|
ctx.Data["HeadIsBranch"] = headIsBranch
|
|
ctx.Data["HeadIsTag"] = headIsTag
|
|
|
|
// Treat as pull request if both references are branches
|
|
if ctx.Data["PageIsComparePull"] == nil {
|
|
ctx.Data["PageIsComparePull"] = headIsBranch && baseIsBranch
|
|
}
|
|
|
|
if ctx.Data["PageIsComparePull"] == true && !permBase.CanReadIssuesOrPulls(true) {
|
|
if log.IsTrace() {
|
|
log.Trace("Permission Denied: User: %-v cannot create/read pull requests in Repo: %-v\nUser in baseRepo has Permissions: %-+v",
|
|
ctx.User,
|
|
baseRepo,
|
|
permBase)
|
|
}
|
|
ctx.NotFound("ParseCompareInfo", nil)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
|
|
compareInfo, err := headGitRepo.GetCompareInfo(models.RepoPath(baseRepo.Owner.Name, baseRepo.Name), baseBranch, headBranch)
|
|
if err != nil {
|
|
ctx.ServerError("GetCompareInfo", err)
|
|
return nil, nil, nil, nil, "", ""
|
|
}
|
|
ctx.Data["BeforeCommitID"] = compareInfo.MergeBase
|
|
|
|
return headUser, headRepo, headGitRepo, compareInfo, baseBranch, headBranch
|
|
}
|
|
|
|
// PrepareCompareDiff renders compare diff page
|
|
func PrepareCompareDiff(
|
|
ctx *context.Context,
|
|
headUser *models.User,
|
|
headRepo *models.Repository,
|
|
headGitRepo *git.Repository,
|
|
compareInfo *git.CompareInfo,
|
|
baseBranch, headBranch string) bool {
|
|
|
|
var (
|
|
repo = ctx.Repo.Repository
|
|
err error
|
|
title string
|
|
)
|
|
|
|
// Get diff information.
|
|
ctx.Data["CommitRepoLink"] = headRepo.Link()
|
|
|
|
headCommitID := headBranch
|
|
if ctx.Data["HeadIsCommit"] == false {
|
|
if ctx.Data["HeadIsTag"] == true {
|
|
headCommitID, err = headGitRepo.GetTagCommitID(headBranch)
|
|
} else {
|
|
headCommitID, err = headGitRepo.GetBranchCommitID(headBranch)
|
|
}
|
|
if err != nil {
|
|
ctx.ServerError("GetRefCommitID", err)
|
|
return false
|
|
}
|
|
}
|
|
|
|
ctx.Data["AfterCommitID"] = headCommitID
|
|
|
|
if headCommitID == compareInfo.MergeBase {
|
|
ctx.Data["IsNothingToCompare"] = true
|
|
return true
|
|
}
|
|
|
|
diff, err := gitdiff.GetDiffRange(models.RepoPath(headUser.Name, headRepo.Name),
|
|
compareInfo.MergeBase, headCommitID, setting.Git.MaxGitDiffLines,
|
|
setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles)
|
|
if err != nil {
|
|
ctx.ServerError("GetDiffRange", err)
|
|
return false
|
|
}
|
|
ctx.Data["Diff"] = diff
|
|
ctx.Data["DiffNotAvailable"] = diff.NumFiles() == 0
|
|
|
|
headCommit, err := headGitRepo.GetCommit(headCommitID)
|
|
if err != nil {
|
|
ctx.ServerError("GetCommit", err)
|
|
return false
|
|
}
|
|
|
|
baseGitRepo := ctx.Repo.GitRepo
|
|
baseCommitID := baseBranch
|
|
if ctx.Data["BaseIsCommit"] == false {
|
|
if ctx.Data["BaseIsTag"] == true {
|
|
baseCommitID, err = baseGitRepo.GetTagCommitID(baseBranch)
|
|
} else {
|
|
baseCommitID, err = baseGitRepo.GetBranchCommitID(baseBranch)
|
|
}
|
|
if err != nil {
|
|
ctx.ServerError("GetRefCommitID", err)
|
|
return false
|
|
}
|
|
}
|
|
|
|
baseCommit, err := baseGitRepo.GetCommit(baseCommitID)
|
|
if err != nil {
|
|
ctx.ServerError("GetCommit", err)
|
|
return false
|
|
}
|
|
|
|
compareInfo.Commits = models.ValidateCommitsWithEmails(compareInfo.Commits)
|
|
compareInfo.Commits = models.ParseCommitsWithSignature(compareInfo.Commits)
|
|
compareInfo.Commits = models.ParseCommitsWithStatus(compareInfo.Commits, headRepo)
|
|
ctx.Data["Commits"] = compareInfo.Commits
|
|
ctx.Data["CommitCount"] = compareInfo.Commits.Len()
|
|
if ctx.Data["CommitCount"] == 0 {
|
|
ctx.Data["PageIsComparePull"] = false
|
|
}
|
|
|
|
if compareInfo.Commits.Len() == 1 {
|
|
c := compareInfo.Commits.Front().Value.(models.SignCommitWithStatuses)
|
|
title = strings.TrimSpace(c.UserCommit.Summary())
|
|
|
|
body := strings.Split(strings.TrimSpace(c.UserCommit.Message()), "\n")
|
|
if len(body) > 1 {
|
|
ctx.Data["content"] = strings.Join(body[1:], "\n")
|
|
}
|
|
} else {
|
|
title = headBranch
|
|
}
|
|
|
|
ctx.Data["title"] = title
|
|
ctx.Data["Username"] = headUser.Name
|
|
ctx.Data["Reponame"] = headRepo.Name
|
|
|
|
setImageCompareContext(ctx, baseCommit, headCommit)
|
|
headTarget := path.Join(headUser.Name, repo.Name)
|
|
setPathsCompareContext(ctx, baseCommit, headCommit, headTarget)
|
|
|
|
return false
|
|
}
|
|
|
|
// parseBaseRepoInfo parse base repository if current repo is forked.
|
|
// The "base" here means the repository where current repo forks from,
|
|
// not the repository fetch from current URL.
|
|
func parseBaseRepoInfo(ctx *context.Context, repo *models.Repository) error {
|
|
if !repo.IsFork {
|
|
return nil
|
|
}
|
|
if err := repo.GetBaseRepo(); err != nil {
|
|
return err
|
|
}
|
|
if err := repo.BaseRepo.GetOwnerName(); err != nil {
|
|
return err
|
|
}
|
|
baseGitRepo, err := git.OpenRepository(models.RepoPath(repo.BaseRepo.OwnerName, repo.BaseRepo.Name))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ctx.Data["BaseRepoBranches"], err = baseGitRepo.GetBranches()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CompareDiff show different from one commit to another commit
|
|
func CompareDiff(ctx *context.Context) {
|
|
headUser, headRepo, headGitRepo, compareInfo, baseBranch, headBranch := ParseCompareInfo(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
if err := parseBaseRepoInfo(ctx, headRepo); err != nil {
|
|
ctx.ServerError("parseBaseRepoInfo", err)
|
|
return
|
|
}
|
|
|
|
nothingToCompare := PrepareCompareDiff(ctx, headUser, headRepo, headGitRepo, compareInfo, baseBranch, headBranch)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
if ctx.Data["PageIsComparePull"] == true {
|
|
headBranches, err := headGitRepo.GetBranches()
|
|
if err != nil {
|
|
ctx.ServerError("GetBranches", err)
|
|
return
|
|
}
|
|
ctx.Data["HeadBranches"] = headBranches
|
|
|
|
pr, err := models.GetUnmergedPullRequest(headRepo.ID, ctx.Repo.Repository.ID, headBranch, baseBranch)
|
|
if err != nil {
|
|
if !models.IsErrPullRequestNotExist(err) {
|
|
ctx.ServerError("GetUnmergedPullRequest", err)
|
|
return
|
|
}
|
|
} else {
|
|
ctx.Data["HasPullRequest"] = true
|
|
ctx.Data["PullRequest"] = pr
|
|
ctx.HTML(200, tplCompareDiff)
|
|
return
|
|
}
|
|
|
|
if !nothingToCompare {
|
|
// Setup information for new form.
|
|
RetrieveRepoMetas(ctx, ctx.Repo.Repository)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
beforeCommitID := ctx.Data["BeforeCommitID"].(string)
|
|
afterCommitID := ctx.Data["AfterCommitID"].(string)
|
|
|
|
ctx.Data["Title"] = "Comparing " + base.ShortSha(beforeCommitID) + "..." + base.ShortSha(afterCommitID)
|
|
|
|
ctx.Data["IsRepoToolbarCommits"] = true
|
|
ctx.Data["IsDiffCompare"] = true
|
|
ctx.Data["RequireHighlightJS"] = true
|
|
ctx.Data["RequireTribute"] = true
|
|
ctx.Data["PullRequestWorkInProgressPrefixes"] = setting.Repository.PullRequest.WorkInProgressPrefixes
|
|
setTemplateIfExists(ctx, pullRequestTemplateKey, pullRequestTemplateCandidates)
|
|
renderAttachmentSettings(ctx)
|
|
|
|
ctx.HTML(200, tplCompare)
|
|
}
|