prompt

git.go (4050B)

---

 package main
 
 import (
 	"io"
 	"fmt"
 	"sync"
 	"errors"
 	"strings"
 	"path/filepath"
 
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
 )
 
 // Safely ignorable errors
 var GitErrIgns = []error{
 	plumbing.ErrReferenceNotFound,
 	git.ErrRepositoryNotExists,
 	ErrCmdNotRepo,
 }
 
 var (
 	ErrBadPrefix = errors.New("bad git prefix")
 	ErrMalformedDiff = errors.New("malfored git diff --name-status")
 	ErrCmdNotRepo = errors.New("git has been run in a directory that is not a repo")
 )
 
 func gitCmd(name string, arg ...string) ([]string, error) {
 	sl, err := Cmd(name, arg...)
 	
 	// That's not a type. Some cmds output 'Not', some output 'not'.
 	// And I'm too lazy to do case insensitive matching.
 	if err != nil && strings.Contains(err.Error(), "ot a git repository") {
 		return nil, ErrCmdNotRepo
 	}
 
 	return sl, err
 }
 
 type gpCache struct {
 	sync.Mutex
 	sync.Once
 	P string
 	E error
 }
 
 var gpc gpCache
 
 func gitPrefix() (string, error) {
 	gpc.Lock()
 	defer gpc.Unlock()
 
 	gpc.Do(func(){
 		prefix, err := gitCmd("git", "rev-parse", "--show-prefix")
 		if err != nil {
 			gpc.E = err
 		} else if len(prefix) > 1 {
 			gpc.E = fmt.Errorf("%w: %v", ErrBadPrefix, prefix)
 		} else if len(prefix) == 1 {
 			gpc.P = filepath.Clean(prefix[0])
 		}
 	})
 
 	return gpc.P, gpc.E
 }
 
 func gitRepo() (*git.Repository, error) {
 	// Ignore the error - let's try PlainOpen anyway
 	p, _ := gitPrefix()
 
 	d, err := filepath.Abs(".")
 	if err != nil {
 		// Fine. Okay. We'll use "."
 		d = "."
 	} else if strings.HasSuffix(d, p) {
 		d = d[:len(d) - len(p)]
 	}
 
 	return git.PlainOpen(d)
 }
 
 func gitResolve(r *git.Repository, ref string) (*plumbing.Hash, error) {
 	return r.ResolveRevision(plumbing.Revision(ref))
 }
 
 func GitHEAD() (string, error) {
 	r, err := gitRepo()
 	if err != nil {
 		return "", err
 	}
 
 	head, err := r.Head()
 	if err != nil {
 		return "", err
 	}
 
 	brch := head.Name().Short()
 
 	if brch == "HEAD" {
 		// On a detached head, so let's show the commit.
 		hash, err := gitResolve(r, "HEAD")
 		if err != nil {
 			return "", err
 		}
 
 		return hash.String()[:7], nil
 	}
 
 	switch {
 	case cnf.Smallbranch && cnf.Uniqbranch:
 		s := Smalltxt(brch)
 
 		iter, err := r.Branches()
 		if err != nil {
 			return "", err
 		}
 
 		for {
 			b, err := iter.Next()
 			if err == io.EOF {
 				return s, nil
 			} else if err != nil {
 				return "", err
 			}
 
 			n := b.Name().Short()
 			
 			// If n == brch, then it is the current branch, so it's fine.
 			if n != brch && (n == s || Smalltxt(n) == s) {
 				return brch, nil
 			}
 		}
 	case cnf.Smallbranch:
 		return Smalltxt(brch), nil
 	default:
 		return brch, nil
 	}
 }
 
 func GitUnpushed() (int, error) {
 	r, err := gitRepo()
 	if err != nil {
 		return 0, err
 	}
 
 	head, err := r.Head()
 	if err != nil {
 		return 0, err
 	}
 
 	b := head.Name().Short()
 
 	if b == "HEAD" {
 		// Alright we're on a detached head so we have no reference
 		// point any more. Say nothing.
 		return 0, nil
 	}
 
 	rmo, err := r.Remotes()
 	if err != nil {
 		return 0, err
 	}
 
 	rmh := make([]string, len(rmo))
 	for i := range rmo {
 		n := rmo[i].Config().Name
 		h, err := gitResolve(r, fmt.Sprintf("refs/remotes/%s/%s", n, b))
 		if err != nil {
 			return 0, err
 		}
 		rmh[i] = h.String()
 	}
 
 	iter, err := r.Log(&git.LogOptions{From: head.Hash()})
 	if err != nil {
 		return 0, err
 	}
 	
 	var ret int
 	counter: for {
 		c, err := iter.Next()
 		if err == io.EOF {
 			break counter
 		} else if err != nil {
 			return 0, err
 		}
 
 		for i := range rmh {
 			if rmh[i] == c.Hash.String() {
 				break counter
 			}
 		}
 
 		ret++
 	}
 
 	return ret, nil
 }
 
 func malformedDiff(str string) error {
 	return fmt.Errorf("%w: \"%v\"", ErrMalformedDiff, str)
 }
 
 func GitDiff() (m, a, d, s int, err error) {
 	sl, err := gitCmd("git", "diff", "--name-status")
 	if err != nil {
 		return
 	}
 
 	// not in a git repo
 	if len(sl) == 1 && sl[0] == "" {
 		return
 	}
 
 	for i := range sl {
 		if len(sl[i]) < 1 {
 			err = malformedDiff(sl[i])
 			return
 		}
 
 		switch sl[i][0] {
 		case 'M':
 			m++
 		case 'A':
 			a++
 		case 'D':
 			d++
 		default:
 			err = malformedDiff(sl[i])
 		}
 	}
 
 	return
 }