ugit/internal/git/repo.go

393 lines
7.7 KiB
Go

package git
import (
"bytes"
"encoding/json"
"errors"
"os"
"path/filepath"
"sort"
"strings"
"time"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
)
// Repo is a git repository
type Repo struct {
path string
Meta RepoMeta
}
// Name returns the human-friendly name, the dir name without the .git suffix
func (r Repo) Name() string {
return strings.TrimSuffix(filepath.Base(r.path), ".git")
}
// NewRepo constructs a Repo given a dir and name
func NewRepo(dir, name string) (*Repo, error) {
if !strings.HasSuffix(name, ".git") {
name += ".git"
}
r := &Repo{
path: filepath.Join(dir, name),
}
_, err := os.Stat(r.path)
if err != nil {
return nil, err
}
if err := ensureJSONFile(r.metaPath()); err != nil {
return nil, err
}
fi, err := os.Open(r.metaPath())
if err != nil {
return nil, err
}
defer fi.Close()
if err := json.NewDecoder(fi).Decode(&r.Meta); err != nil {
return nil, err
}
return r, nil
}
// DefaultBranch returns the branch referenced by HEAD, setting it if needed
func (r Repo) DefaultBranch() (string, error) {
repo, err := r.Git()
if err != nil {
return "", err
}
ref, err := repo.Head()
if err != nil {
if !errors.Is(err, plumbing.ErrReferenceNotFound) {
return "", err
}
brs, err := repo.Branches()
if err != nil {
return "", err
}
defer brs.Close()
fb, err := brs.Next()
if err != nil {
return "", err
}
// Rename the default branch to the first branch available
ref = fb
sym := plumbing.NewSymbolicReference(plumbing.HEAD, fb.Name())
if err := repo.Storer.SetReference(sym); err != nil {
return "", err
}
}
return strings.TrimPrefix(ref.Name().String(), "refs/heads/"), nil
}
// Git allows access to the git repository
func (r Repo) Git() (*git.Repository, error) {
return git.PlainOpen(r.path)
}
// Commit is a git commit
type Commit struct {
SHA string
Message string
Signature string
Author string
Email string
When time.Time
// Extra
Stats CommitStats
Patch string
Files []CommitFile
}
// CommitStats is the stats of a commit
type CommitStats struct {
Changed int
Additions int
Deletions int
}
// CommitFile is a file contained in a commit
type CommitFile struct {
From CommitFileEntry
To CommitFileEntry
Action string
Patch string
}
// CommitFileEntry is a from/to in a file commit
type CommitFileEntry struct {
Path string
Commit string
}
// Short returns the first eight characters of the SHA
func (c Commit) Short() string {
return c.SHA[:8]
}
// Summary returns the first line of the commit, suitable for a <summary>
func (c Commit) Summary() string {
return strings.Split(c.Message, "\n")[0]
}
// Details returns all lines *after* the first, suitable for <details>
func (c Commit) Details() string {
return strings.Join(strings.Split(c.Message, "\n")[1:], "\n")
}
// Commit gets a specific commit by SHA, including all commit information
func (r Repo) Commit(sha string) (Commit, error) {
repo, err := r.Git()
if err != nil {
return Commit{}, err
}
return commit(repo, sha, true)
}
// LastCommit returns the last commit of the repo without any extra information
func (r Repo) LastCommit() (Commit, error) {
repo, err := r.Git()
if err != nil {
return Commit{}, err
}
head, err := repo.Head()
if err != nil {
return Commit{}, err
}
return commit(repo, head.Hash().String(), false)
}
func commit(repo *git.Repository, sha string, extra bool) (Commit, error) {
obj, err := repo.CommitObject(plumbing.NewHash(sha))
if err != nil {
return Commit{}, err
}
var c, a, d int
var p string
var f []CommitFile
if extra {
stats, err := obj.Stats()
if err != nil {
return Commit{}, err
}
c = len(stats)
for _, stat := range stats {
a += stat.Addition
d += stat.Deletion
}
parent, err := obj.Parent(0)
if err != nil {
return Commit{}, err
}
patch, err := obj.Patch(parent)
if err != nil {
return Commit{}, err
}
var buf bytes.Buffer
if err := patch.Encode(&buf); err != nil {
return Commit{}, err
}
p = buf.String()
objTree, err := obj.Tree()
if err != nil {
return Commit{}, err
}
parentTree, err := parent.Tree()
if err != nil {
return Commit{}, err
}
changes, err := parentTree.Diff(objTree)
if err != nil {
return Commit{}, err
}
for _, change := range changes {
action, err := change.Action()
if err != nil {
return Commit{}, err
}
patch, err := change.Patch()
if err != nil {
return Commit{}, err
}
var buf bytes.Buffer
if err := patch.Encode(&buf); err != nil {
return Commit{}, err
}
f = append(f, CommitFile{
From: CommitFileEntry{
Path: change.From.Name,
Commit: parent.Hash.String(),
},
To: CommitFileEntry{
Path: change.To.Name,
Commit: obj.Hash.String(),
},
Action: action.String(),
Patch: buf.String(),
})
}
}
return Commit{
SHA: obj.Hash.String(),
Message: obj.Message,
Signature: obj.PGPSignature,
Author: obj.Author.Name,
Email: obj.Author.Email,
When: obj.Author.When,
Stats: CommitStats{
Changed: c,
Additions: a,
Deletions: d,
},
Patch: p,
Files: f,
}, nil
}
// Branches is all repo branches, default first and sorted alphabetically after that
func (r Repo) Branches() ([]string, error) {
repo, err := r.Git()
if err != nil {
return nil, err
}
def, err := r.DefaultBranch()
if err != nil {
return nil, err
}
brs, err := repo.Branches()
if err != nil {
return nil, err
}
var branches []string
if err := brs.ForEach(func(branch *plumbing.Reference) error {
branches = append(branches, branch.Name().Short())
return nil
}); err != nil {
return nil, err
}
sort.Slice(branches, func(i, j int) bool {
return branches[i] == def || branches[i] < branches[j]
})
return branches, nil
}
// Tag is a git tag, which may or may not have an annotation/signature
type Tag struct {
Name string
Annotation string
Signature string
When time.Time
}
// Tags is all repo tags, sorted by time descending
func (r Repo) Tags() ([]Tag, error) {
repo, err := r.Git()
if err != nil {
return nil, err
}
tgs, err := repo.Tags()
if err != nil {
return nil, err
}
var tags []Tag
if err := tgs.ForEach(func(tag *plumbing.Reference) error {
obj, err := repo.TagObject(tag.Hash())
switch {
case errors.Is(err, plumbing.ErrObjectNotFound):
commit, err := repo.CommitObject(tag.Hash())
if err != nil {
return err
}
tags = append(tags, Tag{
Name: tag.Name().Short(),
Annotation: commit.Message,
Signature: commit.PGPSignature,
When: commit.Author.When,
})
case err == nil:
tags = append(tags, Tag{
Name: obj.Name,
Annotation: obj.Message,
Signature: obj.PGPSignature,
When: obj.Tagger.When,
})
default:
return err
}
return nil
}); err != nil {
return nil, err
}
sort.Slice(tags, func(i, j int) bool {
return tags[i].When.After(tags[j].When)
})
return tags, nil
}
// Commits returns commits from a specific hash in descending order
func (r Repo) Commits(ref string) ([]Commit, error) {
repo, err := r.Git()
if err != nil {
return nil, err
}
hash, err := repo.ResolveRevision(plumbing.Revision(ref))
if err != nil {
return nil, err
}
cmts, err := repo.Log(&git.LogOptions{
From: *hash,
})
if err != nil {
return nil, err
}
var commits []Commit
if err := cmts.ForEach(func(commit *object.Commit) error {
commits = append(commits, Commit{
SHA: commit.Hash.String(),
Message: commit.Message,
Signature: commit.PGPSignature,
Author: commit.Author.Name,
Email: commit.Author.Email,
When: commit.Author.When,
})
return nil
}); err != nil {
return nil, err
}
return commits, nil
}