Add wrapper for io/fs

Signed-off-by: Evan Anderson <[email protected]>

helper/iofs/iofs.go

@@ -0,0 +1,142 @@
+// Package iofs provides an adapter from billy.Filesystem to a the
+// standard library io.fs.FS interface.
+package iofs
+
+import (
+	"io"
+	"io/fs"
+	"path/filepath"
+
+	billyfs "github.com/go-git/go-billy/v5"
+	"github.com/go-git/go-billy/v5/helper/polyfill"
+)
+
+// Wrap adapts a billy.Filesystem to a io.fs.FS.
+func Wrap(fs billyfs.Basic) fs.FS {
+	return &adapterFs{fs: polyfill.New(fs)}
+}
+
+type adapterFs struct {
+	fs billyfs.Filesystem
+}
+
+var _ fs.FS = (*adapterFs)(nil)
+var _ fs.ReadDirFS = (*adapterFs)(nil)
+var _ fs.StatFS = (*adapterFs)(nil)
+var _ fs.ReadFileFS = (*adapterFs)(nil)
+
+// GlobFS would be harder, we don't implement for now.
+
+// Open implements fs.FS.
+func (a *adapterFs) Open(name string) (fs.File, error) {
+	if name[0] == '/' || name != filepath.Clean(name) {
+		// fstest.TestFS explicitly checks that these should return error
+		// MemFS is performs the clean internally, so we need to block that here for testing.
+		return nil, &fs.PathError{Op: "open", Path: name, Err: fs.ErrInvalid}
+	}
+	stat, err := a.fs.Stat(name)
+	if err != nil {
+		return nil, err
+	}
+	if stat.IsDir() {
+		entries, err := a.ReadDir(name)
+		if err != nil {
+			return nil, err
+		}
+		return makeDir(stat, entries), nil
+	}
+	file, err := a.fs.Open(name)
+	return &adapterFile{file: file, info: stat}, err
+}
+
+// ReadDir implements fs.ReadDirFS.
+func (a *adapterFs) ReadDir(name string) ([]fs.DirEntry, error) {
+	items, err := a.fs.ReadDir(name)
+	if err != nil {
+		return nil, err
+	}
+	entries := make([]fs.DirEntry, len(items))
+	for i, item := range items {
+		entries[i] = fs.FileInfoToDirEntry(item)
+	}
+	return entries, nil
+}
+
+// Stat implements fs.StatFS.
+func (a *adapterFs) Stat(name string) (fs.FileInfo, error) {
+	return a.fs.Stat(name)
+}
+
+// ReadFile implements fs.ReadFileFS.
+func (a *adapterFs) ReadFile(name string) ([]byte, error) {
+	stat, err := a.fs.Stat(name)
+	if err != nil {
+		return nil, err
+	}
+	b := make([]byte, stat.Size())
+	file, err := a.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+	_, err = file.Read(b)
+	return b, err
+}
+
+type adapterFile struct {
+	file billyfs.File
+	info fs.FileInfo
+}
+
+var _ fs.File = (*adapterFile)(nil)
+
+// Close implements fs.File.
+func (a *adapterFile) Close() error {
+	return a.file.Close()
+}
+
+// Read implements fs.File.
+func (a *adapterFile) Read(b []byte) (int, error) {
+	return a.file.Read(b)
+}
+
+// Stat implements fs.File.
+func (a *adapterFile) Stat() (fs.FileInfo, error) {
+	return a.info, nil
+}
+
+type adapterDirFile struct {
+	adapterFile
+	entries []fs.DirEntry
+}
+
+var _ fs.ReadDirFile = (*adapterDirFile)(nil)
+
+func makeDir(stat fs.FileInfo, entries []fs.DirEntry) *adapterDirFile {
+	return &adapterDirFile{
+		adapterFile: adapterFile{info: stat},
+		entries:     entries,
+	}
+}
+
+// Close implements fs.File.
+// Subtle: note that this is shadowing adapterFile.Close.
+func (a *adapterDirFile) Close() error {
+	return nil
+}
+
+// ReadDir implements fs.ReadDirFile.
+func (a *adapterDirFile) ReadDir(n int) ([]fs.DirEntry, error) {
+	if len(a.entries) == 0 && n > 0 {
+		return nil, io.EOF
+	}
+	if n <= 0 {
+		n = len(a.entries)
+	}
+	if n > len(a.entries) {
+		n = len(a.entries)
+	}
+	entries := a.entries[:n]
+	a.entries = a.entries[n:]
+	return entries, nil
+}

helper/iofs/iofs_test.go

@@ -0,0 +1,102 @@
+package iofs
+
+import (
+	"errors"
+	"io/fs"
+	"strings"
+	"testing"
+	"testing/fstest"
+
+	billyfs "github.com/go-git/go-billy/v5"
+	"github.com/go-git/go-billy/v5/memfs"
+)
+
+type errorList interface {
+	Unwrap() []error
+}
+
+type wrappedError interface {
+	Unwrap() error
+}
+
+// TestWithFSTest leverages the packaged Go fstest package, which seems comprehensive
+func TestWithFSTest(t *testing.T) {
+	t.Parallel()
+	memfs := memfs.New()
+	iofs := Wrap(memfs)
+
+	files := map[string]string{
+		"foo.txt":     "hello, world",
+		"bar.txt":     "goodbye, world",
+		"dir/baz.txt": "こんにちわ, world",
+	}
+	created_files := make([]string, 0, len(files))
+	for filename, contents := range files {
+		makeFile(memfs, t, filename, contents)
+		created_files = append(created_files, filename)
+	}
+
+	err := fstest.TestFS(iofs, created_files...)
+	if err != nil {
+		if unwrapped := errors.Unwrap(err); unwrapped != nil {
+			err = unwrapped
+		}
+		if errs, ok := err.(errorList); ok {
+			for _, e := range errs.Unwrap() {
+
+				if strings.Contains(e.Error(), "ModTime") {
+					// Memfs returns the current time for Stat().ModTime(), which triggers
+					// a diff complaint in fstest.  We can ignore this, or store modtimes
+					// for every file in Memfs (at a cost of 16 bytes / file).
+					t.Log("Skipping ModTime error (ok).")
+				} else {
+					t.Errorf("Unexpected fstest error: %v", e)
+				}
+			}
+		} else {
+			t.Fatalf("Failed to test fs:\n%v", err)
+		}
+	}
+}
+
+func TestDeletes(t *testing.T) {
+	t.Parallel()
+	memfs := memfs.New()
+	iofs := Wrap(memfs).(fs.ReadFileFS)
+
+	makeFile(memfs, t, "foo.txt", "hello, world")
+	makeFile(memfs, t, "deleted", "nothing to see")
+
+	if _, err := iofs.ReadFile("nonexistent"); err == nil {
+		t.Errorf("expected error for nonexistent file")
+	}
+
+	data, err := iofs.ReadFile("deleted")
+	if err != nil {
+		t.Fatalf("failed to read file before delete: %v", err)
+	}
+	if string(data) != "nothing to see" {
+		t.Errorf("unexpected contents before delete: %v", data)
+	}
+
+	if err := memfs.Remove("deleted"); err != nil {
+		t.Fatalf("failed to remove file: %v", err)
+	}
+
+	if _, err = iofs.ReadFile("deleted"); err == nil {
+		t.Errorf("file existed after delete!")
+	}
+}
+
+func makeFile(fs billyfs.Basic, t *testing.T, filename string, contents string) {
+	t.Helper()
+	file, err := fs.Create(filename)
+	if err != nil {
+		t.Fatalf("failed to create file %s: %v", filename, err)
+	}
+	defer file.Close()
+	_, err = file.Write([]byte(contents))
+	if err != nil {
+		t.Fatalf("failed to write to file %s: %v", filename, err)
+	}
+}