Hulk did something

[bytom/vapor.git] / vendor / github.com / spf13 / afero / regexpfs.go

diff --git a/vendor/github.com/spf13/afero/regexpfs.go b/vendor/github.com/spf13/afero/regexpfs.go
new file mode 100644 (file)
index 0000000..9d92dbc
--- /dev/null
+++ b/vendor/github.com/spf13/afero/regexpfs.go
@@ -0,0 +1,214 @@
+package afero
+
+import (
+       "os"
+       "regexp"
+       "syscall"
+       "time"
+)
+
+// The RegexpFs filters files (not directories) by regular expression. Only
+// files matching the given regexp will be allowed, all others get a ENOENT error (
+// "No such file or directory").
+//
+type RegexpFs struct {
+       re     *regexp.Regexp
+       source Fs
+}
+
+func NewRegexpFs(source Fs, re *regexp.Regexp) Fs {
+       return &RegexpFs{source: source, re: re}
+}
+
+type RegexpFile struct {
+       f  File
+       re *regexp.Regexp
+}
+
+func (r *RegexpFs) matchesName(name string) error {
+       if r.re == nil {
+               return nil
+       }
+       if r.re.MatchString(name) {
+               return nil
+       }
+       return syscall.ENOENT
+}
+
+func (r *RegexpFs) dirOrMatches(name string) error {
+       dir, err := IsDir(r.source, name)
+       if err != nil {
+               return err
+       }
+       if dir {
+               return nil
+       }
+       return r.matchesName(name)
+}
+
+func (r *RegexpFs) Chtimes(name string, a, m time.Time) error {
+       if err := r.dirOrMatches(name); err != nil {
+               return err
+       }
+       return r.source.Chtimes(name, a, m)
+}
+
+func (r *RegexpFs) Chmod(name string, mode os.FileMode) error {
+       if err := r.dirOrMatches(name); err != nil {
+               return err
+       }
+       return r.source.Chmod(name, mode)
+}
+
+func (r *RegexpFs) Name() string {
+       return "RegexpFs"
+}
+
+func (r *RegexpFs) Stat(name string) (os.FileInfo, error) {
+       if err := r.dirOrMatches(name); err != nil {
+               return nil, err
+       }
+       return r.source.Stat(name)
+}
+
+func (r *RegexpFs) Rename(oldname, newname string) error {
+       dir, err := IsDir(r.source, oldname)
+       if err != nil {
+               return err
+       }
+       if dir {
+               return nil
+       }
+       if err := r.matchesName(oldname); err != nil {
+               return err
+       }
+       if err := r.matchesName(newname); err != nil {
+               return err
+       }
+       return r.source.Rename(oldname, newname)
+}
+
+func (r *RegexpFs) RemoveAll(p string) error {
+       dir, err := IsDir(r.source, p)
+       if err != nil {
+               return err
+       }
+       if !dir {
+               if err := r.matchesName(p); err != nil {
+                       return err
+               }
+       }
+       return r.source.RemoveAll(p)
+}
+
+func (r *RegexpFs) Remove(name string) error {
+       if err := r.dirOrMatches(name); err != nil {
+               return err
+       }
+       return r.source.Remove(name)
+}
+
+func (r *RegexpFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
+       if err := r.dirOrMatches(name); err != nil {
+               return nil, err
+       }
+       return r.source.OpenFile(name, flag, perm)
+}
+
+func (r *RegexpFs) Open(name string) (File, error) {
+       dir, err := IsDir(r.source, name)
+       if err != nil {
+               return nil, err
+       }
+       if !dir {
+               if err := r.matchesName(name); err != nil {
+                       return nil, err
+               }
+       }
+       f, err := r.source.Open(name)
+       return &RegexpFile{f: f, re: r.re}, nil
+}
+
+func (r *RegexpFs) Mkdir(n string, p os.FileMode) error {
+       return r.source.Mkdir(n, p)
+}
+
+func (r *RegexpFs) MkdirAll(n string, p os.FileMode) error {
+       return r.source.MkdirAll(n, p)
+}
+
+func (r *RegexpFs) Create(name string) (File, error) {
+       if err := r.matchesName(name); err != nil {
+               return nil, err
+       }
+       return r.source.Create(name)
+}
+
+func (f *RegexpFile) Close() error {
+       return f.f.Close()
+}
+
+func (f *RegexpFile) Read(s []byte) (int, error) {
+       return f.f.Read(s)
+}
+
+func (f *RegexpFile) ReadAt(s []byte, o int64) (int, error) {
+       return f.f.ReadAt(s, o)
+}
+
+func (f *RegexpFile) Seek(o int64, w int) (int64, error) {
+       return f.f.Seek(o, w)
+}
+
+func (f *RegexpFile) Write(s []byte) (int, error) {
+       return f.f.Write(s)
+}
+
+func (f *RegexpFile) WriteAt(s []byte, o int64) (int, error) {
+       return f.f.WriteAt(s, o)
+}
+
+func (f *RegexpFile) Name() string {
+       return f.f.Name()
+}
+
+func (f *RegexpFile) Readdir(c int) (fi []os.FileInfo, err error) {
+       var rfi []os.FileInfo
+       rfi, err = f.f.Readdir(c)
+       if err != nil {
+               return nil, err
+       }
+       for _, i := range rfi {
+               if i.IsDir() || f.re.MatchString(i.Name()) {
+                       fi = append(fi, i)
+               }
+       }
+       return fi, nil
+}
+
+func (f *RegexpFile) Readdirnames(c int) (n []string, err error) {
+       fi, err := f.Readdir(c)
+       if err != nil {
+               return nil, err
+       }
+       for _, s := range fi {
+               n = append(n, s.Name())
+       }
+       return n, nil
+}
+
+func (f *RegexpFile) Stat() (os.FileInfo, error) {
+       return f.f.Stat()
+}
+
+func (f *RegexpFile) Sync() error {
+       return f.f.Sync()
+}
+
+func (f *RegexpFile) Truncate(s int64) error {
+       return f.f.Truncate(s)
+}
+
+func (f *RegexpFile) WriteString(s string) (int, error) {
+       return f.f.WriteString(s)
+}