bench-forgejo/modules/git/tree.go

137 lines
2.8 KiB
Go
Raw Normal View History

2014-07-26 09:54:27 +05:30
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package git
import (
"bytes"
"errors"
"strings"
"github.com/Unknwon/com"
)
var (
ErrNotExist = errors.New("error not exist")
)
// A tree is a flat directory listing.
type Tree struct {
2015-11-04 09:19:06 +05:30
ID sha1
2014-07-26 09:54:27 +05:30
repo *Repository
// parent tree
ptree *Tree
entries Entries
entriesParsed bool
}
// Parse tree information from the (uncompressed) raw
// data from the tree object.
func parseTreeData(tree *Tree, data []byte) ([]*TreeEntry, error) {
entries := make([]*TreeEntry, 0, 10)
l := len(data)
pos := 0
for pos < l {
entry := new(TreeEntry)
entry.ptree = tree
step := 6
switch string(data[pos : pos+step]) {
case "100644":
entry.mode = ModeBlob
entry.Type = BLOB
case "100755":
entry.mode = ModeExec
entry.Type = BLOB
case "120000":
entry.mode = ModeSymlink
entry.Type = BLOB
case "160000":
entry.mode = ModeCommit
entry.Type = COMMIT
step = 8
2014-07-26 09:54:27 +05:30
case "040000":
entry.mode = ModeTree
entry.Type = TREE
default:
return nil, errors.New("unknown type: " + string(data[pos:pos+step]))
}
pos += step + 6 // Skip string type of entry type.
step = 40
id, err := NewIdFromString(string(data[pos : pos+step]))
if err != nil {
return nil, err
}
2015-11-04 09:19:06 +05:30
entry.ID = id
2014-07-26 09:54:27 +05:30
pos += step + 1 // Skip half of sha1.
step = bytes.IndexByte(data[pos:], '\n')
entry.name = string(data[pos : pos+step])
2015-08-20 13:27:51 +05:30
// In case entry name is surrounded by double quotes(it happens only in git-shell).
if entry.name[0] == '"' {
entry.name = string(data[pos+1 : pos+step-1])
entry.name = strings.Replace(entry.name, `\"`, `"`, -1)
}
2014-07-26 09:54:27 +05:30
pos += step + 1
entries = append(entries, entry)
}
return entries, nil
}
func (t *Tree) SubTree(rpath string) (*Tree, error) {
if len(rpath) == 0 {
return t, nil
}
paths := strings.Split(rpath, "/")
var err error
var g = t
var p = t
var te *TreeEntry
for _, name := range paths {
te, err = p.GetTreeEntryByPath(name)
if err != nil {
return nil, err
}
2015-11-04 09:19:06 +05:30
g, err = t.repo.getTree(te.ID)
2014-07-26 09:54:27 +05:30
if err != nil {
return nil, err
}
g.ptree = p
p = g
}
return g, nil
}
func (t *Tree) ListEntries(relpath string) (Entries, error) {
if t.entriesParsed {
return t.entries, nil
}
t.entriesParsed = true
2014-09-30 14:09:53 +05:30
stdout, stderr, err := com.ExecCmdDirBytes(t.repo.Path,
2015-11-04 09:19:06 +05:30
"git", "ls-tree", t.ID.String())
2014-07-26 09:54:27 +05:30
if err != nil {
2014-09-30 14:09:53 +05:30
if strings.Contains(err.Error(), "exit status 128") {
return nil, errors.New(strings.TrimSpace(string(stderr)))
}
2014-07-26 09:54:27 +05:30
return nil, err
}
t.entries, err = parseTreeData(t, stdout)
return t.entries, err
}
func NewTree(repo *Repository, id sha1) *Tree {
tree := new(Tree)
2015-11-04 09:19:06 +05:30
tree.ID = id
2014-07-26 09:54:27 +05:30
tree.repo = repo
return tree
}