0
Fork 0
mirror of https://codeberg.org/forgejo/forgejo.git synced 2024-12-25 08:54:17 -05:00
forgejo/modules/git/repo_commit.go

410 lines
11 KiB
Go
Raw Normal View History

2016-11-03 17:16:01 -05:00
// Copyright 2015 The Gogs 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 git
import (
"bytes"
"container/list"
"strconv"
"strings"
2018-05-27 13:47:34 -05:00
version "github.com/mcuadros/go-version"
2016-11-03 17:16:01 -05:00
)
// GetRefCommitID returns the last commit ID string of given reference (branch or tag).
func (repo *Repository) GetRefCommitID(name string) (string, error) {
2016-11-03 17:16:01 -05:00
stdout, err := NewCommand("show-ref", "--verify", name).RunInDir(repo.Path)
if err != nil {
if strings.Contains(err.Error(), "not a valid ref") {
return "", ErrNotExist{name, ""}
}
return "", err
}
return strings.Split(stdout, " ")[0], nil
}
// GetBranchCommitID returns last commit ID string of given branch.
func (repo *Repository) GetBranchCommitID(name string) (string, error) {
return repo.GetRefCommitID(BranchPrefix + name)
2016-11-03 17:16:01 -05:00
}
// GetTagCommitID returns last commit ID string of given tag.
func (repo *Repository) GetTagCommitID(name string) (string, error) {
stdout, err := NewCommand("rev-list", "-n", "1", name).RunInDir(repo.Path)
if err != nil {
if strings.Contains(err.Error(), "unknown revision or path") {
return "", ErrNotExist{name, ""}
}
return "", err
}
return strings.TrimSpace(stdout), nil
2016-11-03 17:16:01 -05:00
}
// parseCommitData parses commit information from the (uncompressed) raw
// data from the commit object.
// \n\n separate headers from message
func parseCommitData(data []byte) (*Commit, error) {
commit := new(Commit)
2016-12-22 04:30:52 -05:00
commit.parents = make([]SHA1, 0, 1)
2016-11-03 17:16:01 -05:00
// we now have the contents of the commit object. Let's investigate...
nextline := 0
l:
for {
eol := bytes.IndexByte(data[nextline:], '\n')
switch {
case eol > 0:
line := data[nextline : nextline+eol]
spacepos := bytes.IndexByte(line, ' ')
reftype := line[:spacepos]
switch string(reftype) {
case "tree", "object":
id, err := NewIDFromString(string(line[spacepos+1:]))
if err != nil {
return nil, err
}
commit.Tree.ID = id
case "parent":
// A commit can have one or more parents
oid, err := NewIDFromString(string(line[spacepos+1:]))
if err != nil {
return nil, err
}
commit.parents = append(commit.parents, oid)
case "author", "tagger":
sig, err := newSignatureFromCommitline(line[spacepos+1:])
if err != nil {
return nil, err
}
commit.Author = sig
case "committer":
sig, err := newSignatureFromCommitline(line[spacepos+1:])
if err != nil {
return nil, err
}
commit.Committer = sig
case "gpgsig":
sig, err := newGPGSignatureFromCommitline(data, nextline+spacepos+1, false)
if err != nil {
return nil, err
}
commit.Signature = sig
2016-11-03 17:16:01 -05:00
}
nextline += eol + 1
case eol == 0:
cm := string(data[nextline+1:])
// Tag GPG signatures are stored below the commit message
sigindex := strings.Index(cm, "-----BEGIN PGP SIGNATURE-----")
if sigindex != -1 {
sig, err := newGPGSignatureFromCommitline(data, (nextline+1)+sigindex, true)
if err == nil && sig != nil {
// remove signature from commit message
if sigindex == 0 {
cm = ""
} else {
cm = cm[:sigindex-1]
}
commit.Signature = sig
}
}
commit.CommitMessage = cm
2016-11-03 17:16:01 -05:00
break l
default:
break l
}
}
return commit, nil
}
2016-12-22 04:30:52 -05:00
func (repo *Repository) getCommit(id SHA1) (*Commit, error) {
2016-11-03 17:16:01 -05:00
c, ok := repo.commitCache.Get(id.String())
if ok {
log("Hit cache: %s", id)
return c.(*Commit), nil
}
data, err := NewCommand("cat-file", "-p", id.String()).RunInDirBytes(repo.Path)
if err != nil {
if strings.Contains(err.Error(), "fatal: Not a valid object name") {
return nil, ErrNotExist{id.String(), ""}
}
return nil, err
}
commit, err := parseCommitData(data)
if err != nil {
return nil, err
}
commit.repo = repo
commit.ID = id
data, err = NewCommand("name-rev", id.String()).RunInDirBytes(repo.Path)
if err != nil {
return nil, err
}
// name-rev commitID output will be "COMMIT_ID master" or "COMMIT_ID master~12"
commit.Branch = strings.Split(strings.Split(string(data), " ")[1], "~")[0]
2016-11-03 17:16:01 -05:00
repo.commitCache.Set(id.String(), commit)
return commit, nil
}
// GetCommit returns commit object of by ID string.
func (repo *Repository) GetCommit(commitID string) (*Commit, error) {
if len(commitID) != 40 {
var err error
actualCommitID, err := NewCommand("rev-parse", commitID).RunInDir(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
if strings.Contains(err.Error(), "unknown revision or path") {
return nil, ErrNotExist{commitID, ""}
}
2016-11-03 17:16:01 -05:00
return nil, err
}
commitID = actualCommitID
2016-11-03 17:16:01 -05:00
}
id, err := NewIDFromString(commitID)
if err != nil {
return nil, err
}
return repo.getCommit(id)
}
// GetBranchCommit returns the last commit of given branch.
func (repo *Repository) GetBranchCommit(name string) (*Commit, error) {
commitID, err := repo.GetBranchCommitID(name)
if err != nil {
return nil, err
}
return repo.GetCommit(commitID)
}
2016-12-22 04:30:52 -05:00
// GetTagCommit get the commit of the specific tag via name
2016-11-03 17:16:01 -05:00
func (repo *Repository) GetTagCommit(name string) (*Commit, error) {
commitID, err := repo.GetTagCommitID(name)
if err != nil {
return nil, err
}
return repo.GetCommit(commitID)
}
2016-12-22 04:30:52 -05:00
func (repo *Repository) getCommitByPathWithID(id SHA1, relpath string) (*Commit, error) {
2016-11-03 17:16:01 -05:00
// File name starts with ':' must be escaped.
if relpath[0] == ':' {
relpath = `\` + relpath
}
2016-12-22 04:30:52 -05:00
stdout, err := NewCommand("log", "-1", prettyLogFormat, id.String(), "--", relpath).RunInDir(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
return nil, err
}
id, err = NewIDFromString(stdout)
if err != nil {
return nil, err
}
return repo.getCommit(id)
}
// GetCommitByPath returns the last commit of relative path.
func (repo *Repository) GetCommitByPath(relpath string) (*Commit, error) {
2016-12-22 04:30:52 -05:00
stdout, err := NewCommand("log", "-1", prettyLogFormat, "--", relpath).RunInDirBytes(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
return nil, err
}
commits, err := repo.parsePrettyFormatLogToList(stdout)
if err != nil {
return nil, err
}
return commits.Front().Value.(*Commit), nil
}
2016-12-22 04:30:52 -05:00
// CommitsRangeSize the default commits range size
2016-11-03 17:16:01 -05:00
var CommitsRangeSize = 50
2016-12-22 04:30:52 -05:00
func (repo *Repository) commitsByRange(id SHA1, page int) (*list.List, error) {
2016-11-03 17:16:01 -05:00
stdout, err := NewCommand("log", id.String(), "--skip="+strconv.Itoa((page-1)*CommitsRangeSize),
2016-12-22 04:30:52 -05:00
"--max-count="+strconv.Itoa(CommitsRangeSize), prettyLogFormat).RunInDirBytes(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
return nil, err
}
return repo.parsePrettyFormatLogToList(stdout)
}
func (repo *Repository) searchCommits(id SHA1, opts SearchCommitsOptions) (*list.List, error) {
cmd := NewCommand("log", id.String(), "-100", "-i", prettyLogFormat)
if len(opts.Keywords) > 0 {
for _, v := range opts.Keywords {
cmd.AddArguments("--grep=" + v)
}
}
if len(opts.Authors) > 0 {
for _, v := range opts.Authors {
cmd.AddArguments("--author=" + v)
}
}
if len(opts.Committers) > 0 {
for _, v := range opts.Committers {
cmd.AddArguments("--committer=" + v)
}
}
if len(opts.After) > 0 {
cmd.AddArguments("--after=" + opts.After)
}
if len(opts.Before) > 0 {
cmd.AddArguments("--before=" + opts.Before)
}
if opts.All {
cmd.AddArguments("--all")
}
stdout, err := cmd.RunInDirBytes(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
return nil, err
}
return repo.parsePrettyFormatLogToList(stdout)
}
func (repo *Repository) getFilesChanged(id1 string, id2 string) ([]string, error) {
stdout, err := NewCommand("diff", "--name-only", id1, id2).RunInDirBytes(repo.Path)
if err != nil {
return nil, err
}
return strings.Split(string(stdout), "\n"), nil
}
2016-12-22 04:30:52 -05:00
// FileCommitsCount return the number of files at a revison
2016-11-03 17:16:01 -05:00
func (repo *Repository) FileCommitsCount(revision, file string) (int64, error) {
return commitsCount(repo.Path, revision, file)
}
// CommitsByFileAndRange return the commits according revison file and the page
2016-11-03 17:16:01 -05:00
func (repo *Repository) CommitsByFileAndRange(revision, file string, page int) (*list.List, error) {
stdout, err := NewCommand("log", revision, "--follow", "--skip="+strconv.Itoa((page-1)*50),
2016-12-22 04:30:52 -05:00
"--max-count="+strconv.Itoa(CommitsRangeSize), prettyLogFormat, "--", file).RunInDirBytes(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
return nil, err
}
return repo.parsePrettyFormatLogToList(stdout)
}
2016-12-22 04:30:52 -05:00
// FilesCountBetween return the number of files changed between two commits
2016-11-03 17:16:01 -05:00
func (repo *Repository) FilesCountBetween(startCommitID, endCommitID string) (int, error) {
stdout, err := NewCommand("diff", "--name-only", startCommitID+"..."+endCommitID).RunInDir(repo.Path)
if err != nil {
return 0, err
}
return len(strings.Split(stdout, "\n")) - 1, nil
}
// CommitsBetween returns a list that contains commits between [last, before).
func (repo *Repository) CommitsBetween(last *Commit, before *Commit) (*list.List, error) {
2017-10-23 08:36:14 -05:00
stdout, err := NewCommand("rev-list", before.ID.String()+"..."+last.ID.String()).RunInDirBytes(repo.Path)
if err != nil {
return nil, err
2016-11-03 17:16:01 -05:00
}
2017-10-23 08:36:14 -05:00
return repo.parsePrettyFormatLogToList(bytes.TrimSpace(stdout))
2016-11-03 17:16:01 -05:00
}
2016-12-22 04:30:52 -05:00
// CommitsBetweenIDs return commits between twoe commits
2016-11-03 17:16:01 -05:00
func (repo *Repository) CommitsBetweenIDs(last, before string) (*list.List, error) {
lastCommit, err := repo.GetCommit(last)
if err != nil {
return nil, err
}
beforeCommit, err := repo.GetCommit(before)
if err != nil {
return nil, err
}
return repo.CommitsBetween(lastCommit, beforeCommit)
}
2016-12-22 04:30:52 -05:00
// CommitsCountBetween return numbers of commits between two commits
2016-11-03 17:16:01 -05:00
func (repo *Repository) CommitsCountBetween(start, end string) (int64, error) {
return commitsCount(repo.Path, start+"..."+end, "")
}
2016-12-22 04:30:52 -05:00
// commitsBefore the limit is depth, not total number of returned commits.
2017-12-10 21:23:34 -05:00
func (repo *Repository) commitsBefore(id SHA1, limit int) (*list.List, error) {
cmd := NewCommand("log")
if limit > 0 {
2018-05-27 13:47:34 -05:00
cmd.AddArguments("-"+strconv.Itoa(limit), prettyLogFormat, id.String())
2017-12-10 21:23:34 -05:00
} else {
cmd.AddArguments(prettyLogFormat, id.String())
2016-11-03 17:16:01 -05:00
}
2017-12-10 21:23:34 -05:00
stdout, err := cmd.RunInDirBytes(repo.Path)
2016-11-03 17:16:01 -05:00
if err != nil {
2017-12-10 21:23:34 -05:00
return nil, err
2016-11-03 17:16:01 -05:00
}
2017-12-10 21:23:34 -05:00
formattedLog, err := repo.parsePrettyFormatLogToList(bytes.TrimSpace(stdout))
if err != nil {
return nil, err
2016-11-03 17:16:01 -05:00
}
2017-12-10 21:23:34 -05:00
commits := list.New()
for logEntry := formattedLog.Front(); logEntry != nil; logEntry = logEntry.Next() {
commit := logEntry.Value.(*Commit)
branches, err := repo.getBranches(commit, 2)
2016-11-03 17:16:01 -05:00
if err != nil {
2017-12-10 21:23:34 -05:00
return nil, err
2016-11-03 17:16:01 -05:00
}
2017-12-10 21:23:34 -05:00
if len(branches) > 1 {
break
2016-11-03 17:16:01 -05:00
}
2017-12-10 21:23:34 -05:00
commits.PushBack(commit)
2016-11-03 17:16:01 -05:00
}
2017-12-10 21:23:34 -05:00
return commits, nil
2016-11-03 17:16:01 -05:00
}
2016-12-22 04:30:52 -05:00
func (repo *Repository) getCommitsBefore(id SHA1) (*list.List, error) {
2017-12-10 21:23:34 -05:00
return repo.commitsBefore(id, 0)
2016-11-03 17:16:01 -05:00
}
2016-12-22 04:30:52 -05:00
func (repo *Repository) getCommitsBeforeLimit(id SHA1, num int) (*list.List, error) {
2017-12-10 21:23:34 -05:00
return repo.commitsBefore(id, num)
}
func (repo *Repository) getBranches(commit *Commit, limit int) ([]string, error) {
2018-05-27 13:47:34 -05:00
if version.Compare(gitVersion, "2.7.0", ">=") {
stdout, err := NewCommand("for-each-ref", "--count="+strconv.Itoa(limit), "--format=%(refname:strip=2)", "--contains", commit.ID.String(), BranchPrefix).RunInDir(repo.Path)
if err != nil {
return nil, err
}
branches := strings.Fields(stdout)
return branches, nil
}
stdout, err := NewCommand("branch", "--contains", commit.ID.String()).RunInDir(repo.Path)
2017-12-10 21:23:34 -05:00
if err != nil {
return nil, err
}
refs := strings.Split(stdout, "\n")
2018-05-27 13:47:34 -05:00
var max int
if len(refs) > limit {
max = limit
} else {
max = len(refs) - 1
}
branches := make([]string, max)
for i, ref := range refs[:max] {
parts := strings.Fields(ref)
branches[i] = parts[len(parts)-1]
2017-12-10 21:23:34 -05:00
}
return branches, nil
2016-11-03 17:16:01 -05:00
}