Example #1
0
File: refs.go Project: jbrukh/ggit
func (p *refParser) ParsePackedRefs() ([]objects.Ref, error) {
	r := make([]objects.Ref, 0)
	err := util.SafeParse(func() {
		for !p.EOF() {
			c := p.PeekByte()
			switch c {
			case '#':
				// if this is the first line, then it should be a comment
				// that says '# pack-refs with: <extention>' and <extention>
				// is exactly one of the items in this set: { 'peeled' }.
				// currently, we are just ignoring all comments.
				p.ReadString(token.LF)
			case '^':
				// this means the previous line is an annotated tag and the the current
				// line contains the commit that tag points to
				p.ConsumeByte('^')
				commit := p.ParseOid()
				p.ConsumeByte(token.LF)

				if l := len(r); l > 0 {
					_, oid := r[l-1].Target()
					//TODO: inefficient (copying):
					r[l-1] = objects.NewRef(r[l-1].Name(), "", oid.(*objects.ObjectId), commit)
				}
			default:
				oid := p.ParseOid()
				p.ConsumeByte(token.SP)
				name := p.ReadString(token.LF)

				r = append(r, objects.NewRef(name, "", oid, nil))
			}
		}
	})
	return r, err
}
Example #2
0
func Test_Sorting(t *testing.T) {
	refs := make([]objects.Ref, 3)
	refs[0] = objects.NewRef("zoo", "", nil, nil)
	refs[1] = objects.NewRef("yogurt", "", nil, nil)
	refs[2] = objects.NewRef("xavier", "", nil, nil)
	sort.Sort(refByName(refs))
	util.Assert(t, refs[0].Name() == "xavier")
	util.Assert(t, refs[1].Name() == "yogurt")
	util.Assert(t, refs[2].Name() == "zoo")
}
Example #3
0
File: refs.go Project: jbrukh/ggit
func (p *refParser) ParseRef() (r objects.Ref, err error) {
	err = util.SafeParse(func() {
		// is it a symbolic ref?
		if p.PeekString(len(markerRef)) == markerRef {
			p.ConsumeString(markerRef)
			p.ConsumeByte(token.SP)
			spec := p.ReadString(token.LF)
			r = objects.NewRef(p.name, spec, nil, nil)
		} else {
			oid := p.ParseOid()
			p.ConsumeByte(token.LF)
			r = objects.NewRef(p.name, "", oid, nil)
		}
	})
	return r, err
}
Example #4
0
func (repo *DiskRepository) Refs() ([]objects.Ref, error) {

	// First, get all the packed refs.
	pr, err := repo.PackedRefs()
	if err != nil && !os.IsNotExist(err) {
		return nil, err
	}

	// Refs will be stores in a map by their symbolic name.
	refs := make(map[string]objects.Ref)
	for _, ref := range pr {
		refs[ref.Name()] = ref
	}

	// Now let's walk loose refs and collect them to supercede
	// the packed refs. It is worth it to note here that
	// packed refs may contain outdated references because
	// they are updated lazily.
	dir := path.Join(repo.path, "refs")
	err = filepath.Walk(dir,
		func(path string, f os.FileInfo, err error) error {
			// refs are files, so...
			if !f.IsDir() {
				name := util.TrimPrefix(path, repo.path+"/")
				r, e := PeeledRefFromSpec(repo, name)
				if e != nil {
					return e
				}
				refs[name] = objects.NewRef(name, "", r.ObjectId(), nil)
			}
			return nil
		},
	)
	if err != nil {
		return nil, err
	}

	// collect the refs into a list
	refList := make([]objects.Ref, 0, len(refs))
	for _, v := range refs {
		refList = append(refList, v)
	}
	sort.Sort(refByName(refList))
	return refList, nil
}
Example #5
0
func (repo *DiskRepository) LooseRefs() ([]objects.Ref, error) {
	// TODO: figure out a way to decouple this logic
	repoPath := repo.path + "/"
	dir := path.Join(repoPath, "refs")
	refs := make([]objects.Ref, 0)
	err := filepath.Walk(dir,
		func(path string, f os.FileInfo, err error) error {
			if !f.IsDir() {
				name := util.TrimPrefix(path, repoPath)
				r, e := PeeledRefFromSpec(repo, name)
				if e != nil {
					return e
				}
				refs = append(refs, objects.NewRef(name, "", r.ObjectId(), nil))
			}
			return nil
		},
	)
	return refs, err
}