Embed structs seems not working

[syrm]

Hello

I have a problem when i'm using embed structs. Let me explain.
I have this code :

type TemplateReader struct {
	filename string
}

func (t TemplateReader) TemplateText() string {
	fileContent, err := os.ReadFile(t.filename)

	if err != nil {
		return "template not found: " + t.filename
	}

	return string(fileContent)
}

type Layout struct {
	Class string
	Body  Test `tmpl:"body"`

	TemplateReader
}

type Test struct {
}

func (*Test) TemplateText() string {
	fileContent, err := os.ReadFile("feature/authentication/login/template/login.html")

	if err != nil {
		return "template not found: login"
	}

	return string(fileContent)
}

t := &Test{}
body := &Layout{
    "main-register",
    *t,
    TemplateReader{
	filename: "template/base.html",
    },
}

ta := tmpl.MustCompile(body, compilerOption)
result, err := ta.RenderToString(body)

With this code, the template is not found, its output template not found: without the template name.

When i'm calling directly fmt.Printf("%+v\n", body.TemplateText()) the template is found.

[syrm]

the fault is zeroValueInterfaceFromField
it seems to work only if you using embed...

[syrm]

i don't know if its a proper fix, but with this modification its working :

--- compile.go  2024-01-09 22:04:22.985542461 +0100
+++ compile.go.new      2024-01-09 22:04:44.955536530 +0100
@@ -44,13 +44,14 @@
        }
 }

-func compile(tp TemplateProvider, opts ParseOptions, analyzers ...Analyzer) (*template.Template, error) {
+func compile(tpOrg TemplateProvider, opts ParseOptions, analyzers ...Analyzer) (*template.Template, error) {
        var (
                err error
                t   *template.Template
        )

-       helper, err := Analyze(tp, opts, analyzers)
+       helper, err := Analyze(tpOrg, opts, analyzers)
+
        if err != nil {
                return nil, err
        }
@@ -58,7 +59,7 @@
        // recursively parse all templates into a single template instance
        // this block is responsible for constructing the template that
        // will be rendered by the user
-       err = recurseFieldsImplementing[TemplateProvider](tp, func(tp TemplateProvider, field reflect.StructField) error {
+       err = recurseFieldsImplementing[TemplateProvider](tpOrg, func(tp TemplateProvider, field reflect.StructField) error {
                var templateText string

                templateName, ok := field.Tag.Lookup("tmpl")
@@ -67,6 +68,8 @@
                }

                if t == nil {
+                       tp = tpOrg
+
                        // if t is nil, that means this is the recursive entrypoint
                        // and some construction needs to happen
                        t = template.New(templateName)

[tylermmorton]

Hey, thanks for the issue report and associated code! And thanks for trying out tmpl. I'm not sure if I can know exactly what's going on here without understanding what the html templates look like.

When tmpl compiles your templates, it wraps what is returned by TemplateText() with a define directive. The name that is assigned to the template is driven by the tmpl tag, or if not provided, the struct name is used.

{{ define "body" }}TemplateText{{ end }}

I think if you have any defined templates within your template text, you may run into issues using tmpl because of how this wrapping works. I would check to make sure that none of your template files define any templates within them. The solution here would be to break out each defined template into its own template file. (Maybe in the future we can better support multiple templates in a single file 🤔)

Aside from that, I just tested locally and both regular struct fields and embedded struct fields should be recognizable by the compiler in the current version.

Note some nuance when regular fields are used vs embedded fields. When calling the template directive you'll need to be explicit about the value you pass. Simply passing the dot is not enough:

type Child struct {
	DefField string
}

func (*Child) TemplateText() string {
	return `{{ .DefField }}`
}

type Parent struct {
	Name Child `tmpl:"nested"`
}

func (*Parent) TemplateText() string {
         // here: we're passing the value of Child by calling .Name
	return `{{ template "nested" .Name }}`
}

Let me know if that gets you any further along. I'm glad to help out!

Tyler