package gitdir
import (
"bufio"
"errors"
"io/ioutil"
"os"
"strings"
"gopkg.in/src-d/go-git.v3/core"
)
var (
// ErrPackedRefsDuplicatedRef is returned when a duplicated
// reference is found in the packed-ref file. This is usually the
// case for corrupted git repositories.
ErrPackedRefsDuplicatedRef = errors.New("duplicated ref found in packed-ref file")
// ErrPackedRefsBadFormat is returned when the packed-ref file
// corrupt.
ErrPackedRefsBadFormat = errors.New("malformed packed-ref")
// ErrSymRefTargetNotFound is returned when a symbolic reference is
// targeting a non-existing object. This usually means the
// repository is corrupt.
ErrSymRefTargetNotFound = errors.New("symbolic reference target not found")
)
const (
symRefPrefix = "ref: "
)
func (d *GitDir) addRefsFromPackedRefs() (err error) {
path := d.fs.Join(d.path, packedRefsPath)
f, err := d.fs.Open(path)
if err != nil {
if err == os.ErrNotExist {
return nil
}
return err
}
defer func() {
errClose := f.Close()
if err == nil {
err = errClose
}
}()
s := bufio.NewScanner(f)
for s.Scan() {
line := s.Text()
if err = d.processLine(line); err != nil {
return err
}
}
return s.Err()
}
// process lines from a packed-refs file
func (d *GitDir) processLine(line string) error {
switch line[0] {
case '#': // comment - ignore
return nil
case '^': // annotated tag commit of the previous line - ignore
return nil
default:
ws := strings.Split(line, " ") // hash then ref
if len(ws) != 2 {
return ErrPackedRefsBadFormat
}
h, r := ws[0], ws[1]
if _, ok := d.refs[r]; ok {
return ErrPackedRefsDuplicatedRef
}
d.refs[r] = core.NewHash(h)
}
return nil
}
func (d *GitDir) addRefsFromRefDir() error {
return d.walkTree("refs")
}
func (d *GitDir) walkTree(relPath string) error {
files, err := d.fs.ReadDir(d.fs.Join(d.path, relPath))
if err != nil {
return err
}
for _, f := range files {
newRelPath := d.fs.Join(relPath, f.Name())
if f.IsDir() {
if err = d.walkTree(newRelPath); err != nil {
return err
}
} else {
filePath := d.fs.Join(d.path, newRelPath)
h, err := d.readHashFile(filePath)
if err != nil {
return err
}
d.refs[newRelPath] = h
}
}
return nil
}
// ReadHashFile reads a single hash from a file. If a symbolic
// reference is found instead of a hash, the reference is resolved and
// the proper hash is returned.
func (d *GitDir) readHashFile(path string) (h core.Hash, err error) {
f, err := d.fs.Open(path)
if err != nil {
return core.ZeroHash, err
}
defer func() {
errClose := f.Close()
if err == nil {
err = errClose
}
}()
b, err := ioutil.ReadAll(f)
if err != nil {
return core.ZeroHash, err
}
line := strings.TrimSpace(string(b))
if isSymRef(line) {
return d.resolveSymRef(line)
}
return core.NewHash(line), nil
}
func isSymRef(contents string) bool {
return strings.HasPrefix(contents, symRefPrefix)
}
func (d *GitDir) resolveSymRef(symRef string) (core.Hash, error) {
ref := strings.TrimPrefix(symRef, symRefPrefix)
hash, ok := d.refs[ref]
if !ok {
return core.ZeroHash, ErrSymRefTargetNotFound
}
return hash, nil
}
