If method loading html files from embed.FS type could be helpful??

[j1mmyson]

First of all, thank you for creating a very useful framework !!

Recently, I found out that the gin framework cannot load template with embed.FS type and I have solved it in the following way.

//embed:go web/templates/*.html
var templatesFS embed.FS

func main(){
    r := gin.Default()
    LoadHTMLFromEmbedFS(r, templatesFS, "web/templates/*")
    ...
    r.Run()
}

func LoadHTMLFromEmbedFS(engine *gin.Engine, embedFS embed.FS, pattern string){
    templ := template.Must(template.ParseFS(embedFS, pattern))
    engine.SetHTMLTemplate(templ)
}

Is it convenient to use this function in the form of a method?

func (engine *Engine) LoadHTMLFromFS(embedFS embed.FS, pattern string){
    templ := template.Must(template.ParseFS(embedFS, pattern))
    engine.SetHTMLTemplate(templ)
}

and users use it like

//embed:go web/templates/*.html
var templatesFS embed.FS

func main(){
    r := gin.Default()
    r.LoadHTMLFromFS(templatesFS, "web/templates/*")
    ...
    r.Run()
}

I don't know whether my code is safe or not, so leave it as an issue for now. Thank you!

[sesopenko]

The workaround from @j1mmyson above doesn't handle templates in recursive directories. Combining this solution from stack exchange with the above lets you attach templates from recursive embedded directories:

package main

import (
    "embed"
    "github.com/gin-gonic/gin"
    "html/template"
    "io/fs"
    "net/http"
    "strings"
)

// template files in directory:
// templates/index.html
// templates/test/nested.html

//go:embed templates/**
var f embed.FS

func main() {
    r := gin.Default()
    root := template.New("")
    LoadAndAddToRoot(r.FuncMap, root)
    r.GET("/", func(c *gin.Context) {
        c.HTML(http.StatusOK, "templates/index.html", gin.H{})
    })
    r.GET("/embed", func(c *gin.Context) {
        c.HTML(http.StatusOK, "templates/test/nested.html", gin.H{})
    })
    r.Run("127.0.0.1:8080")
}

func LoadAndAddToRoot(funcMap template.FuncMap, rootTemplate *template.Template) error {
    // This solution is CC by share alike 4.0
    // Copyright Rik-777
    // https://stackoverflow.com/a/50581032
    err := fs.WalkDir(f, ".", func(path string, d fs.DirEntry, walkErr error) error {
        if walkErr != nil {
            return walkErr
        }
        if !d.IsDir() && strings.HasSuffix(path, ".html") {
            data, readErr := f.ReadFile(path)
            if readErr != nil {
                return readErr
            }
            t := rootTemplate.New(path).Funcs(funcMap)
            if _, parseErr := t.Parse(string(data)); parseErr != nil {
                return parseErr
            }
        }
        return nil
    })
    return err
}

[j1mmyson]

@sesopenko Thank you for comments! according to your comments, it finally attach templates from recursive embedded directories.

func LoadHTMLFromEmbedFS(engine *gin.Engine, embedFS embed.FS, pattern string) {
    root := template.New("")
    tmpl := template.Must(root, LoadAndAddToRoot(engine.FuncMap, root, embedFS, pattern))
    engine.SetHTMLTemplate(tmpl)
}

// Method version
// func (engine *gin.Engine) LoadHTMLFromFS(embedFS embed.FS, pattern string) {
//  root := template.New("")
//  tmpl := template.Must(root, LoadAndAddToRoot(engine.FuncMap, root, embedFS, pattern))
//  engine.SetHTMLTemplate(tmpl)
// }

func LoadAndAddToRoot(funcMap template.FuncMap, rootTemplate *template.Template, embedFS embed.FS, pattern string) error {
    pattern = strings.ReplaceAll(pattern, ".", "\\.")
    pattern = strings.ReplaceAll(pattern, "*", ".*")

    err := fs.WalkDir(embedFS, ".", func(path string, d fs.DirEntry, walkErr error) error {
        if walkErr != nil {
            return walkErr
        }

        if matched, _ := regexp.MatchString(pattern, path); !d.IsDir() && matched {
            data, readErr := embedFS.ReadFile(path)
            if readErr != nil {
                return readErr
            }
            t := rootTemplate.New(path).Funcs(funcMap)
            if _, parseErr := t.Parse(string(data)); parseErr != nil {
                return parseErr
            }
        }
        return nil
    })
    return err
}

and use it like

package main

import (
    "embed"
    "html/template"
    "io/fs"
    "net/http"
    "regexp"
    "strings"

    "github.com/gin-gonic/gin"
)

//go:embed web/templates
var templatesFS embed.FS

func main() {
    r := gin.Default()
    LoadHTMLFromEmbedFS(r, templatesFS, "web/templates/*html")
        // if method
        // r.LoadHTMLFromEmbedFS(templatesFS, "web/templates/*html")

        ...

    r.Run()
}

following is an example: https://github.com/j1mmyson/LoadHTMLFromEmbedFS-example

from now on, is there any improvement point or problems? Thanks again for your comments!

[walnut-tom]

the template has method

func ParseFS(fs fs.FS, patterns ...string) (*Template, error) 
func (t *Template) ParseFS(fs fs.FS, patterns ...string) (*Template, error)

can add a method like this:

func (engine *Engine) LoadHTMLFS(fs fs.FS, patterns ...string) {
    if IsDebugging() {
        engine.HTMLRender = render.HTMLDebug{Files: patterns, FuncMap: engine.FuncMap, Delims: engine.delims}
        return
    }

    templ := template.Must(template.New("").Delims(engine.delims.Left, engine.delims.Right).Funcs(engine.FuncMap).ParseFS(fs, patterns...))
    engine.SetHTMLTemplate(templ)
}