* Replaced list with slice.
* Fixed usage of pointer to temporary variable.
* Replaced LIFO list with slice.
* Lint
* Removed type check.
* Removed duplicated code.
* Lint
* Fixed merge.
Co-authored-by: 6543 <6543@obermui.de>
--- /dev/null
+// Copyright 2021 Gitea. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package models
+
+import (
+ "code.gitea.io/gitea/modules/git"
+)
+
+// ConvertFromGitCommit converts git commits into SignCommitWithStatuses
+func ConvertFromGitCommit(commits []*git.Commit, repo *Repository) []*SignCommitWithStatuses {
+ return ParseCommitsWithStatus(
+ ParseCommitsWithSignature(
+ ValidateCommitsWithEmails(commits),
+ repo,
+ ),
+ repo,
+ )
+}
package models
import (
- "container/list"
"crypto/sha1"
"fmt"
"strings"
}
// ParseCommitsWithStatus checks commits latest statuses and calculates its worst status state
-func ParseCommitsWithStatus(oldCommits *list.List, repo *Repository) *list.List {
- var (
- newCommits = list.New()
- e = oldCommits.Front()
- )
-
- for e != nil {
- c := e.Value.(SignCommit)
- commit := SignCommitWithStatuses{
- SignCommit: &c,
+func ParseCommitsWithStatus(oldCommits []*SignCommit, repo *Repository) []*SignCommitWithStatuses {
+ newCommits := make([]*SignCommitWithStatuses, 0, len(oldCommits))
+
+ for _, c := range oldCommits {
+ commit := &SignCommitWithStatuses{
+ SignCommit: c,
}
statuses, err := GetLatestCommitStatus(repo.ID, commit.ID.String(), ListOptions{})
if err != nil {
commit.Status = CalcCommitStatus(statuses)
}
- newCommits.PushBack(commit)
- e = e.Next()
+ newCommits = append(newCommits, commit)
}
return newCommits
}
package models
import (
- "container/list"
"fmt"
"hash"
"strings"
)
// ParseCommitsWithSignature checks if signaute of commits are corresponding to users gpg keys.
-func ParseCommitsWithSignature(oldCommits *list.List, repository *Repository) *list.List {
- var (
- newCommits = list.New()
- e = oldCommits.Front()
- )
+func ParseCommitsWithSignature(oldCommits []*UserCommit, repository *Repository) []*SignCommit {
+ newCommits := make([]*SignCommit, 0, len(oldCommits))
keyMap := map[string]bool{}
- for e != nil {
- c := e.Value.(UserCommit)
- signCommit := SignCommit{
- UserCommit: &c,
+ for _, c := range oldCommits {
+ signCommit := &SignCommit{
+ UserCommit: c,
Verification: ParseCommitWithSignature(c.Commit),
}
_ = CalculateTrustStatus(signCommit.Verification, repository, &keyMap)
- newCommits.PushBack(signCommit)
- e = e.Next()
+ newCommits = append(newCommits, signCommit)
}
return newCommits
}
package models
import (
- "container/list"
"fmt"
"regexp"
"strconv"
RefIssue *Issue `xorm:"-"`
RefComment *Comment `xorm:"-"`
- Commits *list.List `xorm:"-"`
- OldCommit string `xorm:"-"`
- NewCommit string `xorm:"-"`
- CommitsNum int64 `xorm:"-"`
- IsForcePush bool `xorm:"-"`
+ Commits []*SignCommitWithStatuses `xorm:"-"`
+ OldCommit string `xorm:"-"`
+ NewCommit string `xorm:"-"`
+ CommitsNum int64 `xorm:"-"`
+ IsForcePush bool `xorm:"-"`
}
// PushActionContent is content of push pull comment
}
defer gitRepo.Close()
- c.Commits = gitRepo.GetCommitsFromIDs(data.CommitIDs)
- c.CommitsNum = int64(c.Commits.Len())
- if c.CommitsNum > 0 {
- c.Commits = ValidateCommitsWithEmails(c.Commits)
- c.Commits = ParseCommitsWithSignature(c.Commits, c.Issue.Repo)
- c.Commits = ParseCommitsWithStatus(c.Commits, c.Issue.Repo)
- }
+ c.Commits = ConvertFromGitCommit(gitRepo.GetCommitsFromIDs(data.CommitIDs), c.Issue.Repo)
+ c.CommitsNum = int64(len(c.Commits))
}
return err
return nil, false, err
}
- var (
- commits *list.List
- commitChecks map[string]commitBranchCheckItem
- )
- commits, err = newCommit.CommitsBeforeUntil(oldCommitID)
+ commits, err := newCommit.CommitsBeforeUntil(oldCommitID)
if err != nil {
return nil, false, err
}
- commitIDs = make([]string, 0, commits.Len())
- commitChecks = make(map[string]commitBranchCheckItem)
+ commitIDs = make([]string, 0, len(commits))
+ commitChecks := make(map[string]*commitBranchCheckItem)
- for e := commits.Front(); e != nil; e = e.Next() {
- commitChecks[e.Value.(*git.Commit).ID.String()] = commitBranchCheckItem{
- Commit: e.Value.(*git.Commit),
+ for _, commit := range commits {
+ commitChecks[commit.ID.String()] = &commitBranchCheckItem{
+ Commit: commit,
Checked: false,
}
}
return
}
- for e := commits.Back(); e != nil; e = e.Prev() {
- commitID := e.Value.(*git.Commit).ID.String()
+ for i := len(commits) - 1; i >= 0; i-- {
+ commitID := commits[i].ID.String()
if item, ok := commitChecks[commitID]; ok && item.Checked {
commitIDs = append(commitIDs, commitID)
}
Checked bool
}
-func commitBranchCheck(gitRepo *git.Repository, startCommit *git.Commit, endCommitID, baseBranch string, commitList map[string]commitBranchCheckItem) (err error) {
- var (
- item commitBranchCheckItem
- ok bool
- listItem *list.Element
- tmp string
- )
-
+func commitBranchCheck(gitRepo *git.Repository, startCommit *git.Commit, endCommitID, baseBranch string, commitList map[string]*commitBranchCheckItem) error {
if startCommit.ID.String() == endCommitID {
- return
+ return nil
}
- checkStack := list.New()
- checkStack.PushBack(startCommit.ID.String())
- listItem = checkStack.Back()
+ checkStack := make([]string, 0, 10)
+ checkStack = append(checkStack, startCommit.ID.String())
- for listItem != nil {
- tmp = listItem.Value.(string)
- checkStack.Remove(listItem)
+ for len(checkStack) > 0 {
+ commitID := checkStack[0]
+ checkStack = checkStack[1:]
- if item, ok = commitList[tmp]; !ok {
- listItem = checkStack.Back()
+ item, ok := commitList[commitID]
+ if !ok {
continue
}
if item.Commit.ID.String() == endCommitID {
- listItem = checkStack.Back()
continue
}
- if err = item.Commit.LoadBranchName(); err != nil {
- return
+ if err := item.Commit.LoadBranchName(); err != nil {
+ return err
}
if item.Commit.Branch == baseBranch {
- listItem = checkStack.Back()
continue
}
if item.Checked {
- listItem = checkStack.Back()
continue
}
item.Checked = true
- commitList[tmp] = item
parentNum := item.Commit.ParentCount()
for i := 0; i < parentNum; i++ {
- var parentCommit *git.Commit
- parentCommit, err = item.Commit.Parent(i)
+ parentCommit, err := item.Commit.Parent(i)
if err != nil {
- return
+ return err
}
- checkStack.PushBack(parentCommit.ID.String())
+ checkStack = append(checkStack, parentCommit.ID.String())
}
-
- listItem = checkStack.Back()
}
return nil
}
if err != nil {
return false, "", nil, err
}
- for e := commitList.Front(); e != nil; e = e.Next() {
- commit = e.Value.(*git.Commit)
+ for _, commit := range commitList {
verification := ParseCommitWithSignature(commit)
if !verification.Verified {
return false, "", nil, &ErrWontSign{commitsSigned}
package models
import (
- "container/list"
"context"
"crypto/sha256"
"crypto/subtle"
}
// ValidateCommitsWithEmails checks if authors' e-mails of commits are corresponding to users.
-func ValidateCommitsWithEmails(oldCommits *list.List) *list.List {
+func ValidateCommitsWithEmails(oldCommits []*git.Commit) []*UserCommit {
var (
- u *User
- emails = map[string]*User{}
- newCommits = list.New()
- e = oldCommits.Front()
+ emails = make(map[string]*User)
+ newCommits = make([]*UserCommit, 0, len(oldCommits))
)
- for e != nil {
- c := e.Value.(*git.Commit)
-
+ for _, c := range oldCommits {
+ var u *User
if c.Author != nil {
if v, ok := emails[c.Author.Email]; !ok {
u, _ = GetUserByEmail(c.Author.Email)
} else {
u = v
}
- } else {
- u = nil
}
- newCommits.PushBack(UserCommit{
+ newCommits = append(newCommits, &UserCommit{
User: u,
Commit: c,
})
- e = e.Next()
}
return newCommits
}
import (
"bufio"
"bytes"
- "container/list"
"errors"
"fmt"
"io"
}
// CommitsByRange returns the specific page commits before current revision, every page's number default by CommitsRangeSize
-func (c *Commit) CommitsByRange(page, pageSize int) (*list.List, error) {
+func (c *Commit) CommitsByRange(page, pageSize int) ([]*Commit, error) {
return c.repo.commitsByRange(c.ID, page, pageSize)
}
// CommitsBefore returns all the commits before current revision
-func (c *Commit) CommitsBefore() (*list.List, error) {
+func (c *Commit) CommitsBefore() ([]*Commit, error) {
return c.repo.getCommitsBefore(c.ID)
}
}
// CommitsBeforeLimit returns num commits before current revision
-func (c *Commit) CommitsBeforeLimit(num int) (*list.List, error) {
+func (c *Commit) CommitsBeforeLimit(num int) ([]*Commit, error) {
return c.repo.getCommitsBeforeLimit(c.ID, num)
}
// CommitsBeforeUntil returns the commits between commitID to current revision
-func (c *Commit) CommitsBeforeUntil(commitID string) (*list.List, error) {
+func (c *Commit) CommitsBeforeUntil(commitID string) ([]*Commit, error) {
endCommit, err := c.repo.GetCommit(commitID)
if err != nil {
return nil, err
}
// SearchCommits returns the commits match the keyword before current revision
-func (c *Commit) SearchCommits(opts SearchCommitsOptions) (*list.List, error) {
+func (c *Commit) SearchCommits(opts SearchCommitsOptions) ([]*Commit, error) {
return c.repo.searchCommits(c.ID, opts)
}
import (
"bytes"
- "container/list"
"context"
"fmt"
"os"
return AllCommitsCount(repo.Path, false)
}
-func (repo *Repository) parsePrettyFormatLogToList(logs []byte) (*list.List, error) {
- l := list.New()
+func (repo *Repository) parsePrettyFormatLogToList(logs []byte) ([]*Commit, error) {
+ var commits []*Commit
if len(logs) == 0 {
- return l, nil
+ return commits, nil
}
parts := bytes.Split(logs, []byte{'\n'})
if err != nil {
return nil, err
}
- l.PushBack(commit)
+ commits = append(commits, commit)
}
- return l, nil
+ return commits, nil
}
// IsRepoURLAccessible checks if given repository URL is accessible.
import (
"bytes"
- "container/list"
"io"
"io/ioutil"
"strconv"
if err != nil {
return nil, err
}
- return commits.Front().Value.(*Commit), nil
+ return commits[0], nil
}
-func (repo *Repository) commitsByRange(id SHA1, page, pageSize int) (*list.List, error) {
+func (repo *Repository) commitsByRange(id SHA1, page, pageSize int) ([]*Commit, error) {
stdout, err := NewCommand("log", id.String(), "--skip="+strconv.Itoa((page-1)*pageSize),
"--max-count="+strconv.Itoa(pageSize), prettyLogFormat).RunInDirBytes(repo.Path)
return repo.parsePrettyFormatLogToList(stdout)
}
-func (repo *Repository) searchCommits(id SHA1, opts SearchCommitsOptions) (*list.List, error) {
+func (repo *Repository) searchCommits(id SHA1, opts SearchCommitsOptions) ([]*Commit, error) {
// create new git log command with limit of 100 commis
cmd := NewCommand("log", id.String(), "-100", prettyLogFormat)
// ignore case
}
// CommitsByFileAndRange return the commits according revision file and the page
-func (repo *Repository) CommitsByFileAndRange(revision, file string, page int) (*list.List, error) {
+func (repo *Repository) CommitsByFileAndRange(revision, file string, page int) ([]*Commit, error) {
skip := (page - 1) * setting.Git.CommitsRangeSize
stdoutReader, stdoutWriter := io.Pipe()
_, err := io.CopyN(ioutil.Discard, stdoutReader, int64(skip*41))
if err != nil {
if err == io.EOF {
- return list.New(), nil
+ return []*Commit{}, nil
}
_ = stdoutReader.CloseWithError(err)
return nil, err
}
// CommitsByFileAndRangeNoFollow return the commits according revision file and the page
-func (repo *Repository) CommitsByFileAndRangeNoFollow(revision, file string, page int) (*list.List, error) {
+func (repo *Repository) CommitsByFileAndRangeNoFollow(revision, file string, page int) ([]*Commit, error) {
stdout, err := NewCommand("log", revision, "--skip="+strconv.Itoa((page-1)*50),
"--max-count="+strconv.Itoa(setting.Git.CommitsRangeSize), prettyLogFormat, "--", file).RunInDirBytes(repo.Path)
if err != nil {
// CommitsBetween returns a list that contains commits between [before, last).
// If before is detached (removed by reset + push) it is not included.
-func (repo *Repository) CommitsBetween(last *Commit, before *Commit) (*list.List, error) {
+func (repo *Repository) CommitsBetween(last *Commit, before *Commit) ([]*Commit, error) {
var stdout []byte
var err error
if before == nil {
}
// CommitsBetweenLimit returns a list that contains at most limit commits skipping the first skip commits between [before, last)
-func (repo *Repository) CommitsBetweenLimit(last *Commit, before *Commit, limit, skip int) (*list.List, error) {
+func (repo *Repository) CommitsBetweenLimit(last *Commit, before *Commit, limit, skip int) ([]*Commit, error) {
var stdout []byte
var err error
if before == nil {
}
// CommitsBetweenIDs return commits between twoe commits
-func (repo *Repository) CommitsBetweenIDs(last, before string) (*list.List, error) {
+func (repo *Repository) CommitsBetweenIDs(last, before string) ([]*Commit, error) {
lastCommit, err := repo.GetCommit(last)
if err != nil {
return nil, err
}
// commitsBefore the limit is depth, not total number of returned commits.
-func (repo *Repository) commitsBefore(id SHA1, limit int) (*list.List, error) {
+func (repo *Repository) commitsBefore(id SHA1, limit int) ([]*Commit, error) {
cmd := NewCommand("log")
if limit > 0 {
cmd.AddArguments("-"+strconv.Itoa(limit), prettyLogFormat, id.String())
return nil, err
}
- commits := list.New()
- for logEntry := formattedLog.Front(); logEntry != nil; logEntry = logEntry.Next() {
- commit := logEntry.Value.(*Commit)
+ commits := make([]*Commit, 0, len(formattedLog))
+ for _, commit := range formattedLog {
branches, err := repo.getBranches(commit, 2)
if err != nil {
return nil, err
break
}
- commits.PushBack(commit)
+ commits = append(commits, commit)
}
return commits, nil
}
-func (repo *Repository) getCommitsBefore(id SHA1) (*list.List, error) {
+func (repo *Repository) getCommitsBefore(id SHA1) ([]*Commit, error) {
return repo.commitsBefore(id, 0)
}
-func (repo *Repository) getCommitsBeforeLimit(id SHA1, num int) (*list.List, error) {
+func (repo *Repository) getCommitsBeforeLimit(id SHA1, num int) ([]*Commit, error) {
return repo.commitsBefore(id, num)
}
}
// GetCommitsFromIDs get commits from commit IDs
-func (repo *Repository) GetCommitsFromIDs(commitIDs []string) (commits *list.List) {
- commits = list.New()
+func (repo *Repository) GetCommitsFromIDs(commitIDs []string) []*Commit {
+ commits := make([]*Commit, 0, len(commitIDs))
for _, commitID := range commitIDs {
commit, err := repo.GetCommit(commitID)
if err == nil && commit != nil {
- commits.PushBack(commit)
+ commits = append(commits, commit)
}
}
for i, c := range cases {
commits, err := bareRepo1.CommitsBetweenIDs(c.NewID, c.OldID)
assert.NoError(t, err)
- assert.Equal(t, c.ExpectedCommits, commits.Len(), "case %d", i)
+ assert.Equal(t, c.ExpectedCommits, len(commits), "case %d", i)
}
}
import (
"bytes"
- "container/list"
"fmt"
"io"
"regexp"
MergeBase string
BaseCommitID string
HeadCommitID string
- Commits *list.List
+ Commits []*Commit
NumFiles int
}
return nil, fmt.Errorf("parsePrettyFormatLogToList: %v", err)
}
} else {
- compareInfo.Commits = list.New()
+ compareInfo.Commits = []*Commit{}
compareInfo.MergeBase, err = GetFullCommitID(repo.Path, remoteBranch)
if err != nil {
compareInfo.MergeBase = remoteBranch
package repository
import (
- "container/list"
"fmt"
"time"
}
}
-// ListToPushCommits transforms a list.List to PushCommits type.
-func ListToPushCommits(l *list.List) *PushCommits {
- var commits []*PushCommit
- for e := l.Front(); e != nil; e = e.Next() {
- commit := CommitToPushCommit(e.Value.(*git.Commit))
- commits = append(commits, commit)
+// GitToPushCommits transforms a list of git.Commits to PushCommits type.
+func GitToPushCommits(gitCommits []*git.Commit) *PushCommits {
+ commits := make([]*PushCommit, 0, len(gitCommits))
+ for _, commit := range gitCommits {
+ commits = append(commits, CommitToPushCommit(commit))
}
return &PushCommits{commits, nil, "", make(map[string]string), make(map[string]*models.User)}
}
package repository
import (
- "container/list"
"crypto/md5"
"fmt"
"testing"
hash2, err := git.NewIDFromString(hexString2)
assert.NoError(t, err)
- l := list.New()
- l.PushBack(&git.Commit{
- ID: hash1,
- Author: sig,
- Committer: sig,
- CommitMessage: "Message1",
- })
- l.PushBack(&git.Commit{
- ID: hash2,
- Author: sig,
- Committer: sig,
- CommitMessage: "Message2",
- })
+ l := []*git.Commit{
+ {
+ ID: hash1,
+ Author: sig,
+ Committer: sig,
+ CommitMessage: "Message1",
+ },
+ {
+ ID: hash2,
+ Author: sig,
+ Committer: sig,
+ CommitMessage: "Message2",
+ },
+ }
- pushCommits := ListToPushCommits(l)
+ pushCommits := GitToPushCommits(l)
if assert.Len(t, pushCommits.Commits, 2) {
assert.Equal(t, "Message1", pushCommits.Commits[0].Message)
assert.Equal(t, hexString1, pushCommits.Commits[0].Sha1)
import (
"bytes"
- "container/list"
"errors"
"fmt"
"html"
},
"SizeFmt": base.FileSize,
"CountFmt": base.FormatNumberSI,
- "List": List,
"SubStr": func(str string, start, length int) string {
if len(str) == 0 {
return ""
},
"CommentMustAsDiff": gitdiff.CommentMustAsDiff,
"MirrorRemoteAddress": mirrorRemoteAddress,
- "CommitType": func(commit interface{}) string {
- switch commit.(type) {
- case models.SignCommitWithStatuses:
- return "SignCommitWithStatuses"
- case models.SignCommit:
- return "SignCommit"
- case models.UserCommit:
- return "UserCommit"
- default:
- return ""
- }
- },
"NotificationSettings": func() map[string]interface{} {
return map[string]interface{}{
"MinTimeout": int(setting.UI.Notification.MinTimeout / time.Millisecond),
"DateFmtShort": func(t time.Time) string {
return t.Format("Jan 02, 2006")
},
- "List": List,
"SubStr": func(str string, start, length int) string {
if len(str) == 0 {
return ""
return template.JSEscapeString(raw)
}
-// List traversings the list
-func List(l *list.List) chan interface{} {
- e := l.Front()
- c := make(chan interface{})
- go func() {
- for e != nil {
- c <- e.Value
- e = e.Next()
- }
- close(c)
- }()
- return c
-}
-
// Sha1 returns sha1 sum of string
func Sha1(str string) string {
return base.EncodeSha1(str)
userCache := make(map[string]*models.User)
- apiCommits := make([]*api.Commit, commits.Len())
-
- i := 0
- for commitPointer := commits.Front(); commitPointer != nil; commitPointer = commitPointer.Next() {
- commit := commitPointer.Value.(*git.Commit)
-
+ apiCommits := make([]*api.Commit, len(commits))
+ for i, commit := range commits {
// Create json struct
apiCommits[i], err = convert.ToCommit(ctx.Repo.Repository, commit, userCache)
if err != nil {
ctx.Error(http.StatusInternalServerError, "toCommit", err)
return
}
-
- i++
}
// kept for backwards compatibility
listOptions := utils.GetListOptions(ctx)
- totalNumberOfCommits := commits.Len()
+ totalNumberOfCommits := len(commits)
totalNumberOfPages := int(math.Ceil(float64(totalNumberOfCommits) / float64(listOptions.PageSize)))
userCache := make(map[string]*models.User)
end = totalNumberOfCommits
}
- apiCommits := make([]*api.Commit, end-start)
-
- i := 0
- addedCommitsCount := 0
- for commitPointer := commits.Front(); commitPointer != nil; commitPointer = commitPointer.Next() {
- if i < start {
- i++
- continue
- }
- if i >= end {
- break
- }
-
- commit := commitPointer.Value.(*git.Commit)
-
- // Create json struct
- apiCommits[addedCommitsCount], err = convert.ToCommit(ctx.Repo.Repository, commit, userCache)
- addedCommitsCount++
+ apiCommits := make([]*api.Commit, 0, end-start)
+ for i := start; i < end; i++ {
+ apiCommit, err := convert.ToCommit(ctx.Repo.Repository, commits[i], userCache)
if err != nil {
ctx.ServerError("toCommit", err)
return
}
- i++
+ apiCommits = append(apiCommits, apiCommit)
}
ctx.SetLinkHeader(int(totalNumberOfCommits), listOptions.PageSize)
package repo
import (
- "container/list"
"fmt"
"html"
gotemplate "html/template"
ctx.HTML(http.StatusOK, tplBlame)
}
-func processBlameParts(ctx *context.Context, blameParts []git.BlamePart) (map[string]models.UserCommit, map[string]string) {
+func processBlameParts(ctx *context.Context, blameParts []git.BlamePart) (map[string]*models.UserCommit, map[string]string) {
// store commit data by SHA to look up avatar info etc
- commitNames := make(map[string]models.UserCommit)
+ commitNames := make(map[string]*models.UserCommit)
// previousCommits contains links from SHA to parent SHA,
// if parent also contains the current TreePath.
previousCommits := make(map[string]string)
// and as blameParts can reference the same commits multiple
// times, we cache the lookup work locally
- commits := list.New()
+ commits := make([]*git.Commit, 0, len(blameParts))
commitCache := map[string]*git.Commit{}
commitCache[ctx.Repo.Commit.ID.String()] = ctx.Repo.Commit
}
}
- commits.PushBack(commit)
-
- commitNames[commit.ID.String()] = models.UserCommit{}
+ commits = append(commits, commit)
}
// populate commit email addresses to later look up avatars.
- commits = models.ValidateCommitsWithEmails(commits)
- for e := commits.Front(); e != nil; e = e.Next() {
- c := e.Value.(models.UserCommit)
+ for _, c := range models.ValidateCommitsWithEmails(commits) {
commitNames[c.ID.String()] = c
}
return commitNames, previousCommits
}
-func renderBlame(ctx *context.Context, blameParts []git.BlamePart, commitNames map[string]models.UserCommit, previousCommits map[string]string) {
+func renderBlame(ctx *context.Context, blameParts []git.BlamePart, commitNames map[string]*models.UserCommit, previousCommits map[string]string) {
repoLink := ctx.Repo.RepoLink
var lines = make([]string, 0)
ctx.ServerError("CommitsByRange", err)
return
}
- commits = models.ValidateCommitsWithEmails(commits)
- commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
- commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
- ctx.Data["Commits"] = commits
+ ctx.Data["Commits"] = models.ConvertFromGitCommit(commits, ctx.Repo.Repository)
ctx.Data["Username"] = ctx.Repo.Owner.Name
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
ctx.ServerError("SearchCommits", err)
return
}
- commits = models.ValidateCommitsWithEmails(commits)
- commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
- commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
- ctx.Data["Commits"] = commits
+ ctx.Data["CommitCount"] = len(commits)
+ ctx.Data["Commits"] = models.ConvertFromGitCommit(commits, ctx.Repo.Repository)
ctx.Data["Keyword"] = query
if all {
}
ctx.Data["Username"] = ctx.Repo.Owner.Name
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
- ctx.Data["CommitCount"] = commits.Len()
ctx.Data["Branch"] = ctx.Repo.BranchName
ctx.HTML(http.StatusOK, tplCommits)
}
ctx.ServerError("CommitsByFileAndRange", err)
return
}
- commits = models.ValidateCommitsWithEmails(commits)
- commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
- commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
- ctx.Data["Commits"] = commits
+ ctx.Data["Commits"] = models.ConvertFromGitCommit(commits, ctx.Repo.Repository)
ctx.Data["Username"] = ctx.Repo.Owner.Name
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
return false
}
- compareInfo.Commits = models.ValidateCommitsWithEmails(compareInfo.Commits)
- compareInfo.Commits = models.ParseCommitsWithSignature(compareInfo.Commits, headRepo)
- compareInfo.Commits = models.ParseCommitsWithStatus(compareInfo.Commits, headRepo)
- ctx.Data["Commits"] = compareInfo.Commits
- ctx.Data["CommitCount"] = compareInfo.Commits.Len()
-
- if compareInfo.Commits.Len() == 1 {
- c := compareInfo.Commits.Front().Value.(models.SignCommitWithStatuses)
+ commits := models.ConvertFromGitCommit(compareInfo.Commits, headRepo)
+ ctx.Data["Commits"] = commits
+ ctx.Data["CommitCount"] = len(commits)
+
+ if len(commits) == 1 {
+ c := commits[0]
title = strings.TrimSpace(c.UserCommit.Summary())
body := strings.Split(strings.TrimSpace(c.UserCommit.Message()), "\n")
package repo
import (
- "container/list"
"crypto/subtle"
"errors"
"fmt"
ctx.ServerError("GetCompareInfo", err)
return nil
}
- ctx.Data["NumCommits"] = compareInfo.Commits.Len()
+ ctx.Data["NumCommits"] = len(compareInfo.Commits)
ctx.Data["NumFiles"] = compareInfo.NumFiles
- if compareInfo.Commits.Len() != 0 {
- sha := compareInfo.Commits.Front().Value.(*git.Commit).ID.String()
+ if len(compareInfo.Commits) != 0 {
+ sha := compareInfo.Commits[0].ID.String()
commitStatuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, sha, models.ListOptions{})
if err != nil {
ctx.ServerError("GetLatestCommitStatus", err)
return nil
}
- ctx.Data["NumCommits"] = compareInfo.Commits.Len()
+ ctx.Data["NumCommits"] = len(compareInfo.Commits)
ctx.Data["NumFiles"] = compareInfo.NumFiles
return compareInfo
}
ctx.Data["ConflictedFiles"] = pull.ConflictedFiles
}
- ctx.Data["NumCommits"] = compareInfo.Commits.Len()
+ ctx.Data["NumCommits"] = len(compareInfo.Commits)
ctx.Data["NumFiles"] = compareInfo.NumFiles
return compareInfo
}
}
pull := issue.PullRequest
- var commits *list.List
var prInfo *git.CompareInfo
if pull.HasMerged {
prInfo = PrepareMergedViewPullInfo(ctx, issue)
ctx.Data["Username"] = ctx.Repo.Owner.Name
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
- commits = prInfo.Commits
- commits = models.ValidateCommitsWithEmails(commits)
- commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
- commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
+
+ commits := models.ConvertFromGitCommit(prInfo.Commits, ctx.Repo.Repository)
ctx.Data["Commits"] = commits
- ctx.Data["CommitCount"] = commits.Len()
+ ctx.Data["CommitCount"] = len(commits)
getBranchData(ctx, issue)
ctx.HTML(http.StatusOK, tplPullCommits)
ctx.ServerError("CommitsByFileAndRangeNoFollow", err)
return nil, nil
}
- commitsHistory = models.ValidateCommitsWithEmails(commitsHistory)
- commitsHistory = models.ParseCommitsWithSignature(commitsHistory, ctx.Repo.Repository)
-
- ctx.Data["Commits"] = commitsHistory
+ ctx.Data["Commits"] = models.ConvertFromGitCommit(commitsHistory, ctx.Repo.Repository)
pager := context.NewPagination(int(commitsCount), setting.Git.CommitsRangeSize, page, 5)
pager.SetDefaultParams(ctx)
continue
}
- theCommits := repo_module.ListToPushCommits(commits)
+ theCommits := repo_module.GitToPushCommits(commits)
if len(theCommits.Commits) > setting.UI.FeedMaxCommitNum {
theCommits.Commits = theCommits.Commits[:setting.UI.FeedMaxCommitNum]
}
return err
}
- if compareInfo.Commits.Len() > 0 {
+ if len(compareInfo.Commits) > 0 {
data := models.PushActionContent{IsForcePush: false}
- data.CommitIDs = make([]string, 0, compareInfo.Commits.Len())
- for e := compareInfo.Commits.Back(); e != nil; e = e.Prev() {
- data.CommitIDs = append(data.CommitIDs, e.Value.(*git.Commit).ID.String())
+ data.CommitIDs = make([]string, 0, len(compareInfo.Commits))
+ for i := len(compareInfo.Commits) - 1; i >= 0; i-- {
+ data.CommitIDs = append(data.CommitIDs, compareInfo.Commits[i].ID.String())
}
dataJSON, err := json.Marshal(data)
limit := setting.Repository.PullRequest.DefaultMergeMessageCommitsLimit
- list, err := gitRepo.CommitsBetweenLimit(headCommit, mergeBase, limit, 0)
+ commits, err := gitRepo.CommitsBetweenLimit(headCommit, mergeBase, limit, 0)
if err != nil {
log.Error("Unable to get commits between: %s %s Error: %v", pr.HeadBranch, pr.MergeBase, err)
return ""
posterSig := pr.Issue.Poster.NewGitSig().String()
authorsMap := map[string]bool{}
- authors := make([]string, 0, list.Len())
+ authors := make([]string, 0, len(commits))
stringBuilder := strings.Builder{}
if !setting.Repository.PullRequest.PopulateSquashCommentWithCommitMessages {
}
// commits list is in reverse chronological order
- element := list.Back()
- for element != nil {
- commit := element.Value.(*git.Commit)
+ first := true
+ for i := len(commits) - 1; i >= 0; i-- {
+ commit := commits[i]
if setting.Repository.PullRequest.PopulateSquashCommentWithCommitMessages {
maxSize := setting.Repository.PullRequest.DefaultMergeMessageSize
if maxSize < 0 || stringBuilder.Len() < maxSize {
var toWrite []byte
- if element == list.Back() {
+ if first {
+ first = false
toWrite = []byte(strings.TrimPrefix(commit.CommitMessage, pr.Issue.Title))
} else {
toWrite = []byte(commit.CommitMessage)
authors = append(authors, authorString)
authorsMap[authorString] = true
}
- element = element.Prev()
}
// Consider collecting the remaining authors
skip := limit
limit = 30
for {
- list, err := gitRepo.CommitsBetweenLimit(headCommit, mergeBase, limit, skip)
+ commits, err := gitRepo.CommitsBetweenLimit(headCommit, mergeBase, limit, skip)
if err != nil {
log.Error("Unable to get commits between: %s %s Error: %v", pr.HeadBranch, pr.MergeBase, err)
return ""
}
- if list.Len() == 0 {
+ if len(commits) == 0 {
break
}
- element := list.Front()
- for element != nil {
- commit := element.Value.(*git.Commit)
-
+ for _, commit := range commits {
authorString := commit.Author.String()
if !authorsMap[authorString] && authorString != posterSig {
authors = append(authors, authorString)
authorsMap[authorString] = true
}
- element = element.Next()
}
skip += limit
}
package repository
import (
- "container/list"
"fmt"
"time"
refName := opts.RefName()
// Push new branch.
- var l *list.List
+ var l []*git.Commit
if opts.IsNewRef() {
if repo.IsEmpty { // Change default branch and empty status only if pushed ref is non-empty branch.
repo.DefaultBranch = refName
}
}
- commits := repo_module.ListToPushCommits(l)
+ commits := repo_module.GitToPushCommits(l)
commits.HeadCommit = repo_module.CommitToPushCommit(newCommit)
if err := repofiles.UpdateIssuesCommit(pusher, repo, commits.Commits, refName); err != nil {
{{.i18n.Tr "mail.issue.action.force_push" .Doer.Name .Comment.Issue.PullRequest.HeadBranch $oldCommitLink $newCommitLink | Str2html}}
{{else}}
- {{.i18n.Tr (TrN .i18n.Lang .Comment.Commits.Len "mail.issue.action.push_1" "mail.issue.action.push_n") .Doer.Name .Comment.Issue.PullRequest.HeadBranch .Comment.Commits.Len | Str2html}}
+ {{.i18n.Tr (TrN .i18n.Lang (len .Comment.Commits) "mail.issue.action.push_1" "mail.issue.action.push_n") .Doer.Name .Comment.Issue.PullRequest.HeadBranch (len .Comment.Commits) | Str2html}}
{{end}}
</p>
{{end}}
</div>
{{end -}}
{{if eq .ActionName "push"}}
- {{ $r:= List .Comment.Commits}}
<ul>
- {{range $r}}
+ {{range .Comment.Commits}}
<li>
<a href="{{AppUrl}}{{$.Comment.Issue.PullRequest.BaseRepo.OwnerName}}/{{$.Comment.Issue.PullRequest.BaseRepo.Name}}/commit/{{.ID}}">
{{ShortSha .ID.String}}
</tr>
</thead>
<tbody class="commit-list">
- {{ $r:= List .Commits}}
- {{range $r}}
+ {{range .Commits}}
<tr>
<td class="author">
{{$userName := .Author.Name}}
{{if IsMultilineCommitMessage .Message}}
<button class="basic compact mini ui icon button commit-button"><i class="ellipsis horizontal icon"></i></button>
{{end}}
- {{if eq (CommitType .) "SignCommitWithStatuses"}}
- {{template "repo/commit_statuses" dict "Status" .Status "Statuses" .Statuses "root" $}}
- {{end}}
+ {{template "repo/commit_statuses" dict "Status" .Status "Statuses" .Statuses "root" $}}
{{if IsMultilineCommitMessage .Message}}
<pre class="commit-body" style="display: none;">{{RenderCommitBody .Message $.RepoLink $.Repository.ComposeMetas}}</pre>
{{end}}
-{{ $r:= List .comment.Commits}}
{{ $index := 0}}
<div class="timeline-item commits-list">
-{{range $r}}
+{{range .comment.Commits}}
{{ $tag := printf "%s-%d" $.comment.HashTag $index }}
{{ $index = Add $index 1}}
<div class="singular-commit" id="{{$tag}}">
{{end}}
<span class="ui float right shabox">
- {{if eq (CommitType .) "SignCommitWithStatuses"}}
- {{template "repo/commit_statuses" dict "Status" .Status "Statuses" .Statuses "root" $.root}}
- {{end}}
+ {{template "repo/commit_statuses" dict "Status" .Status "Statuses" .Statuses "root" $.root}}
{{$class := "ui sha label"}}
{{if .Signature}}
{{$class = (printf "%s%s" $class " isSigned")}}
{{ if .IsForcePush }}
{{$.i18n.Tr "repo.issues.force_push_codes" $.Issue.PullRequest.HeadBranch (ShortSha .OldCommit) ($.Issue.Repo.CommitLink .OldCommit) (ShortSha .NewCommit) ($.Issue.Repo.CommitLink .NewCommit) $createdStr | Safe}}
{{else}}
- {{$.i18n.Tr (TrN $.i18n.Lang .Commits.Len "repo.issues.push_commit_1" "repo.issues.push_commits_n") .Commits.Len $createdStr | Safe}}
+ {{$.i18n.Tr (TrN $.i18n.Lang (len .Commits) "repo.issues.push_commit_1" "repo.issues.push_commits_n") (len .Commits) $createdStr | Safe}}
{{end}}
</span>
</div>
<ul>
{{ $push := ActionContent2Commits .}}
{{ $repoLink := .GetRepoLink}}
- {{if $push.Commits}}
- {{range $push.Commits}}
- {{ $commitLink := printf "%s/commit/%s" $repoLink .Sha1}}
- <li>
- {{avatarHTML ($push.AvatarLink .AuthorEmail) 16 "mr-2" .AuthorName}}
- <a class="commit-id mr-2" href="{{$commitLink}}">{{ShortSha .Sha1}}</a>
- <span class="text truncate light grey">
- {{RenderCommitMessage .Message $repoLink $.ComposeMetas}}
- </span>
- </li>
- {{end}}
+ {{range $push.Commits}}
+ {{ $commitLink := printf "%s/commit/%s" $repoLink .Sha1}}
+ <li>
+ {{avatarHTML ($push.AvatarLink .AuthorEmail) 16 "mr-2" .AuthorName}}
+ <a class="commit-id mr-2" href="{{$commitLink}}">{{ShortSha .Sha1}}</a>
+ <span class="text truncate light grey">
+ {{RenderCommitMessage .Message $repoLink $.ComposeMetas}}
+ </span>
+ </li>
{{end}}
{{if and (gt (len $push.Commits) 1) $push.CompareURL}}<li><a href="{{AppSubUrl}}/{{$push.CompareURL}}">{{$.i18n.Tr "action.compare_commits" (len $push.Commits)}} ยป</a></li>{{end}}
</ul>
projects / gitea.git / commitdiff