Avoid nearly all external 'git' invocations when doing directory listing (.editorconfig code path is still hit).

Signed-off-by: Filip Navara <[email protected]>

Author: filipnavara

modules/git/commit_info.go

@@ -55,12 +55,18 @@ func convertCommit(c *object.Commit) *Commit {
 		}
 	}
 
+	parents := make([]SHA1, len(c.ParentHashes))
+	for i, parentHash := range c.ParentHashes {
+		parents[i] = SHA1(parentHash)
+	}
+
 	return &Commit{
 		ID:            SHA1(c.Hash),
 		CommitMessage: c.Message,
 		Committer:     &commiter,
 		Author:        &author,
 		Signature:     pgpSignaure,
+		parents:       parents,
 	}
 }
 

modules/git/repo.go

@@ -27,8 +27,7 @@ import (
 type Repository struct {
 	Path string
 
-	commitCache *ObjectCache
-	tagCache    *ObjectCache
+	tagCache *ObjectCache
 
 	gogitRepo    *gogit.Repository
 	gogitStorage *filesystem.Storage
@@ -96,7 +95,6 @@ func OpenRepository(repoPath string) (*Repository, error) {
 		Path:         repoPath,
 		gogitRepo:    gogitRepo,
 		gogitStorage: storage,
-		commitCache:  newObjectCache(),
 		tagCache:     newObjectCache(),
 	}, nil
 }

modules/git/repo_branch.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"strings"
 
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 )
 
@@ -29,7 +28,11 @@ func IsBranchExist(repoPath, name string) bool {
 
 // IsBranchExist returns true if given branch exists in current repository.
 func (repo *Repository) IsBranchExist(name string) bool {
-	return IsBranchExist(repo.Path, name)
+	_, err := repo.gogitRepo.Reference(plumbing.ReferenceName(BranchPrefix+name), true)
+	if err != nil {
+		return false
+	}
+	return true
 }
 
 // Branch represents a Git branch.
@@ -64,24 +67,21 @@ func (repo *Repository) SetDefaultBranch(name string) error {
 
 // GetBranches returns all branches of the repository.
 func (repo *Repository) GetBranches() ([]string, error) {
-	r, err := git.PlainOpen(repo.Path)
-	if err != nil {
-		return nil, err
-	}
+	var branchNames []string
 
-	branchIter, err := r.Branches()
+	branches, err := repo.gogitRepo.Branches()
 	if err != nil {
 		return nil, err
 	}
-	branches := make([]string, 0)
-	if err = branchIter.ForEach(func(branch *plumbing.Reference) error {
-		branches = append(branches, branch.Name().Short())
+
+	branches.ForEach(func(branch *plumbing.Reference) error {
+		branchNames = append(branchNames, strings.TrimPrefix(branch.Name().String(), BranchPrefix))
 		return nil
-	}); err != nil {
-		return nil, err
-	}
+	})
+
+	// TODO: Sort?
 
-	return branches, nil
+	return branchNames, nil
 }
 
 // DeleteBranchOptions Option(s) for delete branch

modules/git/repo_commit.go

@@ -10,19 +10,19 @@ import (
 	"strconv"
 	"strings"
 
-	version "github.com/mcuadros/go-version"
+	"github.com/mcuadros/go-version"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
 )
 
 // GetRefCommitID returns the last commit ID string of given reference (branch or tag).
 func (repo *Repository) GetRefCommitID(name string) (string, error) {
-	stdout, err := NewCommand("show-ref", "--verify", name).RunInDir(repo.Path)
+	ref, err := repo.gogitRepo.Reference(plumbing.ReferenceName(name), true)
 	if err != nil {
-		if strings.Contains(err.Error(), "not a valid ref") {
-			return "", ErrNotExist{name, ""}
-		}
 		return "", err
 	}
-	return strings.Split(stdout, " ")[0], nil
+
+	return ref.Hash().String(), nil
 }
 
 // GetBranchCommitID returns last commit ID string of given branch.
@@ -42,114 +42,35 @@ func (repo *Repository) GetTagCommitID(name string) (string, error) {
 	return strings.TrimSpace(stdout), nil
 }
 
-// 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)
-	commit.parents = make([]SHA1, 0, 1)
-	// 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
-			}
-			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
-			break l
-		default:
-			break l
-		}
-	}
-	return commit, nil
-}
-
 func (repo *Repository) getCommit(id SHA1) (*Commit, error) {
-	c, ok := repo.commitCache.Get(id.String())
-	if ok {
-		log("Hit cache: %s", id)
-		return c.(*Commit), nil
-	}
+	//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)
+	gogitCommit, err := repo.gogitRepo.CommitObject(plumbing.Hash(id))
 	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 := convertCommit(gogitCommit)
 	commit.repo = repo
-	commit.ID = id
 
-	data, err = NewCommand("name-rev", id.String()).RunInDirBytes(repo.Path)
+	if tree, err := gogitCommit.Tree(); err != nil {
+		commit.Tree.ID = SHA1(tree.Hash)
+		commit.Tree.gogitTree = tree
+	}
+
+	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]
+	//repo.commitCache.Set(id.String(), commit)
 
-	repo.commitCache.Set(id.String(), commit)
 	return commit, nil
 }
 

modules/git/repo_tag.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/mcuadros/go-version"
+	"gopkg.in/src-d/go-git.v4/plumbing"
 )
 
 // TagPrefix tags prefix path on the repository
@@ -20,7 +21,11 @@ func IsTagExist(repoPath, name string) bool {
 
 // IsTagExist returns true if given tag exists in the repository.
 func (repo *Repository) IsTagExist(name string) bool {
-	return IsTagExist(repo.Path, name)
+	_, err := repo.gogitRepo.Reference(plumbing.ReferenceName(TagPrefix+name), true)
+	if err != nil {
+		return false
+	}
+	return true
 }
 
 // CreateTag create one tag in the repository
@@ -122,28 +127,25 @@ func (repo *Repository) GetTagInfos() ([]*Tag, error) {
 
 // GetTags returns all tags of the repository.
 func (repo *Repository) GetTags() ([]string, error) {
-	cmd := NewCommand("tag", "-l")
-	if version.Compare(gitVersion, "2.0.0", ">=") {
-		cmd.AddArguments("--sort=-v:refname")
-	}
+	var tagNames []string
 
-	stdout, err := cmd.RunInDir(repo.Path)
+	tags, err := repo.gogitRepo.Tags()
 	if err != nil {
-		return nil, err
+		return nil, nil
 	}
 
-	tags := strings.Split(stdout, "\n")
-	tags = tags[:len(tags)-1]
+	tags.ForEach(func(tag *plumbing.Reference) error {
+		tagNames = append(tagNames, strings.TrimPrefix(tag.Name().String(), TagPrefix))
+		return nil
+	})
 
-	if version.Compare(gitVersion, "2.0.0", "<") {
-		version.Sort(tags)
+	version.Sort(tagNames)
 
-		// Reverse order
-		for i := 0; i < len(tags)/2; i++ {
-			j := len(tags) - i - 1
-			tags[i], tags[j] = tags[j], tags[i]
-		}
+	// Reverse order
+	for i := 0; i < len(tagNames)/2; i++ {
+		j := len(tagNames) - i - 1
+		tagNames[i], tagNames[j] = tagNames[j], tagNames[i]
 	}
 
-	return tags, nil
+	return tagNames, nil
 }

modules/git/repo_tree.go

@@ -4,16 +4,17 @@
 
 package git
 
+import "gopkg.in/src-d/go-git.v4/plumbing"
+
 func (repo *Repository) getTree(id SHA1) (*Tree, error) {
-	treePath := filepathFromSHA1(repo.Path, id.String())
-	if isFile(treePath) {
-		_, err := NewCommand("ls-tree", id.String()).RunInDir(repo.Path)
-		if err != nil {
-			return nil, ErrNotExist{id.String(), ""}
-		}
+	gogitTree, err := repo.gogitRepo.TreeObject(plumbing.Hash(id))
+	if err != nil {
+		return nil, err
 	}
 
-	return NewTree(repo, id), nil
+	tree := NewTree(repo, id)
+	tree.gogitTree = gogitTree
+	return tree, nil
 }
 
 // GetTree find the tree object in the repository.