embed fs working

cmd/handlers.go

···
 
 	"github.com/teal-fm/piper/db"
 	"github.com/teal-fm/piper/models"
+	pages "github.com/teal-fm/piper/pages"
 	"github.com/teal-fm/piper/service/musicbrainz"
 	"github.com/teal-fm/piper/service/spotify"
 	"github.com/teal-fm/piper/session"
 )
 
-func home(database *db.DB, pages *Pages) http.HandlerFunc {
+func home(database *db.DB, pages *pages.Pages) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 
 		w.Header().Set("Content-Type", "text/html")
···
 		</body>
 		</html>
 	`
-		pages.execute("home", w, nil)
+		pages.Execute("home", w, nil)
 
 		//w.Write([]byte(html))
 	}

cmd/main.go

···
 	"github.com/teal-fm/piper/db"
 	"github.com/teal-fm/piper/oauth"
 	"github.com/teal-fm/piper/oauth/atproto"
+	pages "github.com/teal-fm/piper/pages"
 	apikeyService "github.com/teal-fm/piper/service/apikey"
 	"github.com/teal-fm/piper/service/musicbrainz"
 	"github.com/teal-fm/piper/service/spotify"
···
 	mbService         *musicbrainz.MusicBrainzService
 	atprotoService    *atproto.ATprotoAuthService
 	playingNowService *playingnow.PlayingNowService
-	pages             *Pages
+	pages             *pages.Pages
 }
 
 // JSON API handlers
···
 		spotifyService:    spotifyService,
 		atprotoService:    atprotoService,
 		playingNowService: playingNowService,
-		pages:             NewPages(true),
+		pages:             pages.NewPages(false),
 	}
 
 	trackerInterval := time.Duration(viper.GetInt("tracker.interval")) * time.Second

cmd/pages.go pages/pages.go

···
-package main
+package pages
 
 import (
 	"embed"
···
 	"io/fs"
 	"os"
 	"strings"
-	"sync"
 	"time"
 )
 
···
 	if pages.dev {
 		pages.embedFS = os.DirFS(pages.templateDir)
 	} else {
-		//pages.embedFS = Files
+		pages.embedFS = Files
 	}
 
 	return pages
···
 
 func (p *Pages) fragmentPaths() ([]string, error) {
 	var fragmentPaths []string
+	// When using os.DirFS("templates"), the FS root is already the templates directory.
+	// Walk from "." and use relative paths (no "templates/" prefix).
 	err := fs.WalkDir(p.embedFS, "templates", func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
···
 		if !strings.HasSuffix(path, ".gohtml") {
 			return nil
 		}
-		if !strings.Contains(path, "fragments/") {
-			return nil
-		}
+		//if !strings.Contains(path, "fragments/") {
+		//	return nil
+		//}
 		fragmentPaths = append(fragmentPaths, path)
 		return nil
 	})
···
 }
 
 func (p *Pages) pathToName(s string) string {
-	return strings.TrimSuffix(strings.TrimPrefix(s, "templates/"), ".html")
+	return strings.TrimSuffix(strings.TrimPrefix(s, "templates/"), ".gohtml")
 }
 
 // reverse of pathToName
 func (p *Pages) nameToPath(s string) string {
-	return "templates/" + s + ".html"
+	return "templates/" + s + ".gohtml"
 }
 
 // parse without memoization
···
 	return tpl.Execute(w, params)
 }
 
-func (p *Pages) execute(name string, w io.Writer, params any) error {
+func (p *Pages) Execute(name string, w io.Writer, params any) error {
 	tpl, err := p.parseBase(name)
 	if err != nil {
 		return err
···
 
 	return tpl.ExecuteTemplate(w, "layouts/base", params)
 }
-
-/// Cache for pages
-
-type TmplCache[K comparable, V any] struct {
-	data  map[K]V
-	mutex sync.RWMutex
-}
-
-func NewTmplCache[K comparable, V any]() *TmplCache[K, V] {
-	return &TmplCache[K, V]{
-		data: make(map[K]V),
-	}
-}
-
-func (c *TmplCache[K, V]) Get(key K) (V, bool) {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-	val, exists := c.data[key]
-	return val, exists
-}
-
-func (c *TmplCache[K, V]) Set(key K, value V) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-	c.data[key] = value
-}
-
-func (c *TmplCache[K, V]) Size() int {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-	return len(c.data)
-}

pages/cache.go

···
+package pages
+
+import "sync"
+
+/// Cache for pages
+
+type TmplCache[K comparable, V any] struct {
+	data  map[K]V
+	mutex sync.RWMutex
+}
+
+func NewTmplCache[K comparable, V any]() *TmplCache[K, V] {
+	return &TmplCache[K, V]{
+		data: make(map[K]V),
+	}
+}
+
+func (c *TmplCache[K, V]) Get(key K) (V, bool) {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	val, exists := c.data[key]
+	return val, exists
+}
+
+func (c *TmplCache[K, V]) Set(key K, value V) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.data[key] = value
+}
+
+func (c *TmplCache[K, V]) Size() int {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	return len(c.data)
+}