tplimpl: Allow text partials in HTML templates

Most obvius benefit of this is to include CSS partials with css file suffix into HTML templates.

A valid workaround would be to rename the file `mystyles.html`, but that doesn't work too good for external editors etc.

The css partial is  a method used in some themes before Hugo 0.20, but then it stopped working.

This commit reintroduces that behaviour.

Note that the regular layout lookups for text templates, i.e. "single.json" will be
prefixed with "_text/" on lookup and will only match in the text collection.

Fixes #3273

diff --git a/tpl/tplimpl/template.go b/tpl/tplimpl/template.go
index f1ab37ee018cab2f414c26d27f67bbbe6a6a3dd0..c86f4cf1e23281d0e3b63bb89d9edc4bd74c294a 100644 (file)
--- a/tpl/tplimpl/template.go
+++ b/tpl/tplimpl/template.go
@@ -97,23 +97,21 @@ func (t *templateHandler) PrintErrors() {
 // Lookup tries to find a template with the given name in both template
 // collections: First HTML, then the plain text template collection.
 func (t *templateHandler) Lookup(name string) *tpl.TemplateAdapter {
-       var te *tpl.TemplateAdapter
 
-       isTextTemplate := strings.HasPrefix(name, textTmplNamePrefix)
-
-       if isTextTemplate {
+       if strings.HasPrefix(name, textTmplNamePrefix) {
+               // The caller has explicitly asked for a text template, so only look
+               // in the text template collection.
                // The templates are stored without the prefix identificator.
                name = strings.TrimPrefix(name, textTmplNamePrefix)
-               te = t.text.Lookup(name)
-       } else {
-               te = t.html.Lookup(name)
+               return t.text.Lookup(name)
        }
 
-       if te == nil {
-               return nil
+       // Look in both
+       if te := t.html.Lookup(name); te != nil {
+               return te
        }
 
-       return te
+       return t.text.Lookup(name)
 }
 
 func (t *templateHandler) clone(d *deps.Deps) *templateHandler {
@@ -459,9 +457,10 @@ func (t *templateHandler) loadTemplates(absPath string, prefix string) {
 
 func (t *templateHandler) initFuncs() {
 
-       // The template funcs need separation between text and html templates.
+       // Both template types will get their own funcster instance, which
+       // in the current case contains the same set of funcs.
        for _, funcsterHolder := range []templateFuncsterTemplater{t.html, t.text} {
-               funcster := newTemplateFuncster(t.Deps, funcsterHolder)
+               funcster := newTemplateFuncster(t.Deps)
 
                // The URL funcs in the funcMap is somewhat language dependent,
                // so we need to wait until the language and site config is loaded.

diff --git a/tpl/tplimpl/templateFuncster.go b/tpl/tplimpl/templateFuncster.go
index ddcafedfd832ff3d5f1fdc5b97f8e7f55d97ba26..52e968fdc55f13dce5180b31d913e74d0d8ec19b 100644 (file)
--- a/tpl/tplimpl/templateFuncster.go
+++ b/tpl/tplimpl/templateFuncster.go
@@ -17,6 +17,7 @@ import (
        "fmt"
        "html/template"
        "strings"
+       texttemplate "text/template"
 
        bp "github.com/spf13/hugo/bufferpool"
 
@@ -31,17 +32,12 @@ type templateFuncster struct {
        cachedPartials partialCache
        image          *imageHandler
 
-       // Make sure each funcster gets its own TemplateFinder to get
-       // proper text and HTML template separation.
-       Tmpl templateFuncsterTemplater
-
        *deps.Deps
 }
 
-func newTemplateFuncster(deps *deps.Deps, t templateFuncsterTemplater) *templateFuncster {
+func newTemplateFuncster(deps *deps.Deps) *templateFuncster {
        return &templateFuncster{
                Deps:           deps,
-               Tmpl:           t,
                cachedPartials: partialCache{p: make(map[string]interface{})},
                image:          &imageHandler{fs: deps.Fs, imageConfigCache: map[string]image.Config{}},
        }
@@ -75,14 +71,12 @@ func (t *templateFuncster) partial(name string, contextList ...interface{}) (int
                                return "", err
                        }
 
-                       switch t.Tmpl.(type) {
-                       case *htmlTemplates:
-                               return template.HTML(b.String()), nil
-                       case *textTemplates:
+                       if _, ok := templ.Template.(*texttemplate.Template); ok {
                                return b.String(), nil
-                       default:
-                               panic("Unknown type")
                        }
+
+                       return template.HTML(b.String()), nil
+
                }
        }
 

diff --git a/tpl/tplimpl/template_funcs.go b/tpl/tplimpl/template_funcs.go
index 2737533889f55a93fa300c8bf653ef151e3d8ed0..54cff81c6ca9bbb39fdde67f2175f5aa3892c29b 100644 (file)
--- a/tpl/tplimpl/template_funcs.go
+++ b/tpl/tplimpl/template_funcs.go
@@ -2221,5 +2221,5 @@ func (t *templateFuncster) initFuncMap() {
        }
 
        t.funcMap = funcMap
-       t.Tmpl.setFuncs(funcMap)
+       t.Tmpl.(*templateHandler).setFuncs(funcMap)
 }

diff --git a/tpl/tplimpl/template_funcs_test.go b/tpl/tplimpl/template_funcs_test.go
index 075581c66d4f93fe4086052beaefa3ee0861ab86..70a0ad5e533b08ad785cb86b6f1274f2b59455b1 100644 (file)
--- a/tpl/tplimpl/template_funcs_test.go
+++ b/tpl/tplimpl/template_funcs_test.go
@@ -2869,20 +2869,27 @@ func TestPartialHTMLAndText(t *testing.T) {
        }
 
        config.WithTemplate = func(templ tpl.TemplateHandler) error {
-               if err := templ.AddTemplate("htmlTemplate.html", `HTML Test Partial: {{ partial "test.foo" . -}}`); err != nil {
+               if err := templ.AddTemplate("htmlTemplate.html", `HTML Test|HTML:{{ partial "test.html" . -}}|Text:{{ partial "test.txt" . }}
+CSS plain:  <style type="text/css">{{ partial "mystyles.css" . -}}</style>
+CSS safe:  <style type="text/css">{{ partial "mystyles.css" . | safeCSS -}}</style>
+`); err != nil {
                        return err
                }
 
-               if err := templ.AddTemplate("_text/textTemplate.txt", `Text Test Partial: {{ partial "test.foo" . -}}`); err != nil {
+               if err := templ.AddTemplate("_text/textTemplate.txt", `Text Test|HTML:{{ partial "test.html" . -}}|Text:{{ partial "test.txt" . }}
+CSS plain:  <style type="text/css">{{ partial "mystyles.css" . -}}</style>`); err != nil {
                        return err
                }
 
-               // Use "foo" here to say that the extension doesn't really matter in this scenario.
-               // It will look for templates in "partials/test.foo" and "partials/test.foo.html".
-               if err := templ.AddTemplate("partials/test.foo", "HTML Name: {{ .Name }}"); err != nil {
+               if err := templ.AddTemplate("partials/test.html", "HTML Name: {{ .Name }}"); err != nil {
+                       return err
+               }
+               if err := templ.AddTemplate("_text/partials/test.txt", "Text Name: {{ .Name }}"); err != nil {
                        return err
                }
-               if err := templ.AddTemplate("_text/partials/test.foo", "Text Name: {{ .Name }}"); err != nil {
+               if err := templ.AddTemplate("_text/partials/mystyles.css",
+                       `body { background-color: blue; }
+`); err != nil {
                        return err
                }
 
@@ -2903,8 +2910,12 @@ func TestPartialHTMLAndText(t *testing.T) {
        resultText, err := templ.ExecuteToString(data)
        require.NoError(t, err)
 
-       require.Contains(t, resultHTML, "HTML Test Partial: HTML Name: a&#43;b&#43;c")
-       require.Contains(t, resultText, "Text Test Partial: Text Name: a+b+c")
+       require.Contains(t, resultHTML, "HTML Test|HTML:HTML Name: a&#43;b&#43;c|Text:Text Name: a&#43;b&#43;c")
+       require.Contains(t, resultHTML, `CSS plain:  <style type="text/css">ZgotmplZ</style>`)
+       require.Contains(t, resultHTML, `CSS safe:  <style type="text/css">body { background-color: blue; }`)
+
+       require.Contains(t, resultText, "Text Test|HTML:HTML Name: a&#43;b&#43;c|Text:Text Name: a+b+c")
+       require.Contains(t, resultText, `CSS plain:  <style type="text/css">body { background-color: blue; }`)
 
 }