merge

diff --cc models/repo2.go
index ccdda5bdb314bf336df9aa92be019f5f5b84f20a,b31244b41476d6c37dba7dae40f1aad25bb11782..3c170a06f4f5811ab498342a2ac3b7f36b2b81cf
--- 1/models/repo2.go
--- 2/models/repo2.go
+++ b/models/repo2.go
@@@ -14,39 -29,41 +29,64 @@@ var 
  
  type RepoFile struct {
        *git.TreeEntry
 -      Path    string
 -      Message string
 -      Created time.Time
 -      Size    int64
 -      Repo    *git.Repository
 +      Path       string
 +      Message    string
 +      Created    time.Time
 +      Size       int64
++      Repo       *git.Repository
 +      LastCommit string
 +}
 +
 +func findTree(repo *git.Repository, tree *git.Tree, rpath string) *git.Tree {
 +      if rpath == "" {
 +              return tree
 +      }
 +      paths := strings.Split(rpath, "/")
 +      var g = tree
 +      for _, p := range paths {
 +              s := g.EntryByName(p)
 +              if s == nil {
 +                      return nil
 +              }
 +              g, err := repo.LookupTree(s.Id)
 +              if err != nil {
 +                      return nil
 +              }
 +              if g == nil {
 +                      return nil
 +              }
 +      }
 +      return g
  }
  
- func GetReposFiles(userName, reposName, branchName, rpath string) ([]*RepoFile, error) {
-       f := RepoPath(userName, reposName)
+ func (file *RepoFile) LookupBlob() (*git.Blob, error) {
+       if file.Repo == nil {
+               return nil, ErrRepoFileNotLoaded
+       }
+ 
+       return file.Repo.LookupBlob(file.Id)
+ }
+ 
+ func GetBranches(userName, reposName string) ([]string, error) {
+       repo, err := git.OpenRepository(RepoPath(userName, reposName))
+       if err != nil {
+               return nil, err
+       }
+ 
+       refs, err := repo.AllReferences()
+       if err != nil {
+               return nil, err
+       }
+ 
+       brs := make([]string, len(refs))
+       for i, ref := range refs {
+               brs[i] = ref.Name
+       }
+       return brs, nil
+ }
  
-       repo, err := git.OpenRepository(f)
+ func GetReposFiles(userName, reposName, branchName, rpath string) ([]*RepoFile, error) {
+       repo, err := git.OpenRepository(RepoPath(userName, reposName))
        if err != nil {
                return nil, err
        }
@@@ -69,72 -86,25 +109,73 @@@
                        if err != nil {
                                return 0
                        }
 -                      switch entry.Filemode {
 -                      case git.FileModeBlob, git.FileModeBlobExec:
 -                              repofiles = append(repofiles, &RepoFile{
 -                                      entry,
 -                                      path.Join(dirname, entry.Name),
 -                                      lastCommit.Message(),
 -                                      lastCommit.Committer.When,
 -                                      size,
 -                                      repo,
 -                              })
 -                      case git.FileModeTree:
 -                              repodirs = append(repodirs, &RepoFile{
 -                                      entry,
 -                                      path.Join(dirname, entry.Name),
 -                                      lastCommit.Message(),
 -                                      lastCommit.Committer.When,
 -                                      size,
 -                                      repo,
 -                              })
 +
 +                      var cm = lastCommit
 +
 +                      for {
 +                              if cm.ParentCount() == 0 {
 +                                      break
 +                              } else if cm.ParentCount() == 1 {
 +                                      pt := findTree(repo, cm.Parent(0).Tree, dirname)
 +                                      if pt == nil {
 +                                              break
 +                                      }
 +                                      pEntry := pt.EntryByName(entry.Name)
 +                                      if pEntry == nil || !pEntry.Id.Equal(entry.Id) {
 +                                              break
 +                                      } else {
 +                                              cm = cm.Parent(0)
 +                                      }
 +                              } else {
 +                                      var emptyCnt = 0
 +                                      var sameIdcnt = 0
 +                                      for i := 0; i < cm.ParentCount(); i++ {
 +                                              p := cm.Parent(i)
 +                                              pt := findTree(repo, p.Tree, dirname)
 +                                              var pEntry *git.TreeEntry
 +                                              if pt != nil {
 +                                                      pEntry = pt.EntryByName(entry.Name)
 +                                              }
 +
 +                                              if pEntry == nil {
 +                                                      if emptyCnt == cm.ParentCount()-1 {
 +                                                              goto loop
 +                                                      } else {
 +                                                              emptyCnt = emptyCnt + 1
 +                                                              continue
 +                                                      }
 +                                              } else {
 +                                                      if !pEntry.Id.Equal(entry.Id) {
 +                                                              goto loop
 +                                                      } else {
 +                                                              if sameIdcnt == cm.ParentCount()-1 {
 +                                                                      // TODO: now follow the first parent commit?
 +                                                                      cm = cm.Parent(0)
 +                                                                      break
 +                                                              }
 +                                                              sameIdcnt = sameIdcnt + 1
 +                                                      }
 +                                              }
 +                                      }
 +                              }
 +                      }
 +
 +              loop:
 +
 +                      rp := &RepoFile{
 +                              entry,
 +                              path.Join(dirname, entry.Name),
 +                              cm.Message(),
 +                              cm.Committer.When,
 +                              size,
++                              repo,
 +                              cm.Id().String(),
 +                      }
 +
 +                      if entry.IsFile() {
 +                              repofiles = append(repofiles, rp)
 +                      } else if entry.IsDir() {
 +                              repodirs = append(repodirs, rp)
                        }
                }
                return 0