compile.go

package tmpl

import (
	"fmt"
	"html/template"
	"reflect"
	"sync"
)

// CompilerOptions holds options that control the template compiler
type CompilerOptions struct {
	// analyzers is a list of analyzers that are run before compilation
	analyzers []Analyzer
	// parseOpts are the options passed to the template parser
	parseOpts ParseOptions
}

// CompilerOption is a function that can be used to modify the CompilerOptions
type CompilerOption func(opts *CompilerOptions)

func UseFuncs(funcs FuncMap) CompilerOption {
	return func(opts *CompilerOptions) {
		if opts.parseOpts.Funcs == nil {
			opts.parseOpts.Funcs = funcs
		} else {
			for k, v := range funcs {
				opts.parseOpts.Funcs[k] = v
			}
		}
	}
}

func UseAnalyzers(analyzers ...Analyzer) CompilerOption {
	return func(opts *CompilerOptions) {
		opts.analyzers = append(opts.analyzers, analyzers...)
	}
}

// UseParseOptions sets the ParseOptions for the template CompilerOptions. These
// options are used internally with the html/template package.
func UseParseOptions(parseOpts ParseOptions) CompilerOption {
	return func(opts *CompilerOptions) {
		opts.parseOpts = parseOpts
	}
}

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

	helper, err := Analyze(tp, opts, analyzers)
	if err != nil {
		return nil, err
	}

	// 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 {
		var (
			funcMap      = make(FuncMap)
			templateText string
		)

		templateName, ok := field.Tag.Lookup("tmpl")
		if !ok {
			templateName = field.Name
		}

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

			t = t.Delims(opts.LeftDelim, opts.RightDelim)

			// Analyzers can provide functions to be used in templates
			for key, fn := range helper.FuncMap() {
				funcMap[key] = fn
			}

			// FuncMapProvider can also be implemented and provide functions
			if fmp, ok := tp.(FuncMapProvider); ok {
				for key, fn := range fmp.TemplateFuncMap() {
					funcMap[key] = fn
				}
			}
		} else {
			// if this is a nested template wrap its text in a {{ define }}
			// statement, so it may be referenced by the "parent" template
			// ex: {{define %q -}}\n%s{{end}}
			templateText = fmt.Sprintf("%[1]sdefine %[3]q -%[2]s\n%[4]s%[1]send%[2]s\n", opts.LeftDelim, opts.RightDelim, templateName, tp.TemplateText())
		}

		t, err = t.Funcs(funcMap).Parse(templateText)
		if err != nil {
			return err
		}

		return nil
	})
	if err != nil {
		return nil, fmt.Errorf("failed to compile template: %+v", err)
	}

	return t, nil
}

// Compile takes the given TemplateProvider, parses the templateProvider text and then
// recursively compiles all nested templates into one managed Template instance.
func Compile[T TemplateProvider](tp T, opts ...CompilerOption) (Template[T], error) {
	var (
		c = &CompilerOptions{
			analyzers: builtinAnalyzers,
			parseOpts: ParseOptions{
				LeftDelim:  "{{",
				RightDelim: "}}",
			},
		}
	)

	for _, opt := range opts {
		opt(c)
	}

	m := &managedTemplate[T]{
		mu: &sync.RWMutex{},
	}

	doCompile := func() (err error) {
		var (
			t *template.Template
		)

		t, err = compile(tp, c.parseOpts, c.analyzers...)
		if err != nil {
			return
		}

		m.mu.Lock()
		m.template = t
		m.mu.Unlock()

		return
	}

	err := doCompile()
	if err != nil {
		return nil, err
	}

	return m, nil
}

// MustCompile is a helper function that wraps Compile and panics if the template
// fails to compile.
func MustCompile[T TemplateProvider](p T, opts ...CompilerOption) Template[T] {
	tmpl, err := Compile(p, opts...)
	if err != nil {
		panic(err)
	}
	return tmpl
}