Added test coverage for template renderer.

services/template_renderer.go

@@ -39,7 +39,7 @@ func NewTemplateRenderer(cfg *config.Config) *TemplateRenderer {
 	}
 
 	// Gets the complete templates directory path
-	// This is needed incase this is called from a package outside of main, such as within tests
+	// This is needed in case this is called from a package outside of main, such as within tests
 	_, b, _, _ := runtime.Caller(0)
 	d := path.Join(path.Dir(b))
 	t.templatesPath = filepath.Join(filepath.Dir(d), config.TemplateDir)
@@ -47,28 +47,48 @@ func NewTemplateRenderer(cfg *config.Config) *TemplateRenderer {
 	return t
 }
 
-func (t *TemplateRenderer) ParseAndExecute(group, id, name string, files []string, directories []string, data interface{}) (*bytes.Buffer, error) {
-	var buf *bytes.Buffer
-	var err error
-
-	if err = t.Parse(group, id, name, files, directories); err != nil {
-		return nil, err
-	}
-	if buf, err = t.Execute(group, id, name, data); err != nil {
-		return nil, err
-	}
-
-	return buf, nil
-}
-
-func (t *TemplateRenderer) Parse(group, id, name string, files []string, directories []string) error {
-	cacheKey := t.getCacheKey(group, id)
+// Parse parses a set of templates and caches them for quick execution
+// If the application environment is set to local, the cache will be bypassed and templates will be
+// parsed upon each request so hot-reloading is possible without restarts.
+//
+// All template files and template directories must be provided relative to the templates directory
+// and without template extensions. Those two values can be altered via the config package.
+//
+// cacheGroup is used to separate templates in to groups within the cache to avoid potential conflicts
+// with the cacheID.
+//
+// baseName is the filename of the base template without any paths or an extension.
+// files is a slice of all individual template files that will be included in the parse.
+// directories is a slice of directories which all template files witin them will be included in the parse
+//
+// Also included will be the function map provided by the funcmap package.
+//
+// An example usage of this:
+// t.Parse(
+//		"page",
+//		"home",
+//		"main",
+//		[]string{
+//			"layouts/main",
+//			"pages/home",
+//		},
+//		[]string{"components"},
+//)
+//
+// This will perform a template parse which will:
+//		- Be cached using a key of "page:home"
+//		- Include the layouts/main.gohtml and pages/home.gohtml templates
+//		- Include all templates within the components directory
+//		- Include the function map within the funcmap package
+//		- Set the base template as main.gohtml
+func (t *TemplateRenderer) Parse(cacheGroup, cacheID, baseName string, files []string, directories []string) error {
+	cacheKey := t.getCacheKey(cacheGroup, cacheID)
 
 	// Check if the template has not yet been parsed or if the app environment is local, so that
 	// templates reflect changes without having the restart the server
-	if _, err := t.Load(group, id); err != nil || t.config.App.Environment == config.EnvLocal {
+	if _, err := t.Load(cacheGroup, cacheID); err != nil || t.config.App.Environment == config.EnvLocal {
 		// Initialize the parsed template with the function map
-		parsed := template.New(name + config.TemplateExt).
+		parsed := template.New(baseName + config.TemplateExt).
 			Funcs(t.funcMap)
 
 		// Parse all files provided
@@ -99,14 +119,16 @@ func (t *TemplateRenderer) Parse(group, id, name string, files []string, directo
 	return nil
 }
 
-func (t *TemplateRenderer) Execute(group, id, name string, data interface{}) (*bytes.Buffer, error) {
-	tmpl, err := t.Load(group, id)
+// Execute executes a cached template with the data provided
+// See Parse() for an explanation of the parameters
+func (t *TemplateRenderer) Execute(cacheGroup, cacheID, baseName string, data interface{}) (*bytes.Buffer, error) {
+	tmpl, err := t.Load(cacheGroup, cacheID)
 	if err != nil {
 		return nil, err
 	}
 
 	buf := new(bytes.Buffer)
-	err = tmpl.ExecuteTemplate(buf, name+config.TemplateExt, data)
+	err = tmpl.ExecuteTemplate(buf, baseName+config.TemplateExt, data)
 	if err != nil {
 		return nil, err
 	}
@@ -114,8 +136,24 @@ func (t *TemplateRenderer) Execute(group, id, name string, data interface{}) (*b
 	return buf, nil
 }
 
-func (t *TemplateRenderer) Load(group, id string) (*template.Template, error) {
-	load, ok := t.templateCache.Load(t.getCacheKey(group, id))
+// ParseAndExecute is a wrapper around Parse() and Execute()
+func (t *TemplateRenderer) ParseAndExecute(cacheGroup, cacheID, baseName string, files []string, directories []string, data interface{}) (*bytes.Buffer, error) {
+	var buf *bytes.Buffer
+	var err error
+
+	if err = t.Parse(cacheGroup, cacheID, baseName, files, directories); err != nil {
+		return nil, err
+	}
+	if buf, err = t.Execute(cacheGroup, cacheID, baseName, data); err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+// Load loads a template from the cache
+func (t *TemplateRenderer) Load(cacheGroup, cacheID string) (*template.Template, error) {
+	load, ok := t.templateCache.Load(t.getCacheKey(cacheGroup, cacheID))
 	if !ok {
 		return nil, errors.New("uncached page template requested")
 	}
@@ -128,10 +166,12 @@ func (t *TemplateRenderer) Load(group, id string) (*template.Template, error) {
 	return tmpl, nil
 }
 
+// GetTemplatesPath gets the complete path to the templates directory
 func (t *TemplateRenderer) GetTemplatesPath() string {
 	return t.templatesPath
 }
 
-func (t *TemplateRenderer) getCacheKey(group, id string) string {
-	return fmt.Sprintf("%s:%s", group, id)
+// getCacheKey gets a cache key for a given group and ID
+func (t *TemplateRenderer) getCacheKey(cacheGroup, cacheID string) string {
+	return fmt.Sprintf("%s:%s", cacheGroup, cacheID)
 }