Embed improvements

- Added a fsutil.Embed.Sub method
- The lang package loads from root FS directory instead of forcing resources/lang, unless the FS implements fsutil.WorkingDirDS

Author: System-Glitch

lang/lang.go

@@ -33,18 +33,18 @@ func New() *Languages {
 	return l
 }
 
-// LoadAllAvailableLanguages loads every language directory
-// in the "resources/lang" directory if it exists.
+// LoadAllAvailableLanguages loads every available language directory.
+// If the given FS implements `fsutil.WorkingDirFS`, the directory
+// used will be "<working directory>/resources/lang".
 func (l *Languages) LoadAllAvailableLanguages(fs fsutil.FS) error {
-	prefix := ""
+	langDirectory := "."
 	if wd, ok := fs.(fsutil.WorkingDirFS); ok {
 		workingDir, err := wd.Getwd()
 		if err != nil {
 			return errors.New(err)
 		}
-		prefix = workingDir + "/"
+		langDirectory = workingDir + "/resources/lang"
 	}
-	langDirectory := prefix + "resources/lang"
 	return l.LoadDirectory(fs, langDirectory)
 }
 
@@ -62,7 +62,8 @@ func (l *Languages) LoadDirectory(fs fsutil.FS, directory string) error {
 
 	for _, f := range files {
 		if f.IsDir() {
-			if err := l.load(fs, f.Name(), directory+"/"+f.Name()); err != nil {
+			path := lo.Ternary(directory == ".", f.Name(), directory+"/"+f.Name())
+			if err := l.load(fs, f.Name(), path); err != nil {
 				return err
 			}
 		}

lang/lang_test.go

@@ -74,6 +74,7 @@ func (suite *LangTestSuite) TestLoad() {
 		lines: map[string]string{
 			"malformed-request": "Malformed request",
 			"malformed-json":    "Malformed JSON",
+			"test-load":         "load UK",
 		},
 		validation: validationLines{
 			rules:  map[string]string{},
@@ -93,6 +94,7 @@ func (suite *LangTestSuite) TestLoad() {
 			"custom-line":       "Custom line",
 			"placeholder":       "Line with :placeholders",
 			"many-placeholders": "Line with :count :placeholders",
+			"test-load":         "load US",
 		},
 		validation: validationLines{
 			rules: map[string]string{

resources/lang/en-UK/locale.json

@@ -1,4 +1,5 @@
 {
     "malformed-request": "Malformed request",
-    "malformed-json": "Malformed JSON"
+    "malformed-json": "Malformed JSON",
+    "test-load": "load UK"
 }

resources/lang/en-US/locale.json

@@ -3,5 +3,6 @@
     "malformed-json": "Malformed JSON",
     "custom-line": "Custom line",
     "placeholder": "Line with :placeholders",
-    "many-placeholders": "Line with :count :placeholders"
+    "many-placeholders": "Line with :count :placeholders",
+    "test-load": "load US"
 }

server_test.go

@@ -120,10 +120,12 @@ func TestServer(t *testing.T) {
 		cfg.Set("database.options", "mode=memory")
 
 		logger := slog.New(slog.NewHandler(false, &bytes.Buffer{}))
+		langEmbed, err := fsutil.NewEmbed(resources).Sub("resources/lang")
+		assert.NoError(t, err)
 		opts := Options{
 			Config: cfg,
 			Logger: logger,
-			LangFS: fsutil.Embed{FS: resources},
+			LangFS: langEmbed,
 		}
 
 		server, err := New(opts)
@@ -137,6 +139,8 @@ func TestServer(t *testing.T) {
 		assert.Equal(t, "test_with_config", server.Config().GetString("app.name"))
 		assert.Equal(t, logger, server.Logger)
 		assert.ElementsMatch(t, []string{"en-US", "en-UK"}, server.Lang.GetAvailableLanguages())
+		assert.Equal(t, "load US", server.Lang.Get("en-US", "test-load"))
+		assert.Equal(t, "load UK", server.Lang.Get("en-UK", "test-load"))
 		assert.NotNil(t, server.DB())
 
 		assert.Nil(t, server.CloseDB())

util/fsutil/fsutil.go

@@ -1,7 +1,6 @@
 package fsutil
 
 import (
-	"embed"
 	"io"
 	"io/fs"
 	"net/http"
@@ -181,16 +180,46 @@ type RemoveFS interface {
 	RemoveAll(path string) error
 }
 
-// Embed is an extension of `embed.FS` implementing `fs.StatFS`.
+// Embed is an extension of aimed at improving `embed.FS` by
+// implementing `fs.StatFS` and a `Sub()` function.
 type Embed struct {
-	embed.FS
+	FS fs.ReadDirFS
+}
+
+// NewEmbed returns a new Embed with the given FS.
+func NewEmbed(fs fs.ReadDirFS) Embed {
+	return Embed{
+		FS: fs,
+	}
+}
+
+// Open opens the named file.
+//
+// When Open returns an error, it should be of type *PathError
+// with the Op field set to "open", the Path field set to name,
+// and the Err field describing the problem.
+//
+// Open should reject attempts to open names that do not satisfy
+// ValidPath(name), returning a *PathError with Err set to
+// ErrInvalid or ErrNotExist.
+func (e Embed) Open(name string) (fs.File, error) {
+	return e.FS.Open(name)
+}
+
+// ReadDir reads the named directory
+// and returns a list of directory entries sorted by filename.
+func (e Embed) ReadDir(name string) ([]fs.DirEntry, error) {
+	return e.FS.ReadDir(name)
 }
 
 // Stat returns a FileInfo describing the file.
 func (e Embed) Stat(name string) (fileinfo fs.FileInfo, err error) {
+	if statsFS, ok := e.FS.(fs.StatFS); ok {
+		return statsFS.Stat(name)
+	}
 	f, err := e.FS.Open(name)
 	if err != nil {
-		return nil, err
+		return nil, errors.New(err)
 	}
 	defer func() {
 		e := f.Close()
@@ -202,3 +231,17 @@ func (e Embed) Stat(name string) (fileinfo fs.FileInfo, err error) {
 	fileinfo, err = f.Stat()
 	return
 }
+
+// Sub returns an Embed FS corresponding to the subtree rooted at dir.
+// Returns and error if the underlying sub FS doesn't implement `fs.ReadDirFS`.
+func (e Embed) Sub(dir string) (Embed, error) {
+	sub, err := fs.Sub(e.FS, dir)
+	if err != nil {
+		return Embed{}, errors.NewSkip(err, 3)
+	}
+	subFS, ok := sub.(fs.ReadDirFS)
+	if !ok {
+		return Embed{}, errors.NewSkip("fsutil.Embed: cannot Sub, underlying sub FS doesn't implement fsutil.FS", 3)
+	}
+	return Embed{FS: subFS}, nil
+}

util/fsutil/fsutil_test.go

@@ -14,11 +14,15 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+	"time"
 
 	_ "embed"
 
 	"github.com/stretchr/testify/assert"
+	"goyave.dev/goyave/v5/util/errors"
 	"goyave.dev/goyave/v5/util/fsutil/osfs"
+
+	stderrors "errors"
 )
 
 func deleteFile(path string) {
@@ -243,8 +247,52 @@ func TestParseMultipartFiles(t *testing.T) {
 //go:embed osfs
 var resources embed.FS
 
+type testStatFS struct {
+	embed.FS
+}
+
+type mockFileInfo struct{}
+
+func (fs *mockFileInfo) Name() string       { return "" }
+func (fs *mockFileInfo) Size() int64        { return 0 }
+func (fs *mockFileInfo) Mode() fs.FileMode  { return 0 }
+func (fs *mockFileInfo) ModTime() time.Time { return time.Now() }
+func (fs *mockFileInfo) Sys() any           { return nil }
+func (fs *mockFileInfo) IsDir() bool        { return false }
+
+func (t testStatFS) Stat(_ string) (fileinfo fs.FileInfo, err error) {
+	return &mockFileInfo{}, nil
+}
+
+type mockFile struct {
+	name string
+}
+
+func (f *mockFile) Stat() (fs.FileInfo, error) { return nil, nil }
+func (f *mockFile) Read(_ []byte) (int, error) { return 0, nil }
+func (f *mockFile) Close() error               { return nil }
+
+type mockDirEntry struct{}
+
+func (f *mockDirEntry) Name() string               { return "" }
+func (f *mockDirEntry) IsDir() bool                { return false }
+func (f *mockDirEntry) Type() fs.FileMode          { return 0 }
+func (f *mockDirEntry) Info() (fs.FileInfo, error) { return &mockFileInfo{}, nil }
+
+type mockFS struct{}
+
+func (e mockFS) Open(name string) (fs.File, error) {
+	return &mockFile{
+		name: name,
+	}, nil
+}
+
+func (e mockFS) ReadDir(_ string) ([]fs.DirEntry, error) {
+	return []fs.DirEntry{&mockDirEntry{}}, nil
+}
+
 func TestEmbed(t *testing.T) {
-	e := Embed{FS: resources}
+	e := NewEmbed(resources)
 
 	stat, err := e.Stat("osfs/osfs.go")
 	if !assert.NoError(t, err) {
@@ -256,9 +304,57 @@ func TestEmbed(t *testing.T) {
 	stat, err = e.Stat("notadir/osfs.go")
 	assert.Nil(t, stat)
 	if assert.NotNil(t, err) {
-		e, ok := err.(*fs.PathError)
-		assert.True(t, ok)
-		assert.Equal(t, "open", e.Op)
-		assert.Equal(t, "notadir/osfs.go", e.Path)
+		e, ok := err.(*errors.Error)
+		if assert.True(t, ok) {
+			var fsErr *fs.PathError
+			if assert.True(t, stderrors.As(e, &fsErr)) {
+				assert.Equal(t, "open", fsErr.Op)
+				assert.Equal(t, "notadir/osfs.go", fsErr.Path)
+			}
+		}
 	}
+
+	// Make it so the underlying FS implements
+	e.FS = testStatFS{resources}
+	stat, err = e.Stat("osfs/osfs.go")
+	if !assert.NoError(t, err) {
+		return
+	}
+	_, ok := stat.(*mockFileInfo)
+	assert.True(t, ok)
+
+	t.Run("Open", func(t *testing.T) {
+		e := NewEmbed(&mockFS{})
+
+		f, err := e.Open("")
+		assert.NoError(t, err)
+		_, ok := f.(*mockFile)
+		assert.True(t, ok)
+	})
+	t.Run("ReadDir", func(t *testing.T) {
+		e := NewEmbed(&mockFS{})
+
+		f, err := e.ReadDir("")
+		assert.NoError(t, err)
+		if assert.Len(t, f, 1) {
+			_, ok := f[0].(*mockDirEntry)
+			assert.True(t, ok)
+		}
+	})
+}
+
+func TestEmbedSub(t *testing.T) {
+	t.Run("err", func(t *testing.T) {
+		e := NewEmbed(resources)
+		sub, err := e.Sub("..")
+		assert.Equal(t, Embed{}, sub)
+		assert.Error(t, err)
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		e := NewEmbed(resources)
+		sub, err := e.Sub("osfs.go") // It is valid to do this
+		assert.NotNil(t, sub.FS)
+		assert.NoError(t, err)
+	})
 }