From b80c56fef3dac9f5c7032b7bacd72083b8dddeae Mon Sep 17 00:00:00 2001 From: Evan Anderson Date: Fri, 13 Sep 2024 13:23:18 -0700 Subject: [PATCH] Add wrapper for io/fs Signed-off-by: Evan Anderson --- helper/iofs/iofs.go | 142 +++++++++++++++++++++++++++++++++++++++ helper/iofs/iofs_test.go | 102 ++++++++++++++++++++++++++++ 2 files changed, 244 insertions(+) create mode 100644 helper/iofs/iofs.go create mode 100644 helper/iofs/iofs_test.go diff --git a/helper/iofs/iofs.go b/helper/iofs/iofs.go new file mode 100644 index 0000000..6c71078 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/helper/iofs/iofs_test.go b/helper/iofs/iofs_test.go new file mode 100644 index 0000000..65d62fb --- /dev/null +++ b/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) + } +}