2014-03-24 06:25:15 -04:00
|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
2019-04-20 00:15:19 -04:00
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
2014-03-24 06:25:15 -04:00
|
|
|
// Use of this source code is governed by a MIT-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package repo
|
|
|
|
|
2014-07-26 02:28:04 -04:00
|
|
|
import (
|
2021-04-01 01:17:14 -04:00
|
|
|
"errors"
|
2014-07-26 02:28:04 -04:00
|
|
|
"path"
|
2017-02-10 23:00:01 -05:00
|
|
|
"strings"
|
2014-07-26 02:28:04 -04:00
|
|
|
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/models"
|
|
|
|
"code.gitea.io/gitea/modules/base"
|
2019-08-15 08:07:28 -04:00
|
|
|
"code.gitea.io/gitea/modules/charset"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/context"
|
2019-03-27 05:33:00 -04:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2019-11-15 19:47:57 -05:00
|
|
|
"code.gitea.io/gitea/modules/gitgraph"
|
2017-09-14 02:51:32 -04:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-09-05 22:20:09 -04:00
|
|
|
"code.gitea.io/gitea/services/gitdiff"
|
2014-07-26 02:28:04 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2019-06-07 16:29:29 -04:00
|
|
|
tplCommits base.TplName = "repo/commits"
|
|
|
|
tplGraph base.TplName = "repo/graph"
|
2020-11-08 12:21:54 -05:00
|
|
|
tplGraphDiv base.TplName = "repo/graph/div"
|
2019-06-07 16:29:29 -04:00
|
|
|
tplCommitPage base.TplName = "repo/commit_page"
|
2014-07-26 02:28:04 -04:00
|
|
|
)
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
// RefCommits render commits page
|
2016-03-11 11:56:52 -05:00
|
|
|
func RefCommits(ctx *context.Context) {
|
2014-11-06 22:06:41 -05:00
|
|
|
switch {
|
2016-08-25 00:35:03 -04:00
|
|
|
case len(ctx.Repo.TreePath) == 0:
|
2014-11-06 22:06:41 -05:00
|
|
|
Commits(ctx)
|
2016-08-25 00:35:03 -04:00
|
|
|
case ctx.Repo.TreePath == "search":
|
2014-11-06 22:06:41 -05:00
|
|
|
SearchCommits(ctx)
|
|
|
|
default:
|
|
|
|
FileHistory(ctx)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
// Commits render branch's commits
|
2016-03-11 11:56:52 -05:00
|
|
|
func Commits(ctx *context.Context) {
|
2015-08-20 08:18:49 -04:00
|
|
|
ctx.Data["PageIsCommits"] = true
|
2017-07-30 21:23:10 -04:00
|
|
|
if ctx.Repo.Commit == nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.NotFound("Commit not found", nil)
|
2017-07-30 21:23:10 -04:00
|
|
|
return
|
|
|
|
}
|
2017-10-25 20:49:16 -04:00
|
|
|
ctx.Data["PageIsViewCode"] = true
|
2014-07-26 02:28:04 -04:00
|
|
|
|
2017-10-25 21:37:33 -04:00
|
|
|
commitsCount, err := ctx.Repo.GetCommitsCount()
|
2014-07-26 02:28:04 -04:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("GetCommitsCount", err)
|
2014-07-26 02:28:04 -04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-08-20 08:18:49 -04:00
|
|
|
page := ctx.QueryInt("page")
|
|
|
|
if page <= 1 {
|
2014-07-26 02:28:04 -04:00
|
|
|
page = 1
|
|
|
|
}
|
|
|
|
|
2020-01-24 14:00:29 -05:00
|
|
|
pageSize := ctx.QueryInt("limit")
|
|
|
|
if pageSize <= 0 {
|
|
|
|
pageSize = git.CommitsRangeSize
|
|
|
|
}
|
|
|
|
|
2014-07-26 02:28:04 -04:00
|
|
|
// Both `git log branchName` and `git log commitId` work.
|
2020-01-24 14:00:29 -05:00
|
|
|
commits, err := ctx.Repo.Commit.CommitsByRange(page, pageSize)
|
2014-07-26 02:28:04 -04:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("CommitsByRange", err)
|
2014-07-26 02:28:04 -04:00
|
|
|
return
|
|
|
|
}
|
2014-09-26 08:55:13 -04:00
|
|
|
commits = models.ValidateCommitsWithEmails(commits)
|
2020-02-27 14:20:55 -05:00
|
|
|
commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
|
2017-05-07 10:40:31 -04:00
|
|
|
commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
|
2014-09-23 15:30:04 -04:00
|
|
|
ctx.Data["Commits"] = commits
|
2015-11-10 16:46:17 -05:00
|
|
|
|
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
2014-07-26 02:28:04 -04:00
|
|
|
ctx.Data["CommitCount"] = commitsCount
|
2015-11-10 16:46:17 -05:00
|
|
|
ctx.Data["Branch"] = ctx.Repo.BranchName
|
2019-04-20 00:15:19 -04:00
|
|
|
|
|
|
|
pager := context.NewPagination(int(commitsCount), git.CommitsRangeSize, page, 5)
|
|
|
|
pager.SetDefaultParams(ctx)
|
|
|
|
ctx.Data["Page"] = pager
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
ctx.HTML(200, tplCommits)
|
2014-07-26 02:28:04 -04:00
|
|
|
}
|
|
|
|
|
2016-12-28 18:44:32 -05:00
|
|
|
// Graph render commit graph - show commits from all branches.
|
|
|
|
func Graph(ctx *context.Context) {
|
2020-11-08 12:21:54 -05:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.commit_graph")
|
2016-12-28 18:44:32 -05:00
|
|
|
ctx.Data["PageIsCommits"] = true
|
2017-10-25 20:49:16 -04:00
|
|
|
ctx.Data["PageIsViewCode"] = true
|
2020-08-06 04:04:08 -04:00
|
|
|
mode := strings.ToLower(ctx.QueryTrim("mode"))
|
|
|
|
if mode != "monochrome" {
|
|
|
|
mode = "color"
|
|
|
|
}
|
|
|
|
ctx.Data["Mode"] = mode
|
2020-11-08 12:21:54 -05:00
|
|
|
hidePRRefs := ctx.QueryBool("hide-pr-refs")
|
|
|
|
ctx.Data["HidePRRefs"] = hidePRRefs
|
|
|
|
branches := ctx.QueryStrings("branch")
|
|
|
|
realBranches := make([]string, len(branches))
|
|
|
|
copy(realBranches, branches)
|
|
|
|
for i, branch := range realBranches {
|
|
|
|
if strings.HasPrefix(branch, "--") {
|
|
|
|
realBranches[i] = "refs/heads/" + branch
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ctx.Data["SelectedBranches"] = realBranches
|
|
|
|
files := ctx.QueryStrings("file")
|
2016-12-28 18:44:32 -05:00
|
|
|
|
2017-10-25 21:37:33 -04:00
|
|
|
commitsCount, err := ctx.Repo.GetCommitsCount()
|
2016-12-28 18:44:32 -05:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("GetCommitsCount", err)
|
2016-12-28 18:44:32 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-11-08 12:21:54 -05:00
|
|
|
graphCommitsCount, err := ctx.Repo.GetCommitGraphsCount(hidePRRefs, realBranches, files)
|
2019-11-07 13:09:51 -05:00
|
|
|
if err != nil {
|
2020-11-08 12:21:54 -05:00
|
|
|
log.Warn("GetCommitGraphsCount error for generate graph exclude prs: %t branches: %s in %-v, Will Ignore branches and try again. Underlying Error: %v", hidePRRefs, branches, ctx.Repo.Repository, err)
|
|
|
|
realBranches = []string{}
|
|
|
|
branches = []string{}
|
|
|
|
graphCommitsCount, err = ctx.Repo.GetCommitGraphsCount(hidePRRefs, realBranches, files)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetCommitGraphsCount", err)
|
|
|
|
return
|
|
|
|
}
|
2019-11-07 13:09:51 -05:00
|
|
|
}
|
|
|
|
|
2019-10-14 17:38:35 -04:00
|
|
|
page := ctx.QueryInt("page")
|
|
|
|
|
2020-11-08 12:21:54 -05:00
|
|
|
graph, err := gitgraph.GetCommitGraph(ctx.Repo.GitRepo, page, 0, hidePRRefs, realBranches, files)
|
2016-12-28 18:44:32 -05:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("GetCommitGraph", err)
|
2016-12-28 18:44:32 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-11-08 12:21:54 -05:00
|
|
|
if err := graph.LoadAndProcessCommits(ctx.Repo.Repository, ctx.Repo.GitRepo); err != nil {
|
|
|
|
ctx.ServerError("LoadAndProcessCommits", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-12-28 18:44:32 -05:00
|
|
|
ctx.Data["Graph"] = graph
|
2020-11-08 12:21:54 -05:00
|
|
|
|
|
|
|
gitRefs, err := ctx.Repo.GitRepo.GetRefs()
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GitRepo.GetRefs", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Data["AllRefs"] = gitRefs
|
|
|
|
|
2016-12-28 18:44:32 -05:00
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
|
|
|
ctx.Data["CommitCount"] = commitsCount
|
|
|
|
ctx.Data["Branch"] = ctx.Repo.BranchName
|
2020-11-08 12:21:54 -05:00
|
|
|
paginator := context.NewPagination(int(graphCommitsCount), setting.UI.GraphMaxCommitNum, page, 5)
|
2020-08-06 04:04:08 -04:00
|
|
|
paginator.AddParam(ctx, "mode", "Mode")
|
2020-11-08 12:21:54 -05:00
|
|
|
paginator.AddParam(ctx, "hide-pr-refs", "HidePRRefs")
|
|
|
|
for _, branch := range branches {
|
|
|
|
paginator.AddParamString("branch", branch)
|
|
|
|
}
|
|
|
|
for _, file := range files {
|
|
|
|
paginator.AddParamString("file", file)
|
|
|
|
}
|
2020-08-06 04:04:08 -04:00
|
|
|
ctx.Data["Page"] = paginator
|
2020-11-08 12:21:54 -05:00
|
|
|
if ctx.QueryBool("div-only") {
|
|
|
|
ctx.HTML(200, tplGraphDiv)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-12-28 18:44:32 -05:00
|
|
|
ctx.HTML(200, tplGraph)
|
|
|
|
}
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
// SearchCommits render commits filtered by keyword
|
2016-03-11 11:56:52 -05:00
|
|
|
func SearchCommits(ctx *context.Context) {
|
2015-08-20 08:18:49 -04:00
|
|
|
ctx.Data["PageIsCommits"] = true
|
2017-10-25 20:49:16 -04:00
|
|
|
ctx.Data["PageIsViewCode"] = true
|
2014-07-26 02:28:04 -04:00
|
|
|
|
2019-04-11 22:28:44 -04:00
|
|
|
query := strings.Trim(ctx.Query("q"), " ")
|
|
|
|
if len(query) == 0 {
|
2017-10-29 22:04:25 -04:00
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/commits/" + ctx.Repo.BranchNameSubURL())
|
2014-07-26 02:28:04 -04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-04-11 22:28:44 -04:00
|
|
|
all := ctx.QueryBool("all")
|
|
|
|
opts := git.NewSearchCommitsOptions(query, all)
|
|
|
|
commits, err := ctx.Repo.Commit.SearchCommits(opts)
|
2014-07-26 02:28:04 -04:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("SearchCommits", err)
|
2014-07-26 02:28:04 -04:00
|
|
|
return
|
|
|
|
}
|
2014-09-26 08:55:13 -04:00
|
|
|
commits = models.ValidateCommitsWithEmails(commits)
|
2020-02-27 14:20:55 -05:00
|
|
|
commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
|
2017-05-07 10:40:31 -04:00
|
|
|
commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
|
2015-11-10 16:46:17 -05:00
|
|
|
ctx.Data["Commits"] = commits
|
2014-07-26 02:28:04 -04:00
|
|
|
|
2019-04-11 22:28:44 -04:00
|
|
|
ctx.Data["Keyword"] = query
|
2017-02-05 09:43:28 -05:00
|
|
|
if all {
|
|
|
|
ctx.Data["All"] = "checked"
|
|
|
|
}
|
2015-11-10 16:46:17 -05:00
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
2014-07-26 02:28:04 -04:00
|
|
|
ctx.Data["CommitCount"] = commits.Len()
|
2015-11-10 16:46:17 -05:00
|
|
|
ctx.Data["Branch"] = ctx.Repo.BranchName
|
2016-11-24 02:04:31 -05:00
|
|
|
ctx.HTML(200, tplCommits)
|
2014-07-26 02:28:04 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
// FileHistory show a file's reversions
|
2016-03-11 11:56:52 -05:00
|
|
|
func FileHistory(ctx *context.Context) {
|
2014-11-06 22:06:41 -05:00
|
|
|
ctx.Data["IsRepoToolbarCommits"] = true
|
|
|
|
|
2016-08-25 00:35:03 -04:00
|
|
|
fileName := ctx.Repo.TreePath
|
2014-11-06 22:06:41 -05:00
|
|
|
if len(fileName) == 0 {
|
|
|
|
Commits(ctx)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
branchName := ctx.Repo.BranchName
|
|
|
|
commitsCount, err := ctx.Repo.GitRepo.FileCommitsCount(branchName, fileName)
|
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("FileCommitsCount", err)
|
2014-11-06 22:06:41 -05:00
|
|
|
return
|
|
|
|
} else if commitsCount == 0 {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.NotFound("FileCommitsCount", nil)
|
2014-11-06 22:06:41 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-11-10 16:46:17 -05:00
|
|
|
page := ctx.QueryInt("page")
|
|
|
|
if page <= 1 {
|
2014-11-06 22:06:41 -05:00
|
|
|
page = 1
|
|
|
|
}
|
|
|
|
|
2015-11-10 16:46:17 -05:00
|
|
|
commits, err := ctx.Repo.GitRepo.CommitsByFileAndRange(branchName, fileName, page)
|
2014-11-06 22:06:41 -05:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("CommitsByFileAndRange", err)
|
2014-11-06 22:06:41 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
commits = models.ValidateCommitsWithEmails(commits)
|
2020-02-27 14:20:55 -05:00
|
|
|
commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
|
2017-05-07 10:40:31 -04:00
|
|
|
commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
|
2014-11-06 22:06:41 -05:00
|
|
|
ctx.Data["Commits"] = commits
|
2015-11-10 16:46:17 -05:00
|
|
|
|
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
2014-11-06 22:06:41 -05:00
|
|
|
ctx.Data["FileName"] = fileName
|
|
|
|
ctx.Data["CommitCount"] = commitsCount
|
2015-11-10 16:46:17 -05:00
|
|
|
ctx.Data["Branch"] = branchName
|
2019-04-20 00:15:19 -04:00
|
|
|
|
|
|
|
pager := context.NewPagination(int(commitsCount), git.CommitsRangeSize, page, 5)
|
|
|
|
pager.SetDefaultParams(ctx)
|
|
|
|
ctx.Data["Page"] = pager
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
ctx.HTML(200, tplCommits)
|
2014-11-06 22:06:41 -05:00
|
|
|
}
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
// Diff show different from current commit to previous commit
|
2016-03-11 11:56:52 -05:00
|
|
|
func Diff(ctx *context.Context) {
|
2015-08-20 12:18:30 -04:00
|
|
|
ctx.Data["PageIsDiff"] = true
|
2016-08-16 10:31:54 -04:00
|
|
|
ctx.Data["RequireHighlightJS"] = true
|
2020-01-26 03:17:25 -05:00
|
|
|
ctx.Data["RequireSimpleMDE"] = true
|
|
|
|
ctx.Data["RequireTribute"] = true
|
2014-07-26 02:28:04 -04:00
|
|
|
|
|
|
|
userName := ctx.Repo.Owner.Name
|
|
|
|
repoName := ctx.Repo.Repository.Name
|
2016-03-21 10:49:46 -04:00
|
|
|
commitID := ctx.Params(":sha")
|
2020-05-16 12:38:40 -04:00
|
|
|
var (
|
|
|
|
gitRepo *git.Repository
|
|
|
|
err error
|
|
|
|
repoPath string
|
|
|
|
)
|
|
|
|
|
|
|
|
if ctx.Data["PageIsWiki"] != nil {
|
|
|
|
gitRepo, err = git.OpenRepository(ctx.Repo.Repository.WikiPath())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("Repo.GitRepo.GetCommit", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
repoPath = ctx.Repo.Repository.WikiPath()
|
|
|
|
} else {
|
|
|
|
gitRepo = ctx.Repo.GitRepo
|
|
|
|
repoPath = models.RepoPath(userName, repoName)
|
|
|
|
}
|
2016-03-21 10:49:46 -04:00
|
|
|
|
2020-05-16 12:38:40 -04:00
|
|
|
commit, err := gitRepo.GetCommit(commitID)
|
2016-03-21 10:49:46 -04:00
|
|
|
if err != nil {
|
2016-08-15 18:27:19 -04:00
|
|
|
if git.IsErrNotExist(err) {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.NotFound("Repo.GitRepo.GetCommit", err)
|
2016-08-15 18:27:19 -04:00
|
|
|
} else {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("Repo.GitRepo.GetCommit", err)
|
2016-08-15 18:27:19 -04:00
|
|
|
}
|
2016-03-21 10:49:46 -04:00
|
|
|
return
|
|
|
|
}
|
2016-11-06 16:15:44 -05:00
|
|
|
if len(commitID) != 40 {
|
|
|
|
commitID = commit.ID.String()
|
|
|
|
}
|
2017-09-14 02:51:32 -04:00
|
|
|
|
2020-12-17 22:33:32 -05:00
|
|
|
statuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, commitID, models.ListOptions{})
|
2017-09-14 02:51:32 -04:00
|
|
|
if err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("GetLatestCommitStatus: %v", err)
|
2017-09-14 02:51:32 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Data["CommitStatus"] = models.CalcCommitStatus(statuses)
|
2020-12-19 22:13:12 -05:00
|
|
|
ctx.Data["CommitStatuses"] = statuses
|
2017-09-14 02:51:32 -04:00
|
|
|
|
2021-02-12 23:35:43 -05:00
|
|
|
diff, err := gitdiff.GetDiffCommitWithWhitespaceBehavior(repoPath,
|
2016-06-29 11:11:00 -04:00
|
|
|
commitID, setting.Git.MaxGitDiffLines,
|
2021-02-12 23:35:43 -05:00
|
|
|
setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles,
|
|
|
|
gitdiff.GetWhitespaceFlag(ctx.Data["WhitespaceBehavior"].(string)))
|
2014-07-26 02:28:04 -04:00
|
|
|
if err != nil {
|
2021-02-12 23:35:43 -05:00
|
|
|
ctx.NotFound("GetDiffCommitWithWhitespaceBehavior", err)
|
2014-07-26 02:28:04 -04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
parents := make([]string, commit.ParentCount())
|
|
|
|
for i := 0; i < commit.ParentCount(); i++ {
|
2015-12-09 20:46:05 -05:00
|
|
|
sha, err := commit.ParentID(i)
|
2014-07-26 02:28:04 -04:00
|
|
|
if err != nil {
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.NotFound("repo.Diff", err)
|
2014-07-26 02:28:04 -04:00
|
|
|
return
|
|
|
|
}
|
2020-02-27 18:10:27 -05:00
|
|
|
parents[i] = sha.String()
|
2014-07-26 02:28:04 -04:00
|
|
|
}
|
|
|
|
|
2016-03-21 10:49:46 -04:00
|
|
|
ctx.Data["CommitID"] = commitID
|
2019-11-14 21:52:59 -05:00
|
|
|
ctx.Data["AfterCommitID"] = commitID
|
2014-07-26 02:28:04 -04:00
|
|
|
ctx.Data["Username"] = userName
|
|
|
|
ctx.Data["Reponame"] = repoName
|
2019-10-04 15:58:54 -04:00
|
|
|
|
|
|
|
var parentCommit *git.Commit
|
2019-09-16 05:03:22 -04:00
|
|
|
if commit.ParentCount() > 0 {
|
2020-05-16 12:38:40 -04:00
|
|
|
parentCommit, err = gitRepo.GetCommit(parents[0])
|
2019-09-16 05:03:22 -04:00
|
|
|
if err != nil {
|
|
|
|
ctx.NotFound("GetParentCommit", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2019-10-04 15:58:54 -04:00
|
|
|
headTarget := path.Join(userName, repoName)
|
2021-03-29 16:44:28 -04:00
|
|
|
setCompareContext(ctx, parentCommit, commit, headTarget)
|
2015-08-31 03:24:28 -04:00
|
|
|
ctx.Data["Title"] = commit.Summary() + " · " + base.ShortSha(commitID)
|
2014-07-26 02:28:04 -04:00
|
|
|
ctx.Data["Commit"] = commit
|
2020-02-27 14:20:55 -05:00
|
|
|
verification := models.ParseCommitWithSignature(commit)
|
|
|
|
ctx.Data["Verification"] = verification
|
2014-10-10 21:40:51 -04:00
|
|
|
ctx.Data["Author"] = models.ValidateCommitWithEmail(commit)
|
2014-07-26 02:28:04 -04:00
|
|
|
ctx.Data["Diff"] = diff
|
|
|
|
ctx.Data["Parents"] = parents
|
2020-05-26 01:58:07 -04:00
|
|
|
ctx.Data["DiffNotAvailable"] = diff.NumFiles == 0
|
2019-05-24 03:52:05 -04:00
|
|
|
|
2020-02-27 14:20:55 -05:00
|
|
|
if err := models.CalculateTrustStatus(verification, ctx.Repo.Repository, nil); err != nil {
|
|
|
|
ctx.ServerError("CalculateTrustStatus", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-05-24 03:52:05 -04:00
|
|
|
note := &git.Note{}
|
|
|
|
err = git.GetNote(ctx.Repo.GitRepo, commitID, note)
|
|
|
|
if err == nil {
|
2019-08-15 08:07:28 -04:00
|
|
|
ctx.Data["Note"] = string(charset.ToUTF8WithFallback(note.Message))
|
2019-05-24 03:52:05 -04:00
|
|
|
ctx.Data["NoteCommit"] = note.Commit
|
|
|
|
ctx.Data["NoteAuthor"] = models.ValidateCommitWithEmail(note.Commit)
|
|
|
|
}
|
|
|
|
|
2019-04-19 08:17:27 -04:00
|
|
|
ctx.Data["BranchName"], err = commit.GetBranchName()
|
2019-06-12 15:41:28 -04:00
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("commit.GetBranchName", err)
|
2020-05-23 15:49:48 -04:00
|
|
|
return
|
2019-06-12 15:41:28 -04:00
|
|
|
}
|
2020-06-11 15:42:55 -04:00
|
|
|
|
|
|
|
ctx.Data["TagName"], err = commit.GetTagName()
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("commit.GetTagName", err)
|
|
|
|
return
|
|
|
|
}
|
2019-06-07 16:29:29 -04:00
|
|
|
ctx.HTML(200, tplCommitPage)
|
2014-07-26 02:28:04 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 02:04:31 -05:00
|
|
|
// RawDiff dumps diff results of repository in given commit ID to io.Writer
|
2016-03-21 10:49:46 -04:00
|
|
|
func RawDiff(ctx *context.Context) {
|
2020-05-16 12:38:40 -04:00
|
|
|
var repoPath string
|
|
|
|
if ctx.Data["PageIsWiki"] != nil {
|
|
|
|
repoPath = ctx.Repo.Repository.WikiPath()
|
|
|
|
} else {
|
|
|
|
repoPath = models.RepoPath(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
|
|
|
|
}
|
2020-01-28 03:02:03 -05:00
|
|
|
if err := git.GetRawDiff(
|
2020-05-16 12:38:40 -04:00
|
|
|
repoPath,
|
2016-07-30 11:02:22 -04:00
|
|
|
ctx.Params(":sha"),
|
2020-01-28 03:02:03 -05:00
|
|
|
git.RawDiffType(ctx.Params(":ext")),
|
2016-07-30 11:39:58 -04:00
|
|
|
ctx.Resp,
|
|
|
|
); err != nil {
|
2021-04-01 01:17:14 -04:00
|
|
|
if git.IsErrNotExist(err) {
|
|
|
|
ctx.NotFound("GetRawDiff",
|
|
|
|
errors.New("commit "+ctx.Params(":sha")+" does not exist."))
|
|
|
|
return
|
|
|
|
}
|
2018-01-10 16:34:17 -05:00
|
|
|
ctx.ServerError("GetRawDiff", err)
|
2016-07-30 11:02:22 -04:00
|
|
|
return
|
|
|
|
}
|
2016-03-21 10:49:46 -04:00
|
|
|
}
|