feat(conf): implement Root, safe and mockable

Author: 0uep

conf/files.go

@@ -17,6 +17,30 @@ import (
 	"github.com/LM4eu/goinfer/gie"
 )
 
+type Root struct {
+	Path string
+	FS   fs.FS
+}
+
+func NewRoot(path string) Root {
+	return Root{path, os.DirFS(path)}
+}
+
+func (root *Root) Open(name string) (fs.File, error) {
+	return root.FS.Open(name)
+}
+
+func (root *Root) ReadFile(fullPath string) ([]byte, error) {
+	relativePath, err := filepath.Rel(root.Path, fullPath)
+	if err != nil {
+		return nil, err
+	}
+	if !filepath.IsLocal(relativePath) {
+		return nil, gie.New(gie.Invalid, "not local", "full", fullPath, "root", root.Path)
+	}
+	return fs.ReadFile(root.FS, filepath.Clean(relativePath))
+}
+
 // replaceDIR in flags by the current dir of he file.
 // When using models like GPT OSS, we need to provide a grammar file.
 // See: github.com/ggml-org/llama.cpp/discussions/15396#discussioncomment-14145537
@@ -201,9 +225,9 @@ func nameWithDir(root, truncated, name string) string {
 
 // extractModelNameAndFlags search for a llama-server command line
 // and extract the model path (flag -m or --model) and the flags after -m|--model.
-func extractModelNameAndFlags(fsys fs.FS, shellPath string) (modelPath, flags []byte) {
+func extractModelNameAndFlags(root Root, shellPath string) (modelPath, flags []byte) {
 	//	shellPath = filepath.Clean(shellPath)
-	script, err := fs.ReadFile(fsys, shellPath)
+	script, err := root.ReadFile(shellPath)
 	if err != nil {
 		return nil, nil
 	}

conf/files_test.go

@@ -266,9 +266,9 @@ const (
 )
 
 func Test_extractModelNameAndFlags(t *testing.T) {
-	t.Parallel()
+	// t.Parallel()
 
-	testFS := fstest.MapFS{
+	root := Root{"/home/me/models", fstest.MapFS{
 		"0.sh": &fstest.MapFile{Data: []byte("")},
 		"1.sh": &fstest.MapFile{Data: []byte(script1)},
 		"2.sh": &fstest.MapFile{Data: []byte(script2)},
@@ -277,21 +277,21 @@ func Test_extractModelNameAndFlags(t *testing.T) {
 		"5.sh": &fstest.MapFile{Data: []byte("llama-server --model ~/model.gguf")},
 		"6.sh": &fstest.MapFile{Data: []byte("/llama-server --model ~/model.gguf")},
 		"7.sh": &fstest.MapFile{Data: []byte("/llama-server\t-m\t~/model.gguf\t-c\t0")},
-	}
+	}}
 
 	tests := []struct{ path, wantModel, wantFlags string }{
-		{"1.sh", "/path/model.gguf", `--no-mmap --chat-template-kwargs '{"reasoning_effort": "high"}' 	--reasoning-format auto -c 10240  #	--no-context-shift`},
-		{"2.sh", "/path/model.gguf", `--no-mmap --chat-template-kwargs '{"reasoning_effort": "high"}' --reasoning-format auto -c 10240`},
-		{"3.sh", "/path/model.gguf", `--no-mmap --chat-template-kwargs '{"reasoning_effort": "high"}' --reasoning-format auto -c 10240`},
-		{"4.sh", "", ""},
-		{"5.sh", "", ""},
-		{"6.sh", "~/model.gguf", ""},
-		{"7.sh", "~/model.gguf", "-c\t0"},
+		{"/home/me/models/1.sh", "/path/model.gguf", `--no-mmap --chat-template-kwargs '{"reasoning_effort": "high"}' 	--reasoning-format auto -c 10240  #	--no-context-shift`},
+		{"/home/me/models/2.sh", "/path/model.gguf", `--no-mmap --chat-template-kwargs '{"reasoning_effort": "high"}' --reasoning-format auto -c 10240`},
+		{"/home/me/models/3.sh", "/path/model.gguf", `--no-mmap --chat-template-kwargs '{"reasoning_effort": "high"}' --reasoning-format auto -c 10240`},
+		{"/home/me/models/4.sh", "", ""},
+		{"/home/me/models/5.sh", "", ""},
+		{"/home/me/models/6.sh", "~/model.gguf", ""},
+		{"/home/me/models/7.sh", "~/model.gguf", "-c\t0"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.path, func(t *testing.T) {
-			t.Parallel()
-			gotModel, gotFlags := extractModelNameAndFlags(testFS, tt.path)
+			// t.Parallel()
+			gotModel, gotFlags := extractModelNameAndFlags(root, tt.path)
 			if string(gotModel) != tt.wantModel {
 				t.Errorf("extractModelNameAndFlags(%s) = %s, want %s", tt.path, gotModel, tt.wantModel)
 			}

conf/info.go

@@ -158,8 +158,8 @@ func (cfg *Cfg) updateInfo() {
 // search walks the given root directory and appends any valid *.gguf model file to
 // cfg.Info. It validates each file using validateFile and warns about errors (logs).
 func (cfg *Cfg) search(params map[string]ModelParams, root string) error {
+	rootFS := NewRoot(root)
 	return filepath.WalkDir(root, func(path string, dir fs.DirEntry, err error) error {
-		fsys := os.DirFS(root)
 		switch {
 		case err != nil:
 			if dir == nil {
@@ -176,7 +176,7 @@ func (cfg *Cfg) search(params map[string]ModelParams, root string) error {
 		case filepath.Ext(path) == ".gguf":
 			cfg.keepGUFF(root, path)
 		case filepath.Ext(path) == ".sh":
-			cfg.keepFlags(fsys, path[len(root):])
+			cfg.keepFlags(rootFS, path[len(root):])
 		default:
 		}
 		return nil
@@ -235,8 +235,8 @@ func (cfg *Cfg) keepGUFF(root, path string) {
 	cfg.Info[name] = &mi
 }
 
-func (cfg *Cfg) keepFlags(fsys fs.FS, path string) {
-	modelPath, args := extractModelNameAndFlags(fsys, path)
+func (cfg *Cfg) keepFlags(root Root, path string) {
+	modelPath, args := extractModelNameAndFlags(root, path)
 	if modelPath == nil {
 		return
 	}