filesystem: add 'ReadDirRecursive()'

Add the 'ReadDirRecursive()' function to 'FileSystem' to facilitate easy
lookup of filesystem entries at a fixed depth from the root. In later
commits, this will be used to look up routes in the bundle server under the
'reporoot' on the filesystem.

'ReadDirRecursive()' takes three arguments:
* 'path': the root directory into which we want to recurse
* 'depth': the number of times to recurse into 'path'. A depth of 0 will
  return nothing, a depth of 1 will return all entries inside 'path', a
  depth of 2 will return all entries inside the subdirectories of 'path',
  etc.
* 'strictDepth': a flag indicating whether to return only entries that are
  *exactly 'depth' levels beneath 'path'. If 'false', 'ReadDirRecursive()'
  will also include files and empty directories at depths less than 'depth'.

For example, consider the following directory tree:

.
├── another-dir/
│   └── testfile
├── myfile
├── org/
│   └── repo/
│       ├── deeper/
│       └── repofile
└── too-shallow/

'ReadDirRecursive(".", 2, true)' will return:
- ./another-dir/testfile
- ./org/repo/

Whereas 'ReadDirRecursive(".", 2, false)' will return:
- ./another-dir/testfile
- ./myfile
- ./org/repo/
- ./too-shallow/

Signed-off-by: Victoria Dye <vdye@github.com>

Author: vdye

internal/common/filesystem.go

@@ -10,6 +10,8 @@ import (
 	"path"
 	"path/filepath"
 	"syscall"
+
+	"github.com/github/git-bundle-server/internal/utils"
 )
 
 const (
@@ -35,6 +37,29 @@ func (l *lockFile) Rollback() error {
 	return os.Remove(l.lockFilename)
 }
 
+type ReadDirEntry interface {
+	Path() string
+	fs.DirEntry
+}
+
+type fsEntry struct {
+	root string
+	fs.DirEntry
+}
+
+func (e *fsEntry) Path() string {
+	return filepath.Join(e.root, e.Name())
+}
+
+func mapDirEntry(root string) func(fs.DirEntry) ReadDirEntry {
+	return func(e fs.DirEntry) ReadDirEntry {
+		return &fsEntry{
+			root:     root,
+			DirEntry: e,
+		}
+	}
+}
+
 type FileSystem interface {
 	GetLocalExecutable(name string) (string, error)
 
@@ -43,6 +68,15 @@ type FileSystem interface {
 	WriteLockFileFunc(filename string, writeFunc func(io.Writer) error) (LockFile, error)
 	DeleteFile(filename string) (bool, error)
 	ReadFileLines(filename string) ([]string, error)
+
+	// ReadDirRecursive recurses into a given directory ('path') up to 'depth'
+	// levels deep. If 'strictDepth' is true, only the entries at *exactly* the
+	// given depth are returned (if any). If 'strictDepth' is false, though, the
+	// results will also include any files or empty directories for a depth <
+	// 'depth'.
+	//
+	// If 'depth' is <= 0, ReadDirRecursive returns an empty list.
+	ReadDirRecursive(path string, depth int, strictDepth bool) ([]ReadDirEntry, error)
 }
 
 type fileSystem struct{}
@@ -173,3 +207,41 @@ func (f *fileSystem) ReadFileLines(filename string) ([]string, error) {
 
 	return l, nil
 }
+
+func (f *fileSystem) ReadDirRecursive(path string, depth int, strictDepth bool) ([]ReadDirEntry, error) {
+	if depth <= 0 {
+		return []ReadDirEntry{}, nil
+	}
+
+	dirEntries, err := os.ReadDir(path)
+	if err != nil {
+		return nil, err
+	}
+
+	entries := utils.Map(dirEntries, mapDirEntry(path))
+	if depth == 1 {
+		return entries, nil
+	}
+
+	out := []ReadDirEntry{}
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			if !strictDepth {
+				out = append(out, entry)
+			}
+			continue
+		}
+
+		subEntries, err := f.ReadDirRecursive(entry.Path(), depth-1, strictDepth)
+		if err != nil {
+			return nil, err
+		}
+		if !strictDepth && len(subEntries) == 0 {
+			out = append(out, entry)
+			continue
+		}
+		out = append(out, subEntries...)
+	}
+
+	return out, nil
+}

internal/testhelpers/mocks.go

@@ -196,6 +196,11 @@ func (m *MockFileSystem) ReadFileLines(filename string) ([]string, error) {
 	return fnArgs.Get(0).([]string), fnArgs.Error(1)
 }
 
+func (m *MockFileSystem) ReadDirRecursive(path string, depth int, strictDepth bool) ([]common.ReadDirEntry, error) {
+	fnArgs := m.Called(path, depth, strictDepth)
+	return fnArgs.Get(0).([]common.ReadDirEntry), fnArgs.Error(1)
+}
+
 type MockGitHelper struct {
 	mock.Mock
 }