Some improvements

Author: lunny

modules/actions/workflows.go

@@ -5,7 +5,6 @@ package actions
 
 import (
 	"bytes"
-	"context"
 	"io"
 	"strings"
 
@@ -57,7 +56,7 @@ func ListWorkflows(commit *git.Commit) (git.Entries, error) {
 	}
 
 	ret := make(git.Entries, 0, 5)
-	if err := tree.IterateEntriesRecursive(context.Background(), func(entry *git.TreeEntry) error {
+	if err := tree.IterateEntriesRecursive(func(entry *git.TreeEntry) error {
 		if strings.HasSuffix(entry.Name(), ".yml") || strings.HasSuffix(entry.Name(), ".yaml") {
 			ret = append(ret, entry)
 		}

modules/git/repo_language_stats_nogogit.go

@@ -72,7 +72,7 @@ func (repo *Repository) GetLanguageStats(commitID string) (map[string]int64, err
 	firstExcludedLanguage := ""
 	firstExcludedLanguageSize := int64(0)
 
-	if err := tree.IterateEntriesRecursive(repo.Ctx, func(f *TreeEntry) error {
+	if err := tree.IterateEntriesRecursive(func(f *TreeEntry) error {
 		contentBuf.Reset()
 		content = contentBuf.Bytes()
 

modules/git/tree_gogit.go

@@ -7,7 +7,6 @@
 package git
 
 import (
-	"context"
 	"io"
 
 	"github.com/go-git/go-git/v5/plumbing"
@@ -58,15 +57,32 @@ func (t *Tree) ListEntries() (Entries, error) {
 }
 
 // ListEntriesRecursiveWithSize returns all entries of current tree recursively including all subtrees
-func (t *Tree) ListEntriesRecursiveWithSize(ctx context.Context) (Entries, error) {
+func (t *Tree) ListEntriesRecursiveWithSize() (Entries, error) {
+	var entries []*TreeEntry
+	if err := t.IterateEntriesRecursive(func(entry *TreeEntry) error {
+		entries = append(entries, convertedEntry)
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return entries, nil
+}
+
+// ListEntriesRecursiveFast is the alias of ListEntriesRecursiveWithSize for the gogit version
+func (t *Tree) ListEntriesRecursiveFast() (Entries, error) {
+	return t.ListEntriesRecursiveWithSize()
+}
+
+// IterateEntriesRecursive returns iterate entries of current tree recursively including all subtrees
+// extraArgs could be "-l" to get the size, which is slower
+func (t *Tree) IterateEntriesRecursive(f func(entry *TreeEntry) error, extraArgs TrustedCmdArgs) error {
 	if t.gogitTree == nil {
 		err := t.loadTreeObject()
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	var entries []*TreeEntry
 	seen := map[plumbing.Hash]bool{}
 	walker := object.NewTreeWalker(t.gogitTree, true, seen)
 	for {
@@ -87,13 +103,10 @@ func (t *Tree) ListEntriesRecursiveWithSize(ctx context.Context) (Entries, error
 			ptree:          t,
 			fullName:       fullName,
 		}
-		entries = append(entries, convertedEntry)
+		if err := f(convertedEntry); err != nil {
+			return nil, err
+		}
 	}
 
-	return entries, nil
-}
-
-// ListEntriesRecursiveFast is the alias of ListEntriesRecursiveWithSize for the gogit version
-func (t *Tree) ListEntriesRecursiveFast(ctx context.Context) (Entries, error) {
-	return t.ListEntriesRecursiveWithSize(ctx)
+	return nil
 }

modules/git/tree_nogogit.go

@@ -7,7 +7,6 @@ package git
 
 import (
 	"bufio"
-	"context"
 	"io"
 	"strings"
 )
@@ -93,13 +92,13 @@ func (t *Tree) ListEntries() (Entries, error) {
 
 // listEntriesRecursive returns all entries of current tree recursively including all subtrees
 // extraArgs could be "-l" to get the size, which is slower
-func (t *Tree) listEntriesRecursive(ctx context.Context, extraArgs TrustedCmdArgs) (Entries, error) {
+func (t *Tree) listEntriesRecursive(extraArgs TrustedCmdArgs) (Entries, error) {
 	if t.entriesRecursiveParsed {
 		return t.entriesRecursive, nil
 	}
 
 	t.entriesRecursive = make([]*TreeEntry, 0)
-	if err := t.IterateEntriesRecursive(ctx, func(entry *TreeEntry) error {
+	if err := t.IterateEntriesRecursive(func(entry *TreeEntry) error {
 		t.entriesRecursive = append(t.entriesRecursive, entry)
 		return nil
 	}, extraArgs); err != nil {
@@ -112,18 +111,18 @@ func (t *Tree) listEntriesRecursive(ctx context.Context, extraArgs TrustedCmdArg
 }
 
 // ListEntriesRecursiveFast returns all entries of current tree recursively including all subtrees, no size
-func (t *Tree) ListEntriesRecursiveFast(ctx context.Context) (Entries, error) {
-	return t.listEntriesRecursive(ctx, nil)
+func (t *Tree) ListEntriesRecursiveFast() (Entries, error) {
+	return t.listEntriesRecursive(nil)
 }
 
 // ListEntriesRecursiveWithSize returns all entries of current tree recursively including all subtrees, with size
-func (t *Tree) ListEntriesRecursiveWithSize(ctx context.Context) (Entries, error) {
-	return t.listEntriesRecursive(ctx, TrustedCmdArgs{"--long"})
+func (t *Tree) ListEntriesRecursiveWithSize() (Entries, error) {
+	return t.listEntriesRecursive(TrustedCmdArgs{"--long"})
 }
 
 // IterateEntriesRecursive returns iterate entries of current tree recursively including all subtrees
 // extraArgs could be "-l" to get the size, which is slower
-func (t *Tree) IterateEntriesRecursive(ctx context.Context, f func(entry *TreeEntry) error, extraArgs TrustedCmdArgs) error {
+func (t *Tree) IterateEntriesRecursive(f func(entry *TreeEntry) error, extraArgs TrustedCmdArgs) error {
 	reader, writer := io.Pipe()
 	done := make(chan error)
 
@@ -154,8 +153,8 @@ func (t *Tree) IterateEntriesRecursive(ctx context.Context, f func(entry *TreeEn
 			}
 
 			select {
-			case <-ctx.Done():
-				return ctx.Err()
+			case <-t.repo.Ctx.Done():
+				return t.repo.Ctx.Err()
 			case runErr := <-done:
 				return runErr
 			default:

routers/web/repo/treelist.go

@@ -21,7 +21,7 @@ func TreeList(ctx *context.Context) {
 		return
 	}
 
-	entries, err := tree.ListEntriesRecursiveFast(ctx)
+	entries, err := tree.ListEntriesRecursiveFast()
 	if err != nil {
 		ctx.ServerError("ListEntriesRecursiveFast", err)
 		return

services/repository/files/tree.go

@@ -47,7 +47,7 @@ func GetTreeBySHA(ctx context.Context, repo *repo_model.Repository, gitRepo *git
 	tree.URL = repo.APIURL() + "/git/trees/" + url.PathEscape(tree.SHA)
 	var entries git.Entries
 	if recursive {
-		entries, err = gitTree.ListEntriesRecursiveWithSize(ctx)
+		entries, err = gitTree.ListEntriesRecursiveWithSize()
 	} else {
 		entries, err = gitTree.ListEntries()
 	}