mirror of https://github.com/spf13/afero.git
139 lines
2.7 KiB
Go
139 lines
2.7 KiB
Go
// +build go1.16
|
|
|
|
package afero
|
|
|
|
import (
|
|
"io/fs"
|
|
"path"
|
|
)
|
|
|
|
// IOFS adopts afero.Fs to stdlib io/fs.FS
|
|
type IOFS struct {
|
|
Fs
|
|
}
|
|
|
|
func NewIOFS(fs Fs) IOFS {
|
|
return IOFS{Fs: fs}
|
|
}
|
|
|
|
var (
|
|
_ fs.FS = IOFS{}
|
|
_ fs.GlobFS = IOFS{}
|
|
_ fs.ReadDirFS = IOFS{}
|
|
_ fs.ReadFileFS = IOFS{}
|
|
_ fs.StatFS = IOFS{}
|
|
_ fs.SubFS = IOFS{}
|
|
)
|
|
|
|
func (iofs IOFS) Open(name string) (fs.File, error) {
|
|
const op = "open"
|
|
|
|
// by convention for fs.FS implementations we should perform this check
|
|
if !fs.ValidPath(name) {
|
|
return nil, iofs.wrapError(op, name, fs.ErrInvalid)
|
|
}
|
|
|
|
file, err := iofs.Fs.Open(name)
|
|
if err != nil {
|
|
return nil, iofs.wrapError(op, name, err)
|
|
}
|
|
|
|
// file should implement fs.ReadDirFile
|
|
if _, ok := file.(fs.ReadDirFile); !ok {
|
|
file = readDirFile{file}
|
|
}
|
|
|
|
return file, nil
|
|
}
|
|
|
|
func (iofs IOFS) Glob(pattern string) ([]string, error) {
|
|
const op = "glob"
|
|
|
|
// afero.Glob does not perform this check but it's required for implementations
|
|
if _, err := path.Match(pattern, ""); err != nil {
|
|
return nil, iofs.wrapError(op, pattern, err)
|
|
}
|
|
|
|
items, err := Glob(iofs.Fs, pattern)
|
|
if err != nil {
|
|
return nil, iofs.wrapError(op, pattern, err)
|
|
}
|
|
|
|
return items, nil
|
|
}
|
|
|
|
func (iofs IOFS) ReadDir(name string) ([]fs.DirEntry, error) {
|
|
items, err := ReadDir(iofs.Fs, name)
|
|
if err != nil {
|
|
return nil, iofs.wrapError("readdir", name, err)
|
|
}
|
|
|
|
ret := make([]fs.DirEntry, len(items))
|
|
for i := range items {
|
|
ret[i] = dirEntry{items[i]}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func (iofs IOFS) ReadFile(name string) ([]byte, error) {
|
|
const op = "readfile"
|
|
|
|
if !fs.ValidPath(name) {
|
|
return nil, iofs.wrapError(op, name, fs.ErrInvalid)
|
|
}
|
|
|
|
bytes, err := ReadFile(iofs.Fs, name)
|
|
if err != nil {
|
|
return nil, iofs.wrapError(op, name, err)
|
|
}
|
|
|
|
return bytes, nil
|
|
}
|
|
|
|
func (iofs IOFS) Sub(dir string) (fs.FS, error) { return IOFS{NewBasePathFs(iofs.Fs, dir)}, nil }
|
|
|
|
func (IOFS) wrapError(op, path string, err error) error {
|
|
if _, ok := err.(*fs.PathError); ok {
|
|
return err // don't need to wrap again
|
|
}
|
|
|
|
return &fs.PathError{
|
|
Op: op,
|
|
Path: path,
|
|
Err: err,
|
|
}
|
|
}
|
|
|
|
// dirEntry provides adapter from os.FileInfo to fs.DirEntry
|
|
type dirEntry struct {
|
|
fs.FileInfo
|
|
}
|
|
|
|
var _ fs.DirEntry = dirEntry{}
|
|
|
|
func (d dirEntry) Type() fs.FileMode { return d.FileInfo.Mode().Type() }
|
|
|
|
func (d dirEntry) Info() (fs.FileInfo, error) { return d.FileInfo, nil }
|
|
|
|
// readDirFile provides adapter from afero.File to fs.ReadDirFile needed for correct Open
|
|
type readDirFile struct {
|
|
File
|
|
}
|
|
|
|
var _ fs.ReadDirFile = readDirFile{}
|
|
|
|
func (r readDirFile) ReadDir(n int) ([]fs.DirEntry, error) {
|
|
items, err := r.File.Readdir(n)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ret := make([]fs.DirEntry, len(items))
|
|
for i := range items {
|
|
ret[i] = dirEntry{items[i]}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|