Refactored isomorphic redirect code to be more idiomatic. Added isomorphic template rendering functionality.

redirect.go

 package isokit
 
 import (
+	"errors"
 	"net/http"
 
 	"github.com/gopherjs/gopherjs/js"
 	js.Get("location").Set("href", destinationURL)
 }
 
-// Redirect performs a redirect operation based on the environment that
-// the program is operating under.
-func Redirect(items ...interface{}) {
-	var url string
-	var w http.ResponseWriter
-	var r *http.Request
-
-	if OperatingEnvironment() == ServerEnvironment && len(items) != 3 {
-		return
-	}
-
-	if OperatingEnvironment() == WebBrowserEnvironment && len(items) != 1 {
-		return
-	}
-
-	for _, item := range items {
-
-		switch t := item.(type) {
-		case http.ResponseWriter:
-			w = t
-		case *http.Request:
-			r = t
-		case string:
-			url = t
-		}
+type RedirectParams struct {
+	ResponseWriter http.ResponseWriter
+	Request        *http.Request
+	URL            string
+}
 
-	}
+func Redirect(params *RedirectParams) error {
 
-	if OperatingEnvironment() == ServerEnvironment && (w == nil || r == nil) {
-		return
+	if params.URL == "" {
+		return errors.New("The URL must be specified!")
 	}
 
-	if url == "" {
-		return
+	if OperatingEnvironment() == ServerEnvironment && (params.ResponseWriter == nil || params.Request == nil) {
+		return errors.New("Either the response writer and/or the request is nil!")
 	}
 
 	switch OperatingEnvironment() {
 	case WebBrowserEnvironment:
-		ClientRedirect(url)
+		ClientRedirect(params.URL)
 
 	case ServerEnvironment:
-		ServerRedirect(w, r, url)
+		ServerRedirect(params.ResponseWriter, params.Request, params.URL)
 	}
+
+	return nil
 }

template.go

+// The Isomorphic Go Project
+// Copyright (c) Wirecog, LLC. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license, which can be found in the LICENSE file.
+
+package isokit
+
+import (
+	"bytes"
+	"errors"
+	"html/template"
+	"net/http"
+	"strings"
+
+	"honnef.co/go/js/dom"
+)
+
+const (
+	TemplateRegular = iota
+	TemplatePartial
+	TemplateLayout
+)
+
+var (
+	PrefixNamePartial     = "partials/"
+	PrefixNameLayout      = "layouts/"
+	TemplateFileExtension = ".tmpl"
+	TemplateFilesPath     = "./templates"
+)
+
+type Template struct {
+	*template.Template
+	templateType int8
+}
+
+const (
+	PlacementAppendTo = iota
+	PlacementReplaceInnerContents
+	PlacementInsertBefore
+)
+
+type RenderParams struct {
+	Data           interface{}
+	ResponseWriter http.ResponseWriter
+	Element        dom.Element
+	Disposition    int8
+	Attributes     map[string]string
+}
+
+func (t *Template) GetTemplateType() int8 {
+
+	if t == nil {
+		return -1
+	} else {
+		return t.templateType
+	}
+}
+
+func (t *Template) NameWithPrefix() string {
+
+	var prefixName string
+	switch t.templateType {
+
+	case TemplateRegular:
+		prefixName = ""
+
+	case TemplatePartial:
+		prefixName = PrefixNamePartial
+
+	case TemplateLayout:
+		prefixName = PrefixNameLayout
+
+	}
+
+	if strings.HasPrefix(t.Name(), prefixName) {
+		return t.Name()
+	} else {
+		return prefixName + t.Name()
+	}
+
+}
+
+func (t *Template) Render(params *RenderParams) error {
+
+	if OperatingEnvironment() == ServerEnvironment && (params.ResponseWriter == nil) {
+		return errors.New("Either the response writer and/or the request is nil!")
+	}
+
+	if OperatingEnvironment() == WebBrowserEnvironment && params.Element == nil {
+		return errors.New("The element to render relative to is nil!")
+	}
+
+	switch OperatingEnvironment() {
+	case WebBrowserEnvironment:
+		t.RenderTemplateOnClient(params)
+
+	case ServerEnvironment:
+		t.RenderTemplateOnServer(params)
+	}
+
+	return nil
+}
+
+func (t *Template) RenderTemplateOnClient(params *RenderParams) {
+
+	var tpl bytes.Buffer
+
+	if err := t.Execute(&tpl, params.Data); err != nil {
+		println("error: ", err)
+	}
+
+	div := dom.GetWindow().Document().CreateElement("div").(*dom.HTMLDivElement)
+	div.SetInnerHTML(string(tpl.Bytes()))
+
+	if _, ok := params.Attributes["id"]; ok {
+		div.SetID(params.Attributes["id"])
+	}
+
+	if _, ok := params.Attributes["class"]; ok {
+		div.SetAttribute("class", params.Attributes["class"])
+	}
+
+	switch params.Disposition {
+	case PlacementAppendTo:
+		params.Element.AppendChild(div)
+	case PlacementReplaceInnerContents:
+		params.Element.SetInnerHTML(div.OuterHTML())
+	case PlacementInsertBefore:
+		params.Element.ParentNode().InsertBefore(div, params.Element)
+	default:
+		params.Element.AppendChild(div)
+	}
+
+}
+
+func (t *Template) RenderTemplateOnServer(params *RenderParams) {
+
+	w := params.ResponseWriter
+
+	var tpl bytes.Buffer
+	if err := t.Execute(&tpl, params.Data); err != nil {
+		println("error: ", err)
+	}
+	w.Write(tpl.Bytes())
+}

templateset.go

+// The Isomorphic Go Project
+// Copyright (c) Wirecog, LLC. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license, which can be found in the LICENSE file.
+
+package isokit
+
+import (
+	"html/template"
+	"io/ioutil"
+	"strings"
+)
+
+type TemplateSet struct {
+	members  map[string]*Template
+	Funcs    template.FuncMap
+	contents *TemplateSetContents
+}
+
+func NewTemplateSet() *TemplateSet {
+	return &TemplateSet{
+		members: map[string]*Template{},
+		Funcs:   template.FuncMap{},
+	}
+}
+
+func (t *TemplateSet) Members() map[string]*Template {
+	return t.members
+}
+
+func (t *TemplateSet) Contents() *TemplateSetContents {
+	return t.contents
+}
+
+func (t *TemplateSet) AddTemplateFile(name, filename string, templateType int8) error {
+	contents, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+
+	tpl, err := template.New(name).Funcs(t.Funcs).Parse(string(contents))
+	template := Template{
+		Template:     tpl,
+		templateType: templateType,
+	}
+
+	t.members[tpl.Name()] = &template
+	return nil
+
+}
+
+func (t *TemplateSet) MakeAllAssociations() error {
+
+	for _, template := range t.members {
+
+		for _, member := range t.members {
+
+			if member.Lookup(template.NameWithPrefix()) == nil {
+
+				if _, err := member.AddParseTree(template.NameWithPrefix(), template.Tree); err != nil {
+					println(err)
+					return err
+				}
+			}
+
+		}
+
+	}
+	return nil
+}
+
+func (t *TemplateSet) ImportTemplatesFromMap(templateMap map[string]string) error {
+
+	for name, templateContents := range templateMap {
+
+		var templateType int8
+		if strings.Contains(name, PrefixNamePartial) {
+			templateType = TemplatePartial
+		} else if strings.Contains(name, PrefixNameLayout) {
+			templateType = TemplateLayout
+		} else {
+			templateType = TemplateRegular
+		}
+
+		tpl, err := template.New(name).Funcs(t.Funcs).Parse(templateContents)
+
+		if err != nil {
+			println("Encountered error when attempting to parse template: ", err)
+
+			return err
+		}
+
+		tmpl := Template{
+			Template:     tpl,
+			templateType: templateType,
+		}
+		t.members[name] = &tmpl
+
+	}
+	t.MakeAllAssociations()
+	return nil
+}
+
+func (t *TemplateSet) RenderMember(templateName string, params *RenderParams) {
+
+	t.Members()[templateName].Render(params)
+
+}
+
+func (t *TemplateSet) GatherTemplates() {
+
+	contents := NewTemplateSetContents()
+	contents.importTemplateFileContents()
+	t.ImportTemplatesFromMap(contents.Items())
+	t.contents = contents
+
+}

templatesetcontents.go

+// The Isomorphic Go Project
+// Copyright (c) Wirecog, LLC. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license, which can be found in the LICENSE file.
+
+package isokit
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type TemplateSetContents struct {
+	items map[string]string
+}
+
+func NewTemplateSetContents() *TemplateSetContents {
+
+	return &TemplateSetContents{
+		items: map[string]string{},
+		// Funcs:   template.FuncMap{},
+	}
+
+}
+
+func (tsc *TemplateSetContents) Items() map[string]string {
+	return tsc.items
+}
+
+func (tsc *TemplateSetContents) importTemplateFileContents() error {
+
+	templateDirectory := filepath.Clean(TemplateFilesPath)
+
+	if err := filepath.Walk(templateDirectory, func(path string, info os.FileInfo, err error) error {
+		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)
+
+			if err != nil {
+				fmt.Println("error encountered while walking directory: ", err)
+				return err
+			}
+
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	return nil
+
+}