Added message on migration

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)
-}