Refactored isomorphic template rendering code

template.go

 	"bytes"
 	"errors"
 	"html/template"
-	"net/http"
+	"io"
 	"strings"
 
 	"honnef.co/go/js/dom"
 )
 
 type RenderParams struct {
-	Data           interface{}
-	ResponseWriter http.ResponseWriter
-	Element        dom.Element
-	Disposition    int8
-	Attributes     map[string]string
+	Data        interface{}
+	Writer      io.Writer
+	Element     dom.Element
+	Disposition int8
+	Attributes  map[string]string
 }
 
 func (t *Template) GetTemplateType() int8 {
 
 func (t *Template) Render(params *RenderParams) error {
 
-	if OperatingEnvironment() == ServerEnvironment && (params.ResponseWriter == nil) {
+	if OperatingEnvironment() == ServerEnvironment && (params.Writer == nil) {
 		return errors.New("Either the response writer and/or the request is nil!")
 	}
 
 
 func (t *Template) RenderTemplateOnServer(params *RenderParams) {
 
-	w := params.ResponseWriter
+	w := params.Writer
 
 	var tpl bytes.Buffer
 	if err := t.Execute(&tpl, params.Data); err != nil {

templatesetcontents.go → templatebundle.go

 	"strings"
 )
 
-type TemplateSetContents struct {
+type TemplateBundle struct {
 	items map[string]string
 }
 
-func NewTemplateSetContents() *TemplateSetContents {
+func NewTemplateBundle() *TemplateBundle {
 
-	return &TemplateSetContents{
+	return &TemplateBundle{
 		items: map[string]string{},
 		// Funcs:   template.FuncMap{},
 	}
 
 }
 
-func (tsc *TemplateSetContents) Items() map[string]string {
-	return tsc.items
+func (t *TemplateBundle) Items() map[string]string {
+	return t.items
 }
 
-func (tsc *TemplateSetContents) importTemplateFileContents() error {
+func (t *TemplateBundle) importTemplateFileContents() error {
 
 	templateDirectory := filepath.Clean(TemplateFilesPath)
 
 		if strings.HasSuffix(path, TemplateFileExtension) {
 			name := strings.TrimSuffix(strings.TrimPrefix(path, templateDirectory+string(os.PathSeparator)), TemplateFileExtension)
 			contents, err := ioutil.ReadFile(path)
-			tsc.items[name] = string(contents)
+			t.items[name] = string(contents)
 
 			if err != nil {
 				fmt.Println("error encountered while walking directory: ", err)

templateset.go

 )
 
 type TemplateSet struct {
-	members  map[string]*Template
-	Funcs    template.FuncMap
-	contents *TemplateSetContents
+	members map[string]*Template
+	Funcs   template.FuncMap
+	bundle  *TemplateBundle
 }
 
 func NewTemplateSet() *TemplateSet {
 	return t.members
 }
 
-func (t *TemplateSet) Contents() *TemplateSetContents {
-	return t.contents
+func (t *TemplateSet) Bundle() *TemplateBundle {
+	return t.bundle
 }
 
 func (t *TemplateSet) AddTemplateFile(name, filename string, templateType int8) error {
 	return nil
 }
 
-func (t *TemplateSet) RenderMember(templateName string, params *RenderParams) {
+func (t *TemplateSet) Render(templateName string, params *RenderParams) {
 
 	t.Members()[templateName].Render(params)
 
 
 func (t *TemplateSet) GatherTemplates() {
 
-	contents := NewTemplateSetContents()
-	contents.importTemplateFileContents()
-	t.ImportTemplatesFromMap(contents.Items())
-	t.contents = contents
+	bundle := NewTemplateBundle()
+	bundle.importTemplateFileContents()
+	t.ImportTemplatesFromMap(bundle.Items())
+	t.bundle = bundle
 
 }