replace afero module

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

2 files changed, 68 insertions, 76 deletions

diff --git a/env/env.go b/env/env.go
index b8bbbfa5..e9ab3632 100644
--- a/env/env.go
+++ b/env/env.go
@@ -2,11 +2,12 @@
 package env
 
 import (
-	"io"
+	"io/fs"
 	"os"
 	"strings"
 
-	"github.com/spf13/afero"
+	osfs "github.com/hack-pad/hackpadfs/os"
+	"github.com/hairyhenderson/gomplate/v4/internal/datafs"
 )
 
 // Getenv - retrieves the value of the environment variable named by the key.
@@ -14,24 +15,26 @@ import (
 // referenced file will be read into the value.
 // Otherwise the provided default (or an emptry string) is returned.
 func Getenv(key string, def ...string) string {
-	return getenvVFS(afero.NewOsFs(), key, def...)
+	fsys := datafs.WrapWdFS(osfs.NewFS())
+	return getenvVFS(fsys, key, def...)
 }
 
 // ExpandEnv - like os.ExpandEnv, except supports `_FILE` vars as well
 func ExpandEnv(s string) string {
-	return expandEnvVFS(afero.NewOsFs(), s)
+	fsys := datafs.WrapWdFS(osfs.NewFS())
+	return expandEnvVFS(fsys, s)
 }
 
 // expandEnvVFS -
-func expandEnvVFS(fs afero.Fs, s string) string {
+func expandEnvVFS(fsys fs.FS, s string) string {
 	return os.Expand(s, func(s string) string {
-		return getenvVFS(fs, s)
+		return getenvVFS(fsys, s)
 	})
 }
 
 // getenvVFS - a convenience function intended for internal use only!
-func getenvVFS(fs afero.Fs, key string, def ...string) string {
-	val := getenvFile(fs, key)
+func getenvVFS(fsys fs.FS, key string, def ...string) string {
+	val := getenvFile(fsys, key)
 	if val == "" && len(def) > 0 {
 		return def[0]
 	}
@@ -39,7 +42,7 @@ func getenvVFS(fs afero.Fs, key string, def ...string) string {
 	return val
 }
 
-func getenvFile(fs afero.Fs, key string) string {
+func getenvFile(fsys fs.FS, key string) string {
 	val := os.Getenv(key)
 	if val != "" {
 		return val
@@ -47,7 +50,7 @@ func getenvFile(fs afero.Fs, key string) string {
 
 	p := os.Getenv(key + "_FILE")
 	if p != "" {
-		val, err := readFile(fs, p)
+		val, err := readFile(fsys, p)
 		if err != nil {
 			return ""
 		}
@@ -57,14 +60,11 @@ func getenvFile(fs afero.Fs, key string) string {
 	return ""
 }
 
-func readFile(fs afero.Fs, p string) (string, error) {
-	f, err := fs.OpenFile(p, os.O_RDONLY, 0)
-	if err != nil {
-		return "", err
-	}
-	b, err := io.ReadAll(f)
+func readFile(fsys fs.FS, p string) (string, error) {
+	b, err := fs.ReadFile(fsys, p)
 	if err != nil {
 		return "", err
 	}
+
 	return string(b), nil
 }
diff --git a/env/env_test.go b/env/env_test.go
index 59bf4048..faaaa603 100644
--- a/env/env_test.go
+++ b/env/env_test.go
@@ -2,10 +2,13 @@ package env
 
 import (
 	"errors"
+	"io/fs"
 	"os"
 	"testing"
+	"testing/fstest"
 
-	"github.com/spf13/afero"
+	"github.com/hack-pad/hackpadfs"
+	"github.com/hairyhenderson/gomplate/v4/internal/datafs"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -17,22 +20,22 @@ func TestGetenv(t *testing.T) {
 }
 
 func TestGetenvFile(t *testing.T) {
-	fs := afero.NewMemMapFs()
-	_ = fs.Mkdir("/tmp", 0777)
-	f, _ := fs.Create("/tmp/foo")
-	_, _ = f.Write([]byte("foo"))
-
-	defer os.Unsetenv("FOO_FILE")
-	os.Setenv("FOO_FILE", "/tmp/foo")
-	assert.Equal(t, "foo", getenvVFS(fs, "FOO", "bar"))
-
-	os.Setenv("FOO_FILE", "/tmp/missing")
-	assert.Equal(t, "bar", getenvVFS(fs, "FOO", "bar"))
-
-	_, _ = fs.Create("/tmp/unreadable")
-	fs = writeOnly(fs)
-	os.Setenv("FOO_FILE", "/tmp/unreadable")
-	assert.Equal(t, "bar", getenvVFS(fs, "FOO", "bar"))
+	fsys := fs.FS(fstest.MapFS{
+		"tmp":            &fstest.MapFile{Mode: fs.ModeDir | 0o777},
+		"tmp/foo":        &fstest.MapFile{Data: []byte("foo")},
+		"tmp/unreadable": &fstest.MapFile{Data: []byte("foo"), Mode: 0o000},
+	})
+	fsys = datafs.WrapWdFS(fsys)
+
+	t.Setenv("FOO_FILE", "/tmp/foo")
+	assert.Equal(t, "foo", getenvVFS(fsys, "FOO", "bar"))
+
+	t.Setenv("FOO_FILE", "/tmp/missing")
+	assert.Equal(t, "bar", getenvVFS(fsys, "FOO", "bar"))
+
+	fsys = writeOnly(fsys)
+	t.Setenv("FOO_FILE", "/tmp/unreadable")
+	assert.Equal(t, "bar", getenvVFS(fsys, "FOO", "bar"))
 }
 
 func TestExpandEnv(t *testing.T) {
@@ -44,73 +47,62 @@ func TestExpandEnv(t *testing.T) {
 }
 
 func TestExpandEnvFile(t *testing.T) {
-	fs := afero.NewMemMapFs()
-	_ = fs.Mkdir("/tmp", 0777)
-	f, _ := fs.Create("/tmp/foo")
-	_, _ = f.Write([]byte("foo"))
-
-	defer os.Unsetenv("FOO_FILE")
-	os.Setenv("FOO_FILE", "/tmp/foo")
-	assert.Equal(t, "foo is foo", expandEnvVFS(fs, "foo is $FOO"))
-
-	os.Setenv("FOO_FILE", "/tmp/missing")
-	assert.Equal(t, "empty", expandEnvVFS(fs, "${FOO}empty"))
-
-	_, _ = fs.Create("/tmp/unreadable")
-	fs = writeOnly(fs)
-	os.Setenv("FOO_FILE", "/tmp/unreadable")
-	assert.Equal(t, "", expandEnvVFS(fs, "${FOO}"))
-}
+	fsys := fs.FS(fstest.MapFS{
+		"tmp":            &fstest.MapFile{Mode: fs.ModeDir | 0o777},
+		"tmp/foo":        &fstest.MapFile{Data: []byte("foo")},
+		"tmp/unreadable": &fstest.MapFile{Data: []byte("foo"), Mode: 0o000},
+	})
+	fsys = datafs.WrapWdFS(fsys)
 
-// Maybe extract this into a separate package sometime...
-// writeOnly - represents a filesystem that's writeable, but read operations fail
-func writeOnly(fs afero.Fs) afero.Fs {
-	return &woFS{fs}
-}
+	t.Setenv("FOO_FILE", "/tmp/foo")
+	assert.Equal(t, "foo is foo", expandEnvVFS(fsys, "foo is $FOO"))
 
-type woFS struct {
-	afero.Fs
-}
+	t.Setenv("FOO_FILE", "/tmp/missing")
+	assert.Equal(t, "empty", expandEnvVFS(fsys, "${FOO}empty"))
 
-func (fs woFS) Remove(name string) error {
-	return fs.Fs.Remove(name)
+	fsys = writeOnly(fsys)
+	t.Setenv("FOO_FILE", "/tmp/unreadable")
+	assert.Equal(t, "", expandEnvVFS(fsys, "${FOO}"))
 }
 
-func (fs woFS) Rename(oldpath, newpath string) error {
-	return fs.Fs.Rename(oldpath, newpath)
+// Maybe extract this into a separate package sometime...
+// writeOnly - represents a filesystem that's writeable, but read operations fail
+func writeOnly(fsys fs.FS) fs.FS {
+	return &woFS{fsys}
 }
 
-func (fs woFS) Mkdir(name string, perm os.FileMode) error {
-	return fs.Fs.Mkdir(name, perm)
+type woFS struct {
+	fsys fs.FS
 }
 
-func (fs woFS) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
-	f, err := fs.Fs.OpenFile(name, flag, perm)
-	if err != nil {
-		return writeOnlyFile(f), err
-	}
-	return writeOnlyFile(f), nil
+func (fsys woFS) Open(name string) (fs.File, error) {
+	f, err := fsys.fsys.Open(name)
+	return writeOnlyFile(f), err
 }
 
-func (fs woFS) ReadDir(_ string) ([]os.FileInfo, error) {
+func (fsys woFS) ReadDir(_ string) ([]fs.DirEntry, error) {
 	return nil, ErrWriteOnly
 }
 
-func (fs woFS) Stat(_ string) (os.FileInfo, error) {
+func (fsys woFS) Stat(_ string) (fs.FileInfo, error) {
 	return nil, ErrWriteOnly
 }
 
-func writeOnlyFile(f afero.File) afero.File {
+func writeOnlyFile(f fs.File) fs.File {
+	if f == nil {
+		return nil
+	}
+
 	return &woFile{f}
 }
 
 type woFile struct {
-	afero.File
+	fs.File
 }
 
-// Write is disabled and returns ErrWriteOnly
+// Write -
 func (f woFile) Write(p []byte) (n int, err error) {
-	return f.File.Write(p)
+	return hackpadfs.WriteFile(f.File, p)
 }
 
 // Read is disabled and returns ErrWriteOnly