gitea/modules/git/tree_entry.go

206 lines
4.4 KiB
Go
Raw Normal View History

2016-11-03 23:16:01 +01:00
// Copyright 2015 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 (
"io"
2016-11-03 23:16:01 +01:00
"sort"
"strconv"
"strings"
)
2016-12-22 10:30:52 +01:00
// EntryMode the type of the object in the git tree
2016-11-03 23:16:01 +01:00
type EntryMode int
// There are only a few file modes in Git. They look like unix file modes, but they can only be
// one of these.
const (
2016-12-22 10:30:52 +01:00
// EntryModeBlob
EntryModeBlob EntryMode = 0x0100644
2016-12-22 10:30:52 +01:00
// EntryModeExec
EntryModeExec EntryMode = 0x0100755
2016-12-22 10:30:52 +01:00
// EntryModeSymlink
EntryModeSymlink EntryMode = 0x0120000
2016-12-22 10:30:52 +01:00
// EntryModeCommit
EntryModeCommit EntryMode = 0x0160000
2016-12-22 10:30:52 +01:00
// EntryModeTree
EntryModeTree EntryMode = 0x0040000
2016-11-03 23:16:01 +01:00
)
2016-12-22 10:30:52 +01:00
// TreeEntry the leaf in the git tree
2016-11-03 23:16:01 +01:00
type TreeEntry struct {
2016-12-22 10:30:52 +01:00
ID SHA1
2016-11-03 23:16:01 +01:00
Type ObjectType
mode EntryMode
name string
ptree *Tree
committed bool
2016-11-03 23:16:01 +01:00
size int64
sized bool
}
2016-12-22 10:30:52 +01:00
// Name returns the name of the entry
2016-11-03 23:16:01 +01:00
func (te *TreeEntry) Name() string {
return te.name
}
// Mode returns the mode of the entry
func (te *TreeEntry) Mode() EntryMode {
return te.mode
}
2016-12-22 10:30:52 +01:00
// Size returns the size of the entry
2016-11-03 23:16:01 +01:00
func (te *TreeEntry) Size() int64 {
if te.IsDir() {
return 0
} else if te.sized {
return te.size
}
stdout, err := NewCommand("cat-file", "-s", te.ID.String()).RunInDir(te.ptree.repo.Path)
if err != nil {
return 0
}
te.sized = true
te.size, _ = strconv.ParseInt(strings.TrimSpace(stdout), 10, 64)
return te.size
}
2016-12-22 10:30:52 +01:00
// IsSubModule if the entry is a sub module
2016-11-03 23:16:01 +01:00
func (te *TreeEntry) IsSubModule() bool {
2016-12-22 10:30:52 +01:00
return te.mode == EntryModeCommit
2016-11-03 23:16:01 +01:00
}
2016-12-22 10:30:52 +01:00
// IsDir if the entry is a sub dir
2016-11-03 23:16:01 +01:00
func (te *TreeEntry) IsDir() bool {
2016-12-22 10:30:52 +01:00
return te.mode == EntryModeTree
2016-11-03 23:16:01 +01:00
}
2016-12-22 10:30:52 +01:00
// IsLink if the entry is a symlink
func (te *TreeEntry) IsLink() bool {
return te.mode == EntryModeSymlink
}
// Blob retrun the blob object the entry
2016-11-03 23:16:01 +01:00
func (te *TreeEntry) Blob() *Blob {
return &Blob{
repo: te.ptree.repo,
TreeEntry: te,
}
}
// FollowLink returns the entry pointed to by a symlink
func (te *TreeEntry) FollowLink() (*TreeEntry, error) {
if !te.IsLink() {
return nil, ErrBadLink{te.Name(), "not a symlink"}
}
// read the link
r, err := te.Blob().Data()
if err != nil {
return nil, err
}
buf := make([]byte, te.Size())
_, err = io.ReadFull(r, buf)
if err != nil {
return nil, err
}
lnk := string(buf)
t := te.ptree
// traverse up directories
for ; t != nil && strings.HasPrefix(lnk, "../"); lnk = lnk[3:] {
t = t.ptree
}
if t == nil {
return nil, ErrBadLink{te.Name(), "points outside of repo"}
}
target, err := t.GetTreeEntryByPath(lnk)
if err != nil {
if IsErrNotExist(err) {
return nil, ErrBadLink{te.Name(), "broken link"}
}
return nil, err
}
return target, nil
}
2016-12-28 17:35:52 +01:00
// GetSubJumpablePathName return the full path of subdirectory jumpable ( contains only one directory )
func (te *TreeEntry) GetSubJumpablePathName() string {
if te.IsSubModule() || !te.IsDir() {
return ""
}
tree, err := te.ptree.SubTree(te.name)
if err != nil {
return te.name
}
entries, _ := tree.ListEntries()
if len(entries) == 1 && entries[0].IsDir() {
name := entries[0].GetSubJumpablePathName()
if name != "" {
return te.name + "/" + name
}
}
return te.name
}
2016-12-22 10:30:52 +01:00
// Entries a list of entry
2016-11-03 23:16:01 +01:00
type Entries []*TreeEntry
type customSortableEntries struct {
Comparer func(s1, s2 string) bool
Entries
}
var sorter = []func(t1, t2 *TreeEntry, cmp func(s1, s2 string) bool) bool{
func(t1, t2 *TreeEntry, cmp func(s1, s2 string) bool) bool {
2016-11-03 23:16:01 +01:00
return (t1.IsDir() || t1.IsSubModule()) && !t2.IsDir() && !t2.IsSubModule()
},
func(t1, t2 *TreeEntry, cmp func(s1, s2 string) bool) bool {
return cmp(t1.name, t2.name)
2016-11-03 23:16:01 +01:00
},
}
func (ctes customSortableEntries) Len() int { return len(ctes.Entries) }
func (ctes customSortableEntries) Swap(i, j int) {
ctes.Entries[i], ctes.Entries[j] = ctes.Entries[j], ctes.Entries[i]
}
func (ctes customSortableEntries) Less(i, j int) bool {
t1, t2 := ctes.Entries[i], ctes.Entries[j]
2016-11-03 23:16:01 +01:00
var k int
for k = 0; k < len(sorter)-1; k++ {
2016-11-12 12:09:25 +01:00
s := sorter[k]
2016-11-03 23:16:01 +01:00
switch {
case s(t1, t2, ctes.Comparer):
2016-11-03 23:16:01 +01:00
return true
case s(t2, t1, ctes.Comparer):
2016-11-03 23:16:01 +01:00
return false
}
}
return sorter[k](t1, t2, ctes.Comparer)
2016-11-03 23:16:01 +01:00
}
2016-12-22 10:30:52 +01:00
// Sort sort the list of entry
2016-11-03 23:16:01 +01:00
func (tes Entries) Sort() {
sort.Sort(customSortableEntries{func(s1, s2 string) bool {
return s1 < s2
}, tes})
}
// CustomSort customizable string comparing sort entry list
func (tes Entries) CustomSort(cmp func(s1, s2 string) bool) {
sort.Sort(customSortableEntries{cmp, tes})
2016-11-03 23:16:01 +01:00
}