vendor/github.com/spf13/afero/iofs.go
changeset 260 445e01aede7e
parent 256 6d9efbef00a9
equal deleted inserted replaced
259:db4911b0c721 260:445e01aede7e
       
     1 //go:build go1.16
     1 // +build go1.16
     2 // +build go1.16
     2 
     3 
     3 package afero
     4 package afero
     4 
     5 
     5 import (
     6 import (
     6 	"io"
     7 	"io"
     7 	"io/fs"
     8 	"io/fs"
     8 	"os"
     9 	"os"
     9 	"path"
    10 	"path"
       
    11 	"sort"
    10 	"time"
    12 	"time"
       
    13 
       
    14 	"github.com/spf13/afero/internal/common"
    11 )
    15 )
    12 
    16 
    13 // IOFS adopts afero.Fs to stdlib io/fs.FS
    17 // IOFS adopts afero.Fs to stdlib io/fs.FS
    14 type IOFS struct {
    18 type IOFS struct {
    15 	Fs
    19 	Fs
    64 
    68 
    65 	return items, nil
    69 	return items, nil
    66 }
    70 }
    67 
    71 
    68 func (iofs IOFS) ReadDir(name string) ([]fs.DirEntry, error) {
    72 func (iofs IOFS) ReadDir(name string) ([]fs.DirEntry, error) {
    69 	items, err := ReadDir(iofs.Fs, name)
    73 	f, err := iofs.Fs.Open(name)
    70 	if err != nil {
    74 	if err != nil {
    71 		return nil, iofs.wrapError("readdir", name, err)
    75 		return nil, iofs.wrapError("readdir", name, err)
    72 	}
    76 	}
       
    77 
       
    78 	defer f.Close()
       
    79 
       
    80 	if rdf, ok := f.(fs.ReadDirFile); ok {
       
    81 		items, err := rdf.ReadDir(-1)
       
    82 		if err != nil {
       
    83 			return nil, iofs.wrapError("readdir", name, err)
       
    84 		}
       
    85 		sort.Slice(items, func(i, j int) bool { return items[i].Name() < items[j].Name() })
       
    86 		return items, nil
       
    87 	}
       
    88 
       
    89 	items, err := f.Readdir(-1)
       
    90 	if err != nil {
       
    91 		return nil, iofs.wrapError("readdir", name, err)
       
    92 	}
       
    93 	sort.Sort(byName(items))
    73 
    94 
    74 	ret := make([]fs.DirEntry, len(items))
    95 	ret := make([]fs.DirEntry, len(items))
    75 	for i := range items {
    96 	for i := range items {
    76 		ret[i] = dirEntry{items[i]}
    97 		ret[i] = common.FileInfoDirEntry{FileInfo: items[i]}
    77 	}
    98 	}
    78 
    99 
    79 	return ret, nil
   100 	return ret, nil
    80 }
   101 }
    81 
   102 
   106 		Path: path,
   127 		Path: path,
   107 		Err:  err,
   128 		Err:  err,
   108 	}
   129 	}
   109 }
   130 }
   110 
   131 
   111 // dirEntry provides adapter from os.FileInfo to fs.DirEntry
       
   112 type dirEntry struct {
       
   113 	fs.FileInfo
       
   114 }
       
   115 
       
   116 var _ fs.DirEntry = dirEntry{}
       
   117 
       
   118 func (d dirEntry) Type() fs.FileMode { return d.FileInfo.Mode().Type() }
       
   119 
       
   120 func (d dirEntry) Info() (fs.FileInfo, error) { return d.FileInfo, nil }
       
   121 
       
   122 // readDirFile provides adapter from afero.File to fs.ReadDirFile needed for correct Open
   132 // readDirFile provides adapter from afero.File to fs.ReadDirFile needed for correct Open
   123 type readDirFile struct {
   133 type readDirFile struct {
   124 	File
   134 	File
   125 }
   135 }
   126 
   136 
   132 		return nil, err
   142 		return nil, err
   133 	}
   143 	}
   134 
   144 
   135 	ret := make([]fs.DirEntry, len(items))
   145 	ret := make([]fs.DirEntry, len(items))
   136 	for i := range items {
   146 	for i := range items {
   137 		ret[i] = dirEntry{items[i]}
   147 		ret[i] = common.FileInfoDirEntry{FileInfo: items[i]}
   138 	}
   148 	}
   139 
   149 
   140 	return ret, nil
   150 	return ret, nil
   141 }
   151 }
   142 
   152