Migrate all backends & readme to use constructorish New...
diff --git a/README.md b/README.md
index f63e748..56d5a0b 100644
--- a/README.md
+++ b/README.md
@@ -61,11 +61,11 @@
First define a package variable and set it to a pointer to a filesystem.
```go
-var AppFs afero.Fs = &afero.MemMapFs{}
+var AppFs afero.Fs = afero.NewMemMapFs()
or
-var AppFs afero.Fs = &afero.OsFs{}
+var AppFs afero.Fs = afero.NewOsFs()
```
It is important to note that if you repeat the composite literal you
will be using a completely new and isolated filesystem. In the case of
@@ -166,7 +166,7 @@
### Calling via Afero
```go
-fs := new(afero.MemMapFs)
+fs := afero.NewMemMapFs
afs := &Afero{Fs: fs}
f, err := afs.TempFile("", "ioutil-test")
```
@@ -187,39 +187,28 @@
* No test cleanup needed
One way to accomplish this is to define a variable as mentioned above.
-In your application this will be set to &afero.OsFs{} during testing you
-can set it to &afero.MemMapFs{}.
+In your application this will be set to afero.NewOsFs() during testing you
+can set it to afero.NewMemMapFs().
It wouldn't be uncommon to have each test initialize a blank slate memory
-backend. To do this I would define my `appFS = &afero.OsFs{}` somewhere
+backend. To do this I would define my `appFS = afero.NewOsFs()` somewhere
appropriate in my application code. This approach ensures that Tests are order
independent, with no test relying on the state left by an earlier test.
Then in my tests I would initialize a new MemMapFs for each test:
```go
func TestExist(t *testing.T) {
- appFS = &afero.MemMapFs{}
+ appFS = afero.NewMemMapFs()
// create test files and directories
appFS.MkdirAll("src/a", 0755))
appFS.WriteFile("src/a/b", []byte("file b"), 0644)
appFS.WriteFile("src/c", []byte("file c"), 0644)
- testExistence("src/c", true, t)
-}
-
-func testExistence(name string, e bool, t *testing.T) {
- _, err := appFS.Stat(name)
+ _, err := appFS.Stat("src/c")
if os.IsNotExist(err) {
- if e {
- t.Errorf("file \"%s\" does not exist.\n", name)
- }
- } else if err != nil {
- panic(err)
- } else {
- if !e {
- t.Errorf("file \"%s\" exists.\n", name)
- }
+ t.Errorf("file \"%s\" does not exist.\n", name)
}
}
+
```
# Available Backends
@@ -233,6 +222,11 @@
calls. It also makes it trivial to have your code use the OS during
operation and a mock filesystem during testing or as needed.
+```go
+appfs := NewOsFs()
+appfs.MkdirAll("src/a", 0755))
+```
+
## Memory Backed Storage
### MemMapFs
@@ -242,6 +236,11 @@
necessary. It is fully concurrent and will work within go routines
safely.
+```go
+mm := NewMemMapFs()
+mm.MkdirAll("src/a", 0755))
+```
+
#### InMemoryFile
As part of MemMapFs, Afero also provides an atomic, fully concurrent memory
@@ -265,7 +264,7 @@
the base path before calling the source Fs.
```go
-bp := &BasePathFs{source: &OsFs{}, path: "/base/path"}
+bp := NewBasePathFs(NewOsFs(), "/base/path")
```
### ReadOnlyFs
@@ -273,7 +272,7 @@
A thin wrapper around the source Fs providing a read only view.
```go
-fs := &ReadOnlyFs{source: &OsFs{}}
+fs := NewReadOnlyFs(NewOsFs())
_, err := fs.Create("/file.txt")
// err = syscall.EPERM
```
@@ -286,7 +285,7 @@
Directories are not filtered.
```go
-fs := &RegexpFs{re: regexp.MustCompile(`\.txt$`), source: &MemMapFs{}}
+fs := NewRegexpFs(NewMemMapFs(), regexp.MustCompile(`\.txt$`))
_, err := fs.Create("/file.html")
// err = syscall.ENOENT
```
@@ -303,7 +302,7 @@
Any Afero FileSystem can be used as an httpFs.
```go
-httpFs := &afero.HttpFs{source: <ExistingFS>}
+httpFs := afero.NewHttpFs(<ExistingFS>)
fileserver := http.FileServer(httpFs.Dir(<PATH>)))
http.Handle("/", fileserver)
```
@@ -335,9 +334,9 @@
caching layer.
```go
-base := &OsFs{}
-layer := &MemMapFs{}
-ufs := &CacheOnReadFs{base: base, layer: layer, cacheTime: 100 * time.Second}
+base := NewOsFs()
+layer := NewMemMapFs()
+ufs := NewCacheOnReadFs(base, layer, 100 * time.Second)
```
### CopyOnWriteFs()
@@ -361,17 +360,17 @@
The writable overlay layer is currently limited to MemMapFs.
```go
- base := &OsFs{}
- roBase := &ReadOnlyFs{source: base}
- ufs := &CopyOnWriteFs{base: roBase, layer: &MemMapFs{}}
+ base := NewOsFs()
+ roBase := NewReadOnlyFs(base)
+ ufs := NewCopyOnWriteFs(roBase, NewMemMapFs())
fh, _ = ufs.Create("/home/test/file2.txt")
fh.WriteString("This is a test")
fh.Close()
```
-In this example all write operations will only occur in memory (&MemMapFs{})
-leaving the base filesystem (&OsFs) untouched.
+In this example all write operations will only occur in memory (MemMapFs)
+leaving the base filesystem (OsFs) untouched.
## Desired/possible backends
diff --git a/basepath.go b/basepath.go
index 083199f..b9fa145 100644
--- a/basepath.go
+++ b/basepath.go
@@ -20,6 +20,10 @@
path string
}
+func NewBasePathFs(source Fs, path string) Fs {
+ return &BasePathFs{source: source, path: path}
+}
+
// on a file outside the base path it returns the given file name and an error,
// else the given file with the base path prepended
func (b *BasePathFs) RealPath(name string) (path string, err error) {
diff --git a/basepath_test.go b/basepath_test.go
index 0db6783..ee9f2d3 100644
--- a/basepath_test.go
+++ b/basepath_test.go
@@ -7,7 +7,7 @@
func TestBasePath(t *testing.T) {
baseFs := &MemMapFs{}
baseFs.MkdirAll("/base/path/tmp", 0777)
- bp := &BasePathFs{source: baseFs, path: "/base/path"}
+ bp := NewBasePathFs(baseFs, "/base/path")
if _, err := bp.Create("/tmp/foo"); err != nil {
t.Errorf("Failed to set real path")
diff --git a/httpFs.go b/httpFs.go
index c7f1955..c421936 100644
--- a/httpFs.go
+++ b/httpFs.go
@@ -20,6 +20,7 @@
"path"
"path/filepath"
"strings"
+ "time"
)
type httpDir struct {
@@ -48,6 +49,10 @@
source Fs
}
+func NewHttpFs(source Fs) *HttpFs {
+ return &HttpFs{source: source}
+}
+
func (h HttpFs) Dir(s string) *httpDir {
return &httpDir{basePath: s, fs: h}
}
@@ -58,6 +63,14 @@
return h.source.Create(name)
}
+func (h HttpFs) Chmod(name string, mode os.FileMode) error {
+ return h.source.Chmod(name, mode)
+}
+
+func (h HttpFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
+ return h.source.Chtimes(name, atime, mtime)
+}
+
func (h HttpFs) Mkdir(name string, perm os.FileMode) error {
return h.source.Mkdir(name, perm)
}
diff --git a/memmap.go b/memmap.go
index 21fbe67..f577ac8 100644
--- a/memmap.go
+++ b/memmap.go
@@ -31,6 +31,10 @@
init sync.Once
}
+func NewMemMapFs() Fs {
+ return &MemMapFs{}
+}
+
var memfsInit sync.Once
func (m *MemMapFs) getData() map[string]*mem.FileData {
diff --git a/memmap_test.go b/memmap_test.go
index bb2769b..6e0f826 100644
--- a/memmap_test.go
+++ b/memmap_test.go
@@ -34,7 +34,7 @@
func TestPathErrors(t *testing.T) {
path := filepath.Join(".", "some", "path")
path2 := filepath.Join(".", "different", "path")
- fs := &MemMapFs{}
+ fs := NewMemMapFs()
perm := os.FileMode(0755)
// relevant functions:
diff --git a/os.go b/os.go
index 30f23ca..4c9c0f6 100644
--- a/os.go
+++ b/os.go
@@ -25,6 +25,10 @@
// (http://golang.org/pkg/os/).
type OsFs struct{}
+func NewOsFs() Fs {
+ return &OsFs{}
+}
+
func (OsFs) Name() string { return "OsFs" }
func (OsFs) Create(name string) (File, error) {
diff --git a/readonlyfs.go b/readonlyfs.go
index fa23703..f1fa55b 100644
--- a/readonlyfs.go
+++ b/readonlyfs.go
@@ -10,6 +10,10 @@
source Fs
}
+func NewReadOnlyFs(source Fs) Fs {
+ return &ReadOnlyFs{source: source}
+}
+
func (r *ReadOnlyFs) ReadDir(name string) ([]os.FileInfo, error) {
return ReadDir(r.source, name)
}
diff --git a/regexpfs.go b/regexpfs.go
index 071b1bd..9d92dbc 100644
--- a/regexpfs.go
+++ b/regexpfs.go
@@ -16,6 +16,10 @@
source Fs
}
+func NewRegexpFs(source Fs, re *regexp.Regexp) Fs {
+ return &RegexpFs{source: source, re: re}
+}
+
type RegexpFile struct {
f File
re *regexp.Regexp
diff --git a/ro_regexp_test.go b/ro_regexp_test.go
index d408fab..ef8a35d 100644
--- a/ro_regexp_test.go
+++ b/ro_regexp_test.go
@@ -20,7 +20,7 @@
fh.Write([]byte("content here"))
fh.Close()
- fs := &ReadOnlyFs{source: mfs}
+ fs := NewReadOnlyFs(mfs)
err = fs.Remove("/file.txt")
if err == nil {
t.Errorf("Did not fail to remove file")
@@ -51,7 +51,7 @@
}
func TestFilterRegexp(t *testing.T) {
- fs := &RegexpFs{re: regexp.MustCompile(`\.txt$`), source: &MemMapFs{}}
+ fs := NewRegexpFs(&MemMapFs{}, regexp.MustCompile(`\.txt$`))
_, err := fs.Create("/file.html")
if err == nil {
diff --git a/union.go b/union.go
index 977232b..a854e5b 100644
--- a/union.go
+++ b/union.go
@@ -21,8 +21,8 @@
// successful read in the overlay will move the cursor position in the base layer
// by the number of bytes read.
type UnionFile struct {
- layer File
base File
+ layer File
off int
files []os.FileInfo
}
diff --git a/union_cache.go b/union_cache.go
index aadcca9..d742425 100644
--- a/union_cache.go
+++ b/union_cache.go
@@ -25,6 +25,10 @@
cacheTime time.Duration
}
+func NewCacheOnReadFs(base Fs, layer Fs, cacheTime time.Duration) Fs {
+ return &CacheOnReadFs{base: base, layer: layer, cacheTime: cacheTime}
+}
+
type cacheState int
const (
diff --git a/union_cow.go b/union_cow.go
index d01b7ae..176aeb7 100644
--- a/union_cow.go
+++ b/union_cow.go
@@ -22,6 +22,10 @@
layer Fs
}
+func NewCopyOnWriteFs(base Fs, layer Fs) Fs {
+ return &CopyOnWriteFs{base: base, layer: layer}
+}
+
func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
if _, err := u.layer.Stat(name); err == nil {
return false, nil
diff --git a/union_test.go b/union_test.go
index 221d032..e8d7be6 100644
--- a/union_test.go
+++ b/union_test.go
@@ -11,7 +11,7 @@
base := &MemMapFs{}
roBase := &ReadOnlyFs{source: base}
- ufs := &CopyOnWriteFs{base: roBase, layer: &MemMapFs{}}
+ ufs := NewCopyOnWriteFs(roBase, &MemMapFs{})
base.MkdirAll("/home/test", 0777)
fh, _ := base.Create("/home/test/file.txt")
@@ -86,7 +86,7 @@
base := &MemMapFs{}
layer := &MemMapFs{}
- ufs := &CacheOnReadFs{base: base, layer: layer, cacheTime: 0}
+ ufs := NewCacheOnReadFs(base, layer, 0)
base.Mkdir("/data", 0777)
