Refactored template code. Added client-side routing.

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 {
+	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()
+}
+
+func (r *Router) RegisterLinks() {
+	document := dom.GetWindow().Document().(dom.HTMLDocument)
+	for _, link := range document.Links() {
+		href := link.GetAttribute("href")
+		switch {
+
+		case strings.HasPrefix(href, "/") && !strings.HasPrefix(href, "//"):
+
+			if r.listener != nil {
+				link.RemoveEventListener("click", true, r.listener)
+			}
+			r.listener = link.AddEventListener("click", true, 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)
+	}
+}

templatebundle.go

 	return t.items
 }
 
-func (t *TemplateBundle) importTemplateFileContents() error {
+func (t *TemplateBundle) importTemplateFileContents(templatesPath string) error {
 
-	templateDirectory := filepath.Clean(TemplateFilesPath)
+	templateDirectory := filepath.Clean(templatesPath)
 
 	if err := filepath.Walk(templateDirectory, func(path string, info os.FileInfo, err error) error {
 		if strings.HasSuffix(path, TemplateFileExtension) {

templateset.go

 )
 
 type TemplateSet struct {
-	members map[string]*Template
-	Funcs   template.FuncMap
-	bundle  *TemplateBundle
+	members           map[string]*Template
+	Funcs             template.FuncMap
+	bundle            *TemplateBundle
+	TemplateFilesPath string
 }
 
 func NewTemplateSet() *TemplateSet {
 func (t *TemplateSet) GatherTemplates() {
 
 	bundle := NewTemplateBundle()
-	bundle.importTemplateFileContents()
+
+	templatesPath := t.TemplateFilesPath
+	if templatesPath == "" {
+		templatesPath = TemplateFilesPath
+	}
+	bundle.importTemplateFileContents(templatesPath)
 	t.ImportTemplatesFromMap(bundle.Items())
 	t.bundle = bundle