code.gitea.io/gitea@v1.19.3/modules/git/tree_gogit.go (about)

     1  // Copyright 2015 The Gogs Authors. All rights reserved.
     2  // Copyright 2019 The Gitea Authors. All rights reserved.
     3  // SPDX-License-Identifier: MIT
     4  
     5  //go:build gogit
     6  
     7  package git
     8  
     9  import (
    10  	"io"
    11  
    12  	"github.com/go-git/go-git/v5/plumbing"
    13  	"github.com/go-git/go-git/v5/plumbing/object"
    14  )
    15  
    16  // Tree represents a flat directory listing.
    17  type Tree struct {
    18  	ID         SHA1
    19  	ResolvedID SHA1
    20  	repo       *Repository
    21  
    22  	gogitTree *object.Tree
    23  
    24  	// parent tree
    25  	ptree *Tree
    26  }
    27  
    28  func (t *Tree) loadTreeObject() error {
    29  	gogitTree, err := t.repo.gogitRepo.TreeObject(t.ID)
    30  	if err != nil {
    31  		return err
    32  	}
    33  
    34  	t.gogitTree = gogitTree
    35  	return nil
    36  }
    37  
    38  // ListEntries returns all entries of current tree.
    39  func (t *Tree) ListEntries() (Entries, error) {
    40  	if t.gogitTree == nil {
    41  		err := t.loadTreeObject()
    42  		if err != nil {
    43  			return nil, err
    44  		}
    45  	}
    46  
    47  	entries := make([]*TreeEntry, len(t.gogitTree.Entries))
    48  	for i, entry := range t.gogitTree.Entries {
    49  		entries[i] = &TreeEntry{
    50  			ID:             entry.Hash,
    51  			gogitTreeEntry: &t.gogitTree.Entries[i],
    52  			ptree:          t,
    53  		}
    54  	}
    55  
    56  	return entries, nil
    57  }
    58  
    59  // ListEntriesRecursiveWithSize returns all entries of current tree recursively including all subtrees
    60  func (t *Tree) ListEntriesRecursiveWithSize() (Entries, error) {
    61  	if t.gogitTree == nil {
    62  		err := t.loadTreeObject()
    63  		if err != nil {
    64  			return nil, err
    65  		}
    66  	}
    67  
    68  	var entries []*TreeEntry
    69  	seen := map[plumbing.Hash]bool{}
    70  	walker := object.NewTreeWalker(t.gogitTree, true, seen)
    71  	for {
    72  		fullName, entry, err := walker.Next()
    73  		if err == io.EOF {
    74  			break
    75  		}
    76  		if err != nil {
    77  			return nil, err
    78  		}
    79  		if seen[entry.Hash] {
    80  			continue
    81  		}
    82  
    83  		convertedEntry := &TreeEntry{
    84  			ID:             entry.Hash,
    85  			gogitTreeEntry: &entry,
    86  			ptree:          t,
    87  			fullName:       fullName,
    88  		}
    89  		entries = append(entries, convertedEntry)
    90  	}
    91  
    92  	return entries, nil
    93  }
    94  
    95  // ListEntriesRecursiveFast is the alias of ListEntriesRecursiveWithSize for the gogit version
    96  func (t *Tree) ListEntriesRecursiveFast() (Entries, error) {
    97  	return t.ListEntriesRecursiveWithSize()
    98  }