Updated source code to stable state

basicform.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 "strings"
+
+type BasicForm struct {
+	formParams *FormParams
+
+	prefillFields []string
+	fields        map[string]string
+	errors        map[string]string
+}
+
+func (c *BasicForm) PrefillFields() []string {
+	return c.prefillFields
+}
+
+func (c *BasicForm) Fields() map[string]string {
+	return c.fields
+}
+
+func (c *BasicForm) Errors() map[string]string {
+	return c.errors
+}
+
+func (c *BasicForm) FormParams() *FormParams {
+	return c.formParams
+
+}
+
+func (c *BasicForm) SetPrefillFields(prefillFields []string) {
+	c.prefillFields = prefillFields
+}
+
+func (c *BasicForm) SetFields(fields map[string]string) {
+	c.fields = fields
+}
+
+func (c *BasicForm) GetFieldValue(key string) string {
+
+	if _, ok := c.fields[key]; ok {
+		return c.fields[key]
+	} else {
+		return ""
+	}
+}
+
+func (c *BasicForm) SetErrors(errors map[string]string) {
+	c.errors = errors
+}
+
+func (c *BasicForm) SetFormParams(formParams *FormParams) {
+	c.formParams = formParams
+}
+
+func (c *BasicForm) SetError(key string, message string) {
+	c.errors[key] = message
+}
+
+func (c *BasicForm) ClearErrors() {
+	c.errors = make(map[string]string)
+}
+
+func (c *BasicForm) PopulateFields() {
+	for _, fieldName := range c.prefillFields {
+		c.fields[fieldName] = FormValue(c.FormParams(), fieldName)
+	}
+}
+
+func (c *BasicForm) DisplayErrors() {
+	if OperatingEnvironment() == WebBrowserEnvironment && c.formParams.FormElement != nil {
+		errorSpans := c.formParams.FormElement.QuerySelectorAll(".formError")
+		for _, v := range errorSpans {
+			v.SetInnerHTML(c.errors[strings.Replace(v.GetAttribute("id"), "Error", "", -1)])
+		}
+	}
+}
+
+func (c *BasicForm) RegenerateErrors() {
+
+	c.errors = make(map[string]string)
+
+	if OperatingEnvironment() == WebBrowserEnvironment && c.formParams.FormElement != nil {
+		errorSpans := c.formParams.FormElement.QuerySelectorAll(".formError")
+		for _, v := range errorSpans {
+			v.SetInnerHTML(c.errors[strings.Replace(v.GetAttribute("id"), "Error", "", -1)])
+		}
+	}
+
+}

fetchtemplatebundle.go

+package isokit
+
+import (
+	"bytes"
+	"encoding/gob"
+	"html/template"
+
+	"honnef.co/go/js/xhr"
+)
+
+func FetchTemplateBundle(templateSetChannel chan *TemplateSet) {
+
+	data, err := xhr.Send("POST", "/template-bundle", nil)
+	if err != nil {
+		println("Encountered error: ", err)
+		println(err)
+	}
+	var templateBundleMap map[string]string
+	var templateBundleMapBuffer bytes.Buffer
+
+	dec := gob.NewDecoder(&templateBundleMapBuffer)
+	templateBundleMapBuffer = *bytes.NewBuffer(data)
+	err = dec.Decode(&templateBundleMap)
+
+	if err != nil {
+		println("Encountered error: ", err)
+		panic(err)
+	}
+
+	templateSet := NewTemplateSet()
+	err = templateSet.ImportTemplatesFromMap(templateBundleMap)
+
+	if err != nil {
+		println("Encountered import error: ", err)
+		panic(err)
+	}
+
+	templateSetChannel <- templateSet
+}
+
+func FetchTemplateBundleWithSuppliedFunctionMap(templateSetChannel chan *TemplateSet, funcMap template.FuncMap) {
+
+	data, err := xhr.Send("POST", "/template-bundle", nil)
+	if err != nil {
+		println("Encountered error: ", err)
+		println(err)
+	}
+	var templateBundleMap map[string]string
+	var templateBundleMapBuffer bytes.Buffer
+
+	dec := gob.NewDecoder(&templateBundleMapBuffer)
+	templateBundleMapBuffer = *bytes.NewBuffer(data)
+	err = dec.Decode(&templateBundleMap)
+
+	if err != nil {
+		println("Encountered error: ", err)
+		panic(err)
+	}
+
+	templateSet := NewTemplateSet()
+	templateSet.Funcs = funcMap
+	err = templateSet.ImportTemplatesFromMap(templateBundleMap)
+
+	if err != nil {
+		println("Encountered import error: ", err)
+		panic(err)
+	}
+
+	templateSetChannel <- templateSet
+}

form.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.
+
+// +build !clientonly
+
+package isokit
+
+import (
+	"honnef.co/go/js/dom"
+)
+
+type Form interface {
+	Validate() bool
+	Fields() map[string]string
+	Errors() map[string]string
+	FormParams() *FormParams
+	PrefillFields()
+	SetFields(fields map[string]string)
+	SetErrors(errors map[string]string)
+	SetFormParams(formParams *FormParams)
+	SetPrefillFields(prefillFields []string)
+}
+
+func FormValue(fp *FormParams, key string) string {
+
+	var result string
+
+	if OperatingEnvironment() == ServerEnvironment && fp.Request == nil {
+		return ""
+	}
+
+	switch OperatingEnvironment() {
+
+	case ServerEnvironment:
+
+		if fp.UseFormFieldsForValidation == true {
+			result = fp.FormFields[key]
+		} else {
+			result = fp.Request.FormValue(key)
+		}
+
+	case WebBrowserEnvironment:
+
+		field := fp.FormElement.QuerySelector("[name=" + key + "]")
+
+		switch field.(type) {
+		case *dom.HTMLInputElement:
+			result = field.(*dom.HTMLInputElement).Value
+		case *dom.HTMLTextAreaElement:
+			result = field.(*dom.HTMLTextAreaElement).Value
+		case *dom.HTMLSelectElement:
+			result = field.(*dom.HTMLSelectElement).Value
+
+		}
+	}
+
+	return result
+}

formjs.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.
+
+// +build clientonly
+
+package isokit
+
+import (
+	"honnef.co/go/js/dom"
+)
+
+type Form interface {
+	Validate() bool
+	AutofillFields() []string
+	Fields() map[string]string
+	Errors() map[string]string
+	//	SetError(key string, message string)
+}
+
+func FormValue(fp *FormParams, key string) string {
+
+	var result string
+
+	field := fp.FormElement.QuerySelector("[name=" + key + "]")
+
+	switch field.(type) {
+	case *dom.HTMLInputElement:
+		result = field.(*dom.HTMLInputElement).Value
+	case *dom.HTMLTextAreaElement:
+		result = field.(*dom.HTMLTextAreaElement).Value
+	case *dom.HTMLSelectElement:
+		result = field.(*dom.HTMLSelectElement).Value
+
+	}
+
+	return result
+}

formparams.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.
+
+// +build !clientonly
+
+package isokit
+
+import (
+	"net/http"
+
+	"honnef.co/go/js/dom"
+)
+
+type FormParams struct {
+	FormElement                *dom.HTMLFormElement
+	ResponseWriter             http.ResponseWriter
+	Request                    *http.Request
+	UseFormFieldsForValidation bool
+	FormFields                 map[string]string
+}

formparamsjs.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.
+
+// +build clientonly
+
+package isokit
+
+import (
+	"honnef.co/go/js/dom"
+)
+
+type FormParams struct {
+	FormElement                *dom.HTMLFormElement
+	UseFormFieldsForValidation bool
+	FormFields                 map[string]string
+}

gopherjshandlers.go

+// +build !clientonly
+
+package isokit
+
+import (
+	"net/http"
+)
+
+func GopherjsScriptHandler(webAppRoot string) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.ServeFile(w, r, webAppRoot+"/client/client.js")
+	})
+}
+
+func GopherjsScriptMapHandler(webAppRoot string) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.ServeFile(w, r, webAppRoot+"/client/client.js.map")
+	})
+}

isokit.go

 // in an Isomorphic Go web application.
 package isokit
 
-import (
-	"fmt"
-	"os"
-)
-
 var (
 	WebAppRoot = ""
 )
-
-func init() {
-	fmt.Println("The isokit package has moved to https://go.isomorphicgo.org.")
-	fmt.Print("You can 'go get' it like so:\t", "'go get -u go.isomorphicgo.org/go/isokit'")
-	os.Exit(1)
-}

opdetails.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 "github.com/gopherjs/gopherjs/js"
+
+type OperatingDetails struct {
+	Environment int
+	Runtime     int
+}
+
+const (
+	ServerEnvironment = iota
+	WebBrowserEnvironment
+)
+
+const (
+	GoRuntime = iota
+	JSRuntime
+)
+
+var (
+	operatingEnvironment int
+	operatingRuntime     int
+)
+
+func isJSRuntime() bool {
+	return js.Global != nil
+}
+
+func isGoRuntime() bool {
+	return !isJSRuntime()
+}
+
+func isWebBrowserEnvironment() bool {
+	return isJSRuntime() && js.Global.Get("document") != js.Undefined
+}
+
+func isServerEnvironment() bool {
+
+	if isGoRuntime() == true {
+		return true
+	} else if isJSRuntime() == true {
+		return !isWebBrowserEnvironment()
+	} else {
+		return true
+	}
+
+}
+
+func OperatingEnvironment() int {
+	return operatingEnvironment
+}
+
+func OperatingRuntime() int {
+	return operatingRuntime
+}
+
+func initializeOperatingDetails() {
+
+	if isJSRuntime() == true {
+		operatingRuntime = WebBrowserEnvironment
+	}
+
+	if isGoRuntime() == true {
+		operatingRuntime = GoRuntime
+	}
+
+	if isServerEnvironment() == true {
+		operatingEnvironment = ServerEnvironment
+	}
+
+	if isWebBrowserEnvironment() == true {
+		operatingEnvironment = WebBrowserEnvironment
+	}
+
+}
+
+func init() {
+
+	initializeOperatingDetails()
+
+}

redirect.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.
+
+// +build !clientonly
+
+package isokit
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/gopherjs/gopherjs/js"
+)
+
+// ServerRedirect performs a redirect when operating on the server-side.
+func ServerRedirect(w http.ResponseWriter, r *http.Request, destinationURL string) {
+	http.Redirect(w, r, destinationURL, 302)
+}
+
+// ClientRedirect performs a redirect when operating on the client-side.
+func ClientRedirect(destinationURL string) {
+	js := js.Global
+	js.Get("location").Set("href", destinationURL)
+}
+
+type RedirectParams struct {
+	ResponseWriter http.ResponseWriter
+	Request        *http.Request
+	URL            string
+}
+
+func Redirect(params *RedirectParams) error {
+
+	if params.URL == "" {
+		return errors.New("The URL must be specified!")
+	}
+
+	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(params.URL)
+
+	case ServerEnvironment:
+		ServerRedirect(params.ResponseWriter, params.Request, params.URL)
+	}
+
+	return nil
+}

route.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 (
+	"context"
+	"regexp"
+	"strings"
+)
+
+const (
+	RouteWithParamsPattern = `/([^/]*)`
+	RouteOnlyPrefixPattern = `/`
+	RouteSuffixPattern     = `/?$`
+)
+
+type Handler interface {
+	ServeRoute(context.Context)
+}
+
+type HandlerFunc func(context.Context)
+
+func (f HandlerFunc) ServeRoute(ctx context.Context) {
+	f(ctx)
+}
+
+type RouteVarsKey string
+
+type Route struct {
+	handler  Handler
+	regex    *regexp.Regexp
+	varNames []string
+}
+
+func NewRoute(path string, handler HandlerFunc) *Route {
+	r := &Route{
+		handler: handler,
+	}
+
+	path = strings.TrimPrefix(path, `/`)
+	if strings.HasSuffix(path, `/`) {
+		path = strings.TrimSuffix(path, `/`)
+	}
+
+	routeParts := strings.Split(path, "/")
+
+	var routePattern string = `^`
+	for _, routePart := range routeParts {
+		if strings.HasPrefix(routePart, `{`) && strings.HasSuffix(routePart, `}`) {
+			routePattern += RouteWithParamsPattern
+			routePart = strings.TrimPrefix(path, `{`)
+			routePart = strings.TrimSuffix(path, `}`)
+			r.varNames = append(r.varNames, routePart)
+		} else {
+			routePattern += RouteOnlyPrefixPattern + routePart
+		}
+	}
+	routePattern += RouteSuffixPattern
+	r.regex = regexp.MustCompile(routePattern)
+	return r
+}

router.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 (
+	"context"
+	"strings"
+
+	"github.com/gopherjs/gopherjs/js"
+	"honnef.co/go/js/dom"
+)
+
+type Router struct {
+	routes   []*Route
+	listener func(*js.Object)
+}
+
+func NewRouter() *Router {
+
+	initializeHistoryInteractions()
+
+	return &Router{
+		routes: []*Route{},
+	}
+}
+
+func (r *Router) Handle(path string, handler Handler) *Route {
+	return r.HandleFunc(path, handler.(HandlerFunc))
+}
+
+func (r *Router) HandleFunc(path string, handler HandlerFunc) *Route {
+	route := NewRoute(path, handler)
+	r.routes = append(r.routes, route)
+	return route
+}
+
+func (r *Router) Listen() {
+	r.RegisterLinks("body a")
+}
+
+func (r *Router) RegisterLinks(querySelector string) {
+	document := dom.GetWindow().Document().(dom.HTMLDocument)
+	links := document.QuerySelectorAll(querySelector)
+
+	for _, link := range links {
+
+		href := link.GetAttribute("href")
+		switch {
+
+		case strings.HasPrefix(href, "/") && !strings.HasPrefix(href, "//"):
+
+			if r.listener != nil {
+				link.RemoveEventListener("click", false, r.listener)
+			}
+
+			r.listener = link.AddEventListener("click", false, r.linkHandler)
+		}
+	}
+
+}
+
+func (r *Router) linkHandler(event dom.Event) {
+
+	uri := event.CurrentTarget().GetAttribute("href")
+	path := strings.Split(uri, "?")[0]
+	//	leastParams := -1
+	var matchedRoute *Route
+	var parts []string
+	var lowestMatchCountSet bool = false
+	var lowestMatchCount int = -1
+
+	for _, route := range r.routes {
+
+		matches := route.regex.FindStringSubmatch(path)
+		matchesExist := len(matches) > 0 && matches != nil
+		isLowestMatchCount := (lowestMatchCountSet == false) || (len(matches) < lowestMatchCount)
+
+		if matchesExist && isLowestMatchCount {
+			matchedRoute = route
+			parts = matches[1:]
+			lowestMatchCount = len(matches)
+			lowestMatchCountSet = true
+		}
+	}
+
+	if matchedRoute != nil {
+		event.PreventDefault()
+		js.Global.Get("history").Call("pushState", nil, "", uri)
+		routeVars := make(map[string]string)
+
+		for i, part := range parts {
+			routeVars[matchedRoute.varNames[i]+`}`] = part
+		}
+
+		var ctx context.Context
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		k := RouteVarsKey("Vars")
+		ctx = context.WithValue(ctx, k, routeVars)
+		go matchedRoute.handler.ServeRoute(ctx)
+	}
+}
+
+func initializeHistoryInteractions() {
+	// Handler for back/forward button interactions
+	dom.GetWindow().AddEventListener("popstate", false, func(event dom.Event) {
+		var location = js.Global.Get("location")
+		js.Global.Set("location", location)
+	})
+}

static.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.
+
+// +build !clientonly
+
+package isokit
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	"github.com/tdewolff/minify"
+	"github.com/tdewolff/minify/css"
+	"github.com/tdewolff/minify/js"
+)
+
+var StaticAssetsPath string
+var ShouldMinifyStaticAssets bool
+
+func findStaticAssets(ext string, paths []string) []string {
+
+	var files []string
+
+	for i := 0; i < len(paths); i++ {
+		//fmt.Println("file search path: ", paths[i])
+		filepath.Walk(paths[i], func(path string, f os.FileInfo, _ error) error {
+			if !f.IsDir() {
+				r, err := regexp.MatchString(ext, f.Name())
+				if err == nil && r {
+					files = append(files, path)
+				}
+			}
+			return nil
+		})
+
+	}
+	return files
+}
+
+func bundleJavaScript(jsfiles []string, shouldMinify bool) {
+
+	outputFileName := "cogimports.js"
+	if shouldMinify == true {
+		outputFileName = "cogimports.min.js"
+	}
+
+	var result []byte = make([]byte, 0)
+
+	if StaticAssetsPath == "" {
+		return
+	}
+
+	if _, err := os.Stat(filepath.Join(StaticAssetsPath, "js")); os.IsNotExist(err) {
+		os.Mkdir(filepath.Join(StaticAssetsPath, "js"), 0711)
+	}
+
+	destinationFile := filepath.Join(StaticAssetsPath, "js", outputFileName)
+
+	for i := 0; i < len(jsfiles); i++ {
+		b, err := ioutil.ReadFile(jsfiles[i])
+		if err != nil {
+			log.Println(err)
+		}
+		result = append(result, b...)
+	}
+
+	if shouldMinify == true {
+
+		m := minify.New()
+		m.AddFunc("text/javascript", js.Minify)
+		b, err := m.Bytes("text/javascript", result)
+
+		if err != nil {
+			log.Println(err)
+		}
+
+		err = ioutil.WriteFile(destinationFile, b, 0644)
+
+		if err != nil {
+			log.Println(err)
+		}
+
+	} else {
+		err := ioutil.WriteFile(destinationFile, result, 0644)
+
+		if err != nil {
+			log.Println(err)
+		}
+
+	}
+
+}
+
+func bundleCSS(cssfiles []string, shouldMinify bool) {
+
+	outputFileName := "cogimports.css"
+	if shouldMinify == true {
+		outputFileName = "cogimports.min.css"
+	}
+
+	var result []byte = make([]byte, 0)
+
+	if StaticAssetsPath == "" {
+		return
+	}
+
+	if _, err := os.Stat(filepath.Join(StaticAssetsPath, "css")); os.IsNotExist(err) {
+		os.Mkdir(filepath.Join(StaticAssetsPath, "css"), 0711)
+	}
+
+	destinationFile := filepath.Join(StaticAssetsPath, "css", outputFileName)
+
+	for i := 0; i < len(cssfiles); i++ {
+		b, err := ioutil.ReadFile(cssfiles[i])
+		if err != nil {
+			log.Println(err)
+		}
+		result = append(result, b...)
+	}
+
+	if shouldMinify == true {
+
+		m := minify.New()
+		m.AddFunc("text/css", css.Minify)
+		b, err := m.Bytes("text/css", result)
+
+		if err != nil {
+			log.Println(err)
+		}
+
+		err = ioutil.WriteFile(destinationFile, b, 0644)
+
+	} else {
+		err := ioutil.WriteFile(destinationFile, result, 0644)
+		if err != nil {
+			log.Println(err)
+		}
+
+	}
+
+}
+
+func BundleStaticAssets() {
+
+	if ShouldBundleStaticAssets == false {
+		return
+	}
+
+	jsfiles := findStaticAssets(".js", CogStaticAssetsSearchPaths)
+	bundleJavaScript(jsfiles, ShouldMinifyStaticAssets)
+	cssfiles := findStaticAssets(".css", CogStaticAssetsSearchPaths)
+	bundleCSS(cssfiles, ShouldMinifyStaticAssets)
+}
+
+func init() {
+	CogStaticAssetsSearchPaths = make([]string, 0)
+}

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"
+	"io"
+	"log"
+	"strings"
+
+	"honnef.co/go/js/dom"
+)
+
+const (
+	TemplateRegular = iota
+	TemplatePartial
+	TemplateLayout
+)
+
+var (
+	PrefixNamePartial            = "partials/"
+	PrefixNameLayout             = "layouts/"
+	TemplateFileExtension        = ".tmpl"
+	TemplateFilesPath            = "./templates"
+	UseStaticTemplateBundleFile  = false
+	StaticTemplateBundleFilePath = ""
+	ShouldBundleStaticAssets     = true
+)
+
+type Template struct {
+	*template.Template
+	templateType int8
+}
+
+const (
+	PlacementAppendTo = iota
+	PlacementReplaceInnerContents
+	PlacementInsertBefore
+)
+
+type RenderParams struct {
+	Data                          interface{}
+	Writer                        io.Writer
+	Element                       dom.Element
+	Disposition                   int8
+	Attributes                    map[string]string
+	ShouldPopulateRenderedContent bool
+	RenderedContent               string
+	ShouldSkipFinalRenderStep     bool
+	PageTitle                     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.Writer == 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 {
+		log.Println("Error encountered when attempting to render template on client: ", err)
+	}
+
+	if params.ShouldPopulateRenderedContent == true {
+		params.RenderedContent = string(tpl.Bytes())
+	}
+
+	if params.ShouldSkipFinalRenderStep == true {
+		return
+	}
+
+	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)
+	}
+
+	if params.PageTitle != "" && params.ShouldPopulateRenderedContent == false {
+		dom.GetWindow().Document().Underlying().Set("title", params.PageTitle)
+	}
+
+}
+
+func (t *Template) RenderTemplateOnServer(params *RenderParams) {
+
+	w := params.Writer
+	var tpl bytes.Buffer
+	if err := t.Execute(&tpl, params.Data); err != nil {
+		log.Println("Error encountered when attempting to render template on server: ", err)
+	}
+	w.Write(tpl.Bytes())
+}

templatebundle.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 (
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+type TemplateBundle struct {
+	items map[string]string
+}
+
+func NewTemplateBundle() *TemplateBundle {
+
+	return &TemplateBundle{
+		items: map[string]string{},
+	}
+
+}
+
+func (t *TemplateBundle) Items() map[string]string {
+	return t.items
+}
+
+func normalizeTemplateNameForWindows(path, templateDirectory, TemplateFileExtension string) string {
+
+	result := strings.Replace(path, templateDirectory, "", -1)
+	result = strings.Replace(result, string(os.PathSeparator), "/", -1)
+	result = strings.Replace(result, TemplateFileExtension, "", -1)
+	result = strings.TrimPrefix(result, `/`)
+	return result
+}
+
+func normalizeCogTemplateNameForWindows(path, templateDirectory, TemplateFileExtension string) string {
+
+	result := strings.Replace(path, templateDirectory, "", -1)
+	result = strings.Replace(result, string(os.PathSeparator), "/", -1)
+	result = strings.Replace(result, TemplateFileExtension, "", -1)
+	result = strings.TrimPrefix(result, `/`)
+	result = result + "/" + result
+	return result
+}
+
+func (t *TemplateBundle) importTemplateFileContents(templatesPath string) error {
+
+	templateDirectory := filepath.Clean(templatesPath)
+
+	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+"/"), TemplateFileExtension)
+
+			if runtime.GOOS == "windows" {
+				name = normalizeTemplateNameForWindows(path, templateDirectory, TemplateFileExtension)
+			}
+
+			contents, err := ioutil.ReadFile(path)
+			t.items[name] = string(contents)
+
+			if err != nil {
+				log.Println("error encountered while walking directory: ", err)
+				return err
+			}
+
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	return nil
+
+}
+
+func (t *TemplateBundle) importTemplateFileContentsForCog(templatesPath string, prefixName string, templateFileExtension string) error {
+
+	templateDirectory := filepath.Clean(templatesPath)
+	RegisterStaticAssetsSearchPath(strings.Replace(templateDirectory, string(os.PathSeparator)+"templates", "", -1))
+	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), TemplateFileExtension)
+
+			if runtime.GOOS == "windows" {
+				name = normalizeCogTemplateNameForWindows(path, templateDirectory, TemplateFileExtension)
+				prefixName = "cog:"
+			}
+
+			name = prefixName + name
+			contents, err := ioutil.ReadFile(path)
+			t.items[name] = string(contents)
+
+			if err != nil {
+				log.Println("error encountered while walking directory: ", err)
+				return err
+			}
+
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	return nil
+
+}

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 (
+	"bytes"
+	"encoding/gob"
+	"errors"
+	"html/template"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var CogStaticAssetsSearchPaths []string
+
+type TemplateSet struct {
+	members           map[string]*Template
+	Funcs             template.FuncMap
+	bundle            *TemplateBundle
+	TemplateFilesPath string
+}
+
+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) Bundle() *TemplateBundle {
+	return t.bundle
+}
+
+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 {
+			log.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) Render(templateName string, params *RenderParams) {
+
+	t.Members()[templateName].Render(params)
+
+}
+
+func (t *TemplateSet) PersistTemplateBundleToDisk() error {
+
+	dirPath := filepath.Dir(StaticTemplateBundleFilePath)
+	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
+
+		return errors.New("The specified directory for the StaticTemplateBundleFilePath, " + dirPath + ", does not exist!")
+
+	} else {
+
+		var templateContentItemsBuffer bytes.Buffer
+		enc := gob.NewEncoder(&templateContentItemsBuffer)
+		m := t.bundle.Items()
+		err := enc.Encode(&m)
+		if err != nil {
+			return err
+		}
+		err = ioutil.WriteFile(StaticTemplateBundleFilePath, templateContentItemsBuffer.Bytes(), 0644)
+		if err != nil {
+			return err
+		} else {
+			return nil
+		}
+
+	}
+
+}
+
+func (t *TemplateSet) RestoreTemplateBundleFromDisk() error {
+
+	if _, err := os.Stat(StaticTemplateBundleFilePath); os.IsNotExist(err) {
+		return errors.New("The StaticTemplateBundleFilePath, " + StaticTemplateBundleFilePath + ", does not exist")
+	} else {
+
+		data, err := ioutil.ReadFile(StaticTemplateBundleFilePath)
+		if err != nil {
+			return err
+		}
+
+		var templateBundleMap map[string]string
+		var templateBundleMapBuffer bytes.Buffer
+		dec := gob.NewDecoder(&templateBundleMapBuffer)
+		templateBundleMapBuffer = *bytes.NewBuffer(data)
+		err = dec.Decode(&templateBundleMap)
+
+		if err != nil {
+			return err
+		}
+
+		t.ImportTemplatesFromMap(templateBundleMap)
+		bundle := &TemplateBundle{items: templateBundleMap}
+		t.bundle = bundle
+
+		return nil
+	}
+}
+
+func (t *TemplateSet) GatherTemplates() {
+
+	if UseStaticTemplateBundleFile == true {
+		err := t.RestoreTemplateBundleFromDisk()
+		if err != nil {
+			log.Println("Didn't find a template bundle from disk, will generate a new template bundle.")
+		} else {
+			return
+		}
+	}
+
+	bundle := NewTemplateBundle()
+
+	templatesPath := t.TemplateFilesPath
+	if templatesPath == "" {
+		templatesPath = TemplateFilesPath
+	}
+	bundle.importTemplateFileContents(templatesPath)
+	t.ImportTemplatesFromMap(bundle.Items())
+	t.bundle = bundle
+
+	if StaticTemplateBundleFilePath != "" {
+		err := t.PersistTemplateBundleToDisk()
+		if err != nil {
+			log.Println("Failed to persist the template bundle to disk, in GatherTemplates, with error: ", err)
+		}
+	}
+
+}
+
+func (t *TemplateSet) GatherCogTemplates(cogTemplatePath string, prefixName string, templateFileExtension string) {
+
+	if ShouldBundleStaticAssets == false || UseStaticTemplateBundleFile == true {
+		return
+	}
+
+	bundle := NewTemplateBundle()
+
+	templatesPath := cogTemplatePath
+	bundle.importTemplateFileContentsForCog(templatesPath, prefixName, templateFileExtension)
+	t.ImportTemplatesFromMap(bundle.Items())
+
+	for k, v := range bundle.Items() {
+		t.bundle.items[k] = v
+	}
+
+	if StaticTemplateBundleFilePath != "" {
+		err := t.PersistTemplateBundleToDisk()
+		if err != nil {
+			log.Println("Failed to persist the template bundle to disk, in GatherCogTemplates, with error: ", err)
+		}
+	}
+
+}
+
+func StaticTemplateBundleFileExists() bool {
+
+	if _, err := os.Stat(StaticTemplateBundleFilePath); os.IsNotExist(err) {
+		return false
+	} else {
+		return true
+	}
+
+}
+
+func RegisterStaticAssetsSearchPath(path string) {
+	//fmt.Println("cog search path: ", path)
+	CogStaticAssetsSearchPaths = append(CogStaticAssetsSearchPaths, path)
+}