gromer

git clone https://pyrossh.dev/repos/gromer.git

gromer is a framework and cli to build multipage web apps in golang using htmx and alpinejs.

f3a4c91b — pyros2097

make routing work

Files changed (8) hide show

app_nowasm.go +42 -26
app_wasm.go +22 -2
attributes_test.go +2 -2
example/main.go +7 -9
go.mod +1 -0
go.sum +2 -0
tree.go +1281 -0
utils.go +5 -29

app_nowasm.go CHANGED Viewed

@@ -8,46 +8,57 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
-	"strconv"
+	"strings"
 	"github.com/akrylysov/algnhsa"
 	"github.com/markbates/pkger"
 )
+// ServeFiles serves files from the given file system root.
+// The path must end with "/*filepath", files are then served from the local
+// path /defined/root/dir/*filepath.
+// For example if root is "/etc" and *filepath is "passwd", the local file
+// "/etc/passwd" would be served.
+// Internally a http.FileServer is used, therefore http.NotFound is used instead
+// of the Router's NotFound handler.
+// To use the operating system's file system implementation,
-type AppInfo struct {
+// use http.Dir:
+//     router.ServeFiles("/src/*filepath", http.Dir("/var/www"))
+// func (r *Router) ServeFiles(path string, root http.FileSystem) {
+// 	if len(path) < 10 || path[len(path)-10:] != "/*filepath" {
+// 		panic("path must end with /*filepath in path '" + path + "'")
-	Title       string
+// 	}
-	Description string
+// 	fileServer := http.FileServer(root)
-	Author      string
-	Keywords    string
-}
+// 	r.GET(path, func(w http.ResponseWriter, req *http.Request, ps Params) {
-func Run(info AppInfo, routes map[string]RenderFunc) {
+// 		req.URL.Path = ps.ByName("filepath")
+// 		fileServer.ServeHTTP(w, req)
+// 	})
+// }
+func Run() {
 	isLambda := os.Getenv("_LAMBDA_SERVER_PORT") != ""
-	wd, err := os.Getwd()
-	if err != nil {
-		fmt.Printf("could not get wd")
-		return
-	}
 	if !isLambda {
+		wd, err := os.Getwd()
+		if err != nil {
+			fmt.Printf("could not get wd")
+			return
+		}
-		http.Handle("/assets/", http.StripPrefix("/assets", http.FileServer(pkger.Dir(filepath.Join(wd, "assets")))))
+		assetsFS := http.FileServer(pkger.Dir(filepath.Join(wd, "assets")))
+		router.GET("/assets/*filepath", func(w http.ResponseWriter, r *http.Request) {
+			r.URL.Path = strings.Replace(r.URL.Path, "/assets", "", 1)
+			assetsFS.ServeHTTP(w, r)
+		})
 	}
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		println("route: " + r.URL.Path)
-		renderFunc := MatchRoute(routes, r.URL.Path)
-		page := createPage(info, renderFunc(NewRenderContext()))
-		w.Header().Set("Content-Length", strconv.Itoa(page.Len()))
-		w.Header().Set("Content-Type", "text/html")
-		w.WriteHeader(http.StatusOK)
-		w.Write(page.Bytes())
-	})
 	if isLambda {
 		println("running in lambda mode")
-		algnhsa.ListenAndServe(http.DefaultServeMux, &algnhsa.Options{
+		algnhsa.ListenAndServe(router, &algnhsa.Options{
 			BinaryContentTypes: []string{"application/wasm", "image/png"},
 		})
 	} else {
 		println("Serving on HTTP port: 1234")
-		http.ListenAndServe(":1234", nil)
+		http.ListenAndServe(":1234", router)
 	}
 }
@@ -55,7 +66,12 @@ func Reload() {
 	panic("wasm required")
 }
+func Route(path string, render RenderFunc, info RouteInfo) {
+	println("registering route: " + path)
+	router.GET(path, render)
+}
-func createPage(info AppInfo, ui UI) *bytes.Buffer {
+func createPage(info RouteInfo, ui UI) *bytes.Buffer {
 	isLambda := os.Getenv("_LAMBDA_SERVER_PORT") != ""
 	page := bytes.NewBuffer(nil)
 	page.WriteString("<!DOCTYPE html>\n")

app_wasm.go CHANGED Viewed

@@ -2,6 +2,8 @@
 package app
 import (
+	"bytes"
 	"github.com/pyros2097/wapp/js"
 )
@@ -9,10 +11,20 @@ var (
 	body       *elem
 	content    UI
 	rootPrefix string
+	renderFunc RenderFunc
 )
-func Run(routes map[string]RenderFunc) {
+func Run() {
-	renderFunc := MatchRoute(routes, js.Window.URL().Path)
+	handle, _, _ := router.Lookup("GET", js.Window.URL().Path)
+	if handle == nil {
+		if router.NotFound != nil {
+			renderFunc = router.NotFound
+		} else {
+			renderFunc = DefaultNotFound
+		}
+	} else {
+		renderFunc, _ = handle.(RenderFunc)
+	}
 	defer func() {
 		err := recover()
 		// show alert
@@ -40,6 +52,10 @@ func Reload() {
 	})
 }
+func Route(path string, render RenderFunc, info RouteInfo) {
+	router.GET(path, render)
+}
 func initBody() {
 	body = &elem{
 		jsvalue: js.Window.Get("document").Get("body"),
@@ -71,3 +87,7 @@ func initContent() {
 // func isFragmentNavigation(u *url.URL) bool {
 // 	return u.Fragment != ""
 // }
+func createPage(info RouteInfo, ui UI) *bytes.Buffer {
+	return &bytes.Buffer{}
+}

attributes_test.go CHANGED Viewed

@@ -28,7 +28,7 @@ func Counter(c *RenderContext) UI {
 	)
 }
-func Route(c *RenderContext) UI {
+func TestRoute(c *RenderContext) UI {
 	return Div(
 		Div(),
 		Counter(c),
@@ -42,7 +42,7 @@ func TestCreatePage(t *testing.T) {
 		Head(
 			Title("Title"),
 		),
-		Body(Route(NewRenderContext())),
+		Body(TestRoute(NewRenderContext())),
 	).Html(page)
 	assert.Equal(t, "<!DOCTYPE html>\n<html>\n    <head>\n        <meta charset=\"UTF-8\">\n        <meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\">\n        <meta http-equiv=\"encoding\" content=\"utf-8\">\n        <title>\n            Title\n        </title>\n    </head>\n    <body>\n        <div>\n            <div></div>\n            <div class=\"flex flex-col justify-center align-items-center\">\n                <div class=\"flex flex-row justify-center align-items-center yellow\">\n                    Counter\n                </div>\n                <div class=\"flex flex-row justify-center align-items-center\">\n                    <div>\n                        -\n                    </div>\n                    <div>\n                        0\n                    </div>\n                    <div>\n                        +\n                    </div>\n                </div>\n            </div>\n        </div>\n    </body>\n</html>", page.String())
 }

example/main.go CHANGED Viewed

@@ -4,18 +4,16 @@ import (
 	. "github.com/pyros2097/wapp"
 )
-var routes = map[string]RenderFunc{
-	"/about":     About,
-	"/clock":     Clock,
-	"/container": Container,
-	"/":          Index,
-}
 func main() {
-	Run(AppInfo{
+	info := RouteInfo{
 		Title:       "wapp-example",
 		Description: "wapp is a framework",
 		Author:      "pyros2097",
 		Keywords:    "wapp,wapp-example,golang,framework,frontend,ui,wasm,isomorphic",
+	}
+	Route("/about", About, info)
+	Route("/clock", Clock, info)
+	Route("/container", Container, info)
+	Route("/", Index, info)
-	}, routes)
+	Run()
 }

go.mod CHANGED Viewed

@@ -6,6 +6,7 @@ require (
 	github.com/akrylysov/algnhsa v0.12.1
 	github.com/aws/aws-lambda-go v1.20.0
 	github.com/awslabs/goformation/v4 v4.15.6
+	github.com/julienschmidt/httprouter v1.3.0
 	github.com/kevinpollet/nego v0.0.0-20200702060216-3ff8e9f14a70
 	github.com/markbates/pkger v0.17.1
 	github.com/shurcooL/httpgzip v0.0.0-20190720172056-320755c1c1b0

go.sum CHANGED Viewed

@@ -30,6 +30,8 @@ github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
 github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
+github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/kevinpollet/nego v0.0.0-20200702060216-3ff8e9f14a70 h1:vl63cy3DUIN3iZI5oU/2yfVXEFVPc5ahbwjWk0aF3nA=
 github.com/kevinpollet/nego v0.0.0-20200702060216-3ff8e9f14a70/go.mod h1:bST7PtmFt4otZfrYPAUmYA1v3hZBhX4ttQzBSxeRE4E=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=

tree.go ADDED Viewed

@@ -0,0 +1,1281 @@
+package app
+import (
+	"context"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+	"unicode/utf8"
+)
+// CleanPath is the URL version of path.Clean, it returns a canonical URL path
+// for p, eliminating . and .. elements.
+//
+// The following rules are applied iteratively until no further processing can
+// be done:
+//	1. Replace multiple slashes with a single slash.
+//	2. Eliminate each . path name element (the current directory).
+//	3. Eliminate each inner .. path name element (the parent directory)
+//	   along with the non-.. element that precedes it.
+//	4. Eliminate .. elements that begin a rooted path:
+//	   that is, replace "/.." by "/" at the beginning of a path.
+//
+// If the result of this process is an empty string, "/" is returned
+func CleanPath(p string) string {
+	const stackBufSize = 128
+	// Turn empty string into "/"
+	if p == "" {
+		return "/"
+	}
+	// Reasonably sized buffer on stack to avoid allocations in the common case.
+	// If a larger buffer is required, it gets allocated dynamically.
+	buf := make([]byte, 0, stackBufSize)
+	n := len(p)
+	// Invariants:
+	//      reading from path; r is index of next byte to process.
+	//      writing to buf; w is index of next byte to write.
+	// path must start with '/'
+	r := 1
+	w := 1
+	if p[0] != '/' {
+		r = 0
+		if n+1 > stackBufSize {
+			buf = make([]byte, n+1)
+		} else {
+			buf = buf[:n+1]
+		}
+		buf[0] = '/'
+	}
+	trailing := n > 1 && p[n-1] == '/'
+	// A bit more clunky without a 'lazybuf' like the path package, but the loop
+	// gets completely inlined (bufApp calls).
+	// So in contrast to the path package this loop has no expensive function
+	// calls (except make, if needed).
+	for r < n {
+		switch {
+		case p[r] == '/':
+			// empty path element, trailing slash is added after the end
+			r++
+		case p[r] == '.' && r+1 == n:
+			trailing = true
+			r++
+		case p[r] == '.' && p[r+1] == '/':
+			// . element
+			r += 2
+		case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+			// .. element: remove to last /
+			r += 3
+			if w > 1 {
+				// can backtrack
+				w--
+				if len(buf) == 0 {
+					for w > 1 && p[w] != '/' {
+						w--
+					}
+				} else {
+					for w > 1 && buf[w] != '/' {
+						w--
+					}
+				}
+			}
+		default:
+			// Real path element.
+			// Add slash if needed
+			if w > 1 {
+				bufApp(&buf, p, w, '/')
+				w++
+			}
+			// Copy element
+			for r < n && p[r] != '/' {
+				bufApp(&buf, p, w, p[r])
+				w++
+				r++
+			}
+		}
+	}
+	// Re-append trailing slash
+	if trailing && w > 1 {
+		bufApp(&buf, p, w, '/')
+		w++
+	}
+	// If the original string was not modified (or only shortened at the end),
+	// return the respective substring of the original string.
+	// Otherwise return a new string from the buffer.
+	if len(buf) == 0 {
+		return p[:w]
+	}
+	return string(buf[:w])
+}
+// Internal helper to lazily create a buffer if necessary.
+// Calls to this function get inlined.
+func bufApp(buf *[]byte, s string, w int, c byte) {
+	b := *buf
+	if len(b) == 0 {
+		// No modification of the original string so far.
+		// If the next character is the same as in the original string, we do
+		// not yet have to allocate a buffer.
+		if s[w] == c {
+			return
+		}
+		// Otherwise use either the stack buffer, if it is large enough, or
+		// allocate a new buffer on the heap, and copy all previous characters.
+		if l := len(s); l > cap(b) {
+			*buf = make([]byte, len(s))
+		} else {
+			*buf = (*buf)[:l]
+		}
+		b = *buf
+		copy(b, s[:w])
+	}
+	b[w] = c
+}
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+func longestCommonPrefix(a, b string) int {
+	i := 0
+	max := min(len(a), len(b))
+	for i < max && a[i] == b[i] {
+		i++
+	}
+	return i
+}
+// Search for a wildcard segment and check the name for invalid characters.
+// Returns -1 as index, if no wildcard was found.
+func findWildcard(path string) (wilcard string, i int, valid bool) {
+	// Find start
+	for start, c := range []byte(path) {
+		// A wildcard starts with ':' (param) or '*' (catch-all)
+		if c != ':' && c != '*' {
+			continue
+		}
+		// Find end and check for invalid characters
+		valid = true
+		for end, c := range []byte(path[start+1:]) {
+			switch c {
+			case '/':
+				return path[start : start+1+end], start, valid
+			case ':', '*':
+				valid = false
+			}
+		}
+		return path[start:], start, valid
+	}
+	return "", -1, false
+}
+func countParams(path string) uint16 {
+	var n uint
+	for i := range []byte(path) {
+		switch path[i] {
+		case ':', '*':
+			n++
+		}
+	}
+	return uint16(n)
+}
+type nodeType uint8
+const (
+	static nodeType = iota // default
+	root
+	param
+	catchAll
+)
+type node struct {
+	path      string
+	indices   string
+	wildChild bool
+	nType     nodeType
+	priority  uint32
+	children  []*node
+	handle    interface{}
+}
+// Increments priority of the given child and reorders if necessary
+func (n *node) incrementChildPrio(pos int) int {
+	cs := n.children
+	cs[pos].priority++
+	prio := cs[pos].priority
+	// Adjust position (move to front)
+	newPos := pos
+	for ; newPos > 0 && cs[newPos-1].priority < prio; newPos-- {
+		// Swap node positions
+		cs[newPos-1], cs[newPos] = cs[newPos], cs[newPos-1]
+	}
+	// Build new index char string
+	if newPos != pos {
+		n.indices = n.indices[:newPos] + // Unchanged prefix, might be empty
+			n.indices[pos:pos+1] + // The index char we move
+			n.indices[newPos:pos] + n.indices[pos+1:] // Rest without char at 'pos'
+	}
+	return newPos
+}
+// addRoute adds a node with the given handle to the path.
+// Not concurrency-safe!
+func (n *node) addRoute(path string, handle interface{}) {
+	fullPath := path
+	n.priority++
+	// Empty tree
+	if n.path == "" && n.indices == "" {
+		n.insertChild(path, fullPath, handle)
+		n.nType = root
+		return
+	}
+walk:
+	for {
+		// Find the longest common prefix.
+		// This also implies that the common prefix contains no ':' or '*'
+		// since the existing key can't contain those chars.
+		i := longestCommonPrefix(path, n.path)
+		// Split edge
+		if i < len(n.path) {
+			child := node{
+				path:      n.path[i:],
+				wildChild: n.wildChild,
+				nType:     static,
+				indices:   n.indices,
+				children:  n.children,
+				handle:    n.handle,
+				priority:  n.priority - 1,
+			}
+			n.children = []*node{&child}
+			// []byte for proper unicode char conversion, see #65
+			n.indices = string([]byte{n.path[i]})
+			n.path = path[:i]
+			n.handle = nil
+			n.wildChild = false
+		}
+		// Make new node a child of this node
+		if i < len(path) {
+			path = path[i:]
+			if n.wildChild {
+				n = n.children[0]
+				n.priority++
+				// Check if the wildcard matches
+				if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
+					// Adding a child to a catchAll is not possible
+					n.nType != catchAll &&
+					// Check for longer wildcard, e.g. :name and :names
+					(len(n.path) >= len(path) || path[len(n.path)] == '/') {
+					continue walk
+				} else {
+					// Wildcard conflict
+					pathSeg := path
+					if n.nType != catchAll {
+						pathSeg = strings.SplitN(pathSeg, "/", 2)[0]
+					}
+					prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
+					panic("'" + pathSeg +
+						"' in new path '" + fullPath +
+						"' conflicts with existing wildcard '" + n.path +
+						"' in existing prefix '" + prefix +
+						"'")
+				}
+			}
+			idxc := path[0]
+			// '/' after param
+			if n.nType == param && idxc == '/' && len(n.children) == 1 {
+				n = n.children[0]
+				n.priority++
+				continue walk
+			}
+			// Check if a child with the next path byte exists
+			for i, c := range []byte(n.indices) {
+				if c == idxc {
+					i = n.incrementChildPrio(i)
+					n = n.children[i]
+					continue walk
+				}
+			}
+			// Otherwise insert it
+			if idxc != ':' && idxc != '*' {
+				// []byte for proper unicode char conversion, see #65
+				n.indices += string([]byte{idxc})
+				child := &node{}
+				n.children = append(n.children, child)
+				n.incrementChildPrio(len(n.indices) - 1)
+				n = child
+			}
+			n.insertChild(path, fullPath, handle)
+			return
+		}
+		// Otherwise add handle to current node
+		if n.handle != nil {
+			panic("a handle is already registered for path '" + fullPath + "'")
+		}
+		n.handle = handle
+		return
+	}
+}
+func (n *node) insertChild(path, fullPath string, handle interface{}) {
+	for {
+		// Find prefix until first wildcard
+		wildcard, i, valid := findWildcard(path)
+		if i < 0 { // No wilcard found
+			break
+		}
+		// The wildcard name must not contain ':' and '*'
+		if !valid {
+			panic("only one wildcard per path segment is allowed, has: '" +
+				wildcard + "' in path '" + fullPath + "'")
+		}
+		// Check if the wildcard has a name
+		if len(wildcard) < 2 {
+			panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
+		}
+		// Check if this node has existing children which would be
+		// unreachable if we insert the wildcard here
+		if len(n.children) > 0 {
+			panic("wildcard segment '" + wildcard +
+				"' conflicts with existing children in path '" + fullPath + "'")
+		}
+		// param
+		if wildcard[0] == ':' {
+			if i > 0 {
+				// Insert prefix before the current wildcard
+				n.path = path[:i]
+				path = path[i:]
+			}
+			n.wildChild = true
+			child := &node{
+				nType: param,
+				path:  wildcard,
+			}
+			n.children = []*node{child}
+			n = child
+			n.priority++
+			// If the path doesn't end with the wildcard, then there
+			// will be another non-wildcard subpath starting with '/'
+			if len(wildcard) < len(path) {
+				path = path[len(wildcard):]
+				child := &node{
+					priority: 1,
+				}
+				n.children = []*node{child}
+				n = child
+				continue
+			}
+			// Otherwise we're done. Insert the handle in the new leaf
+			n.handle = handle
+			return
+		}
+		// catchAll
+		if i+len(wildcard) != len(path) {
+			panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
+		}
+		if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
+			panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
+		}
+		// Currently fixed width 1 for '/'
+		i--
+		if path[i] != '/' {
+			panic("no / before catch-all in path '" + fullPath + "'")
+		}
+		n.path = path[:i]
+		// First node: catchAll node with empty path
+		child := &node{
+			wildChild: true,
+			nType:     catchAll,
+		}
+		n.children = []*node{child}
+		n.indices = string('/')
+		n = child
+		n.priority++
+		// Second node: node holding the variable
+		child = &node{
+			path:     path[i:],
+			nType:    catchAll,
+			handle:   handle,
+			priority: 1,
+		}
+		n.children = []*node{child}
+		return
+	}
+	// If no wildcard was found, simply insert the path and handle
+	n.path = path
+	n.handle = handle
+}
+// Returns the handle registered with the given path (key). The values of
+// wildcards are saved to a map.
+// If no handle can be found, a TSR (trailing slash redirect) recommendation is
+// made if a handle exists with an extra (without the) trailing slash for the
+// given path.
+func (n *node) getValue(path string, params func() *Params) (handle interface{}, ps *Params, tsr bool) {
+walk: // Outer loop for walking the tree
+	for {
+		prefix := n.path
+		if len(path) > len(prefix) {
+			if path[:len(prefix)] == prefix {
+				path = path[len(prefix):]
+				// If this node does not have a wildcard (param or catchAll)
+				// child, we can just look up the next child node and continue
+				// to walk down the tree
+				if !n.wildChild {
+					idxc := path[0]
+					for i, c := range []byte(n.indices) {
+						if c == idxc {
+							n = n.children[i]
+							continue walk
+						}
+					}
+					// Nothing found.
+					// We can recommend to redirect to the same URL without a
+					// trailing slash if a leaf exists for that path.
+					tsr = (path == "/" && n.handle != nil)
+					return
+				}
+				// Handle wildcard child
+				n = n.children[0]
+				switch n.nType {
+				case param:
+					// Find param end (either '/' or path end)
+					end := 0
+					for end < len(path) && path[end] != '/' {
+						end++
+					}
+					// Save param value
+					if params != nil {
+						if ps == nil {
+							ps = params()
+						}
+						// Expand slice within preallocated capacity
+						i := len(*ps)
+						*ps = (*ps)[:i+1]
+						(*ps)[i] = Param{
+							Key:   n.path[1:],
+							Value: path[:end],
+						}
+					}
+					// We need to go deeper!
+					if end < len(path) {
+						if len(n.children) > 0 {
+							path = path[end:]
+							n = n.children[0]
+							continue walk
+						}
+						// ... but we can't
+						tsr = (len(path) == end+1)
+						return
+					}
+					if handle = n.handle; handle != nil {
+						return
+					} else if len(n.children) == 1 {
+						// No handle found. Check if a handle for this path + a
+						// trailing slash exists for TSR recommendation
+						n = n.children[0]
+						tsr = (n.path == "/" && n.handle != nil) || (n.path == "" && n.indices == "/")
+					}
+					return
+				case catchAll:
+					// Save param value
+					if params != nil {
+						if ps == nil {
+							ps = params()
+						}
+						// Expand slice within preallocated capacity
+						i := len(*ps)
+						*ps = (*ps)[:i+1]
+						(*ps)[i] = Param{
+							Key:   n.path[2:],
+							Value: path,
+						}
+					}
+					handle = n.handle
+					return
+				default:
+					panic("invalid node type")
+				}
+			}
+		} else if path == prefix {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if handle = n.handle; handle != nil {
+				return
+			}
+			// If there is no handle for this route, but this route has a
+			// wildcard child, there must be a handle for this path with an
+			// additional trailing slash
+			if path == "/" && n.wildChild && n.nType != root {
+				tsr = true
+				return
+			}
+			// No handle found. Check if a handle for this path + a
+			// trailing slash exists for trailing slash recommendation
+			for i, c := range []byte(n.indices) {
+				if c == '/' {
+					n = n.children[i]
+					tsr = (len(n.path) == 1 && n.handle != nil) ||
+						(n.nType == catchAll && n.children[0].handle != nil)
+					return
+				}
+			}
+			return
+		}
+		// Nothing found. We can recommend to redirect to the same URL with an
+		// extra trailing slash if a leaf exists for that path
+		tsr = (path == "/") ||
+			(len(prefix) == len(path)+1 && prefix[len(path)] == '/' &&
+				path == prefix[:len(prefix)-1] && n.handle != nil)
+		return
+	}
+}
+// Makes a case-insensitive lookup of the given path and tries to find a handler.
+// It can optionally also fix trailing slashes.
+// It returns the case-corrected path and a bool indicating whether the lookup
+// was successful.
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (fixedPath string, found bool) {
+	const stackBufSize = 128
+	// Use a static sized buffer on the stack in the common case.
+	// If the path is too long, allocate a buffer on the heap instead.
+	buf := make([]byte, 0, stackBufSize)
+	if l := len(path) + 1; l > stackBufSize {
+		buf = make([]byte, 0, l)
+	}
+	ciPath := n.findCaseInsensitivePathRec(
+		path,
+		buf,       // Preallocate enough memory for new path
+		[4]byte{}, // Empty rune buffer
+		fixTrailingSlash,
+	)
+	return string(ciPath), ciPath != nil
+}
+// Shift bytes in array by n bytes left
+func shiftNRuneBytes(rb [4]byte, n int) [4]byte {
+	switch n {
+	case 0:
+		return rb
+	case 1:
+		return [4]byte{rb[1], rb[2], rb[3], 0}
+	case 2:
+		return [4]byte{rb[2], rb[3]}
+	case 3:
+		return [4]byte{rb[3]}
+	default:
+		return [4]byte{}
+	}
+}
+// Recursive case-insensitive lookup function used by n.findCaseInsensitivePath
+func (n *node) findCaseInsensitivePathRec(path string, ciPath []byte, rb [4]byte, fixTrailingSlash bool) []byte {
+	npLen := len(n.path)
+walk: // Outer loop for walking the tree
+	for len(path) >= npLen && (npLen == 0 || strings.EqualFold(path[1:npLen], n.path[1:])) {
+		// Add common prefix to result
+		oldPath := path
+		path = path[npLen:]
+		ciPath = append(ciPath, n.path...)
+		if len(path) > 0 {
+			// If this node does not have a wildcard (param or catchAll) child,
+			// we can just look up the next child node and continue to walk down
+			// the tree
+			if !n.wildChild {
+				// Skip rune bytes already processed
+				rb = shiftNRuneBytes(rb, npLen)
+				if rb[0] != 0 {
+					// Old rune not finished
+					idxc := rb[0]
+					for i, c := range []byte(n.indices) {
+						if c == idxc {
+							// continue with child node
+							n = n.children[i]
+							npLen = len(n.path)
+							continue walk
+						}
+					}
+				} else {
+					// Process a new rune
+					var rv rune
+					// Find rune start.
+					// Runes are up to 4 byte long,
+					// -4 would definitely be another rune.
+					var off int
+					for max := min(npLen, 3); off < max; off++ {
+						if i := npLen - off; utf8.RuneStart(oldPath[i]) {
+							// read rune from cached path
+							rv, _ = utf8.DecodeRuneInString(oldPath[i:])
+							break
+						}
+					}
+					// Calculate lowercase bytes of current rune
+					lo := unicode.ToLower(rv)
+					utf8.EncodeRune(rb[:], lo)
+					// Skip already processed bytes
+					rb = shiftNRuneBytes(rb, off)
+					idxc := rb[0]
+					for i, c := range []byte(n.indices) {
+						// Lowercase matches
+						if c == idxc {
+							// must use a recursive approach since both the
+							// uppercase byte and the lowercase byte might exist
+							// as an index
+							if out := n.children[i].findCaseInsensitivePathRec(
+								path, ciPath, rb, fixTrailingSlash,
+							); out != nil {
+								return out
+							}
+							break
+						}
+					}
+					// If we found no match, the same for the uppercase rune,
+					// if it differs
+					if up := unicode.ToUpper(rv); up != lo {
+						utf8.EncodeRune(rb[:], up)
+						rb = shiftNRuneBytes(rb, off)
+						idxc := rb[0]
+						for i, c := range []byte(n.indices) {
+							// Uppercase matches
+							if c == idxc {
+								// Continue with child node
+								n = n.children[i]
+								npLen = len(n.path)
+								continue walk
+							}
+						}
+					}
+				}
+				// Nothing found. We can recommend to redirect to the same URL
+				// without a trailing slash if a leaf exists for that path
+				if fixTrailingSlash && path == "/" && n.handle != nil {
+					return ciPath
+				}
+				return nil
+			}
+			n = n.children[0]
+			switch n.nType {
+			case param:
+				// Find param end (either '/' or path end)
+				end := 0
+				for end < len(path) && path[end] != '/' {
+					end++
+				}
+				// Add param value to case insensitive path
+				ciPath = append(ciPath, path[:end]...)
+				// We need to go deeper!
+				if end < len(path) {
+					if len(n.children) > 0 {
+						// Continue with child node
+						n = n.children[0]
+						npLen = len(n.path)
+						path = path[end:]
+						continue
+					}
+					// ... but we can't
+					if fixTrailingSlash && len(path) == end+1 {
+						return ciPath
+					}
+					return nil
+				}
+				if n.handle != nil {
+					return ciPath
+				} else if fixTrailingSlash && len(n.children) == 1 {
+					// No handle found. Check if a handle for this path + a
+					// trailing slash exists
+					n = n.children[0]
+					if n.path == "/" && n.handle != nil {
+						return append(ciPath, '/')
+					}
+				}
+				return nil
+			case catchAll:
+				return append(ciPath, path...)
+			default:
+				panic("invalid node type")
+			}
+		} else {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if n.handle != nil {
+				return ciPath
+			}
+			// No handle found.
+			// Try to fix the path by adding a trailing slash
+			if fixTrailingSlash {
+				for i, c := range []byte(n.indices) {
+					if c == '/' {
+						n = n.children[i]
+						if (len(n.path) == 1 && n.handle != nil) ||
+							(n.nType == catchAll && n.children[0].handle != nil) {
+							return append(ciPath, '/')
+						}
+						return nil
+					}
+				}
+			}
+			return nil
+		}
+	}
+	// Nothing found.
+	// Try to fix the path by adding / removing a trailing slash
+	if fixTrailingSlash {
+		if path == "/" {
+			return ciPath
+		}
+		if len(path)+1 == npLen && n.path[len(path)] == '/' &&
+			strings.EqualFold(path[1:], n.path[1:len(path)]) && n.handle != nil {
+			return append(ciPath, n.path...)
+		}
+	}
+	return nil
+}
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+	Key   string
+	Value string
+}
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) ByName(name string) string {
+	for _, p := range ps {
+		if p.Key == name {
+			return p.Value
+		}
+	}
+	return ""
+}
+type paramsKey struct{}
+// ParamsKey is the request context key under which URL params are stored.
+var ParamsKey = paramsKey{}
+// ParamsFromContext pulls the URL parameters from a request context,
+// or returns nil if none are present.
+func ParamsFromContext(ctx context.Context) Params {
+	p, _ := ctx.Value(ParamsKey).(Params)
+	return p
+}
+// MatchedRoutePathParam is the Param name under which the path of the matched
+// route is stored, if Router.SaveMatchedRoutePath is set.
+var MatchedRoutePathParam = "$matchedRoutePath"
+// MatchedRoutePath retrieves the path of the matched route.
+// Router.SaveMatchedRoutePath must have been enabled when the respective
+// handler was added, otherwise this function always returns an empty string.
+func (ps Params) MatchedRoutePath() string {
+	return ps.ByName(MatchedRoutePathParam)
+}
+// Router is a http.Handler which can be used to dispatch requests to different
+// handler functions via configurable routes
+type Router struct {
+	trees map[string]*node
+	paramsPool sync.Pool
+	maxParams  uint16
+	// If enabled, adds the matched route path onto the http.Request context
+	// before invoking the handler.
+	// The matched route path is only added to handlers of routes that were
+	// registered when this option was enabled.
+	SaveMatchedRoutePath bool
+	// Enables automatic redirection if the current route can't be matched but a
+	// handler for the path with (without) the trailing slash exists.
+	// For example if /foo/ is requested but a route only exists for /foo, the
+	// client is redirected to /foo with http status code 301 for GET requests
+	// and 308 for all other request methods.
+	RedirectTrailingSlash bool
+	// If enabled, the router tries to fix the current request path, if no
+	// handle is registered for it.
+	// First superfluous path elements like ../ or // are removed.
+	// Afterwards the router does a case-insensitive lookup of the cleaned path.
+	// If a handle can be found for this route, the router makes a redirection
+	// to the corrected path with status code 301 for GET requests and 308 for
+	// all other request methods.
+	// For example /FOO and /..//Foo could be redirected to /foo.
+	// RedirectTrailingSlash is independent of this option.
+	RedirectFixedPath bool
+	// If enabled, the router checks if another method is allowed for the
+	// current route, if the current request can not be routed.
+	// If this is the case, the request is answered with 'Method Not Allowed'
+	// and HTTP status code 405.
+	// If no other Method is allowed, the request is delegated to the NotFound
+	// handler.
+	HandleMethodNotAllowed bool
+	// If enabled, the router automatically replies to OPTIONS requests.
+	// Custom OPTIONS handlers take priority over automatic replies.
+	HandleOPTIONS bool
+	// An optional http.Handler that is called on automatic OPTIONS requests.
+	// The handler is only called if HandleOPTIONS is true and no OPTIONS
+	// handler for the specific path was set.
+	// The "Allowed" header is set before calling the handler.
+	GlobalOPTIONS http.Handler
+	// Cached value of global (*) allowed methods
+	globalAllowed string
+	// Configurable http.Handler which is called when no matching route is
+	// found. If it is not set, http.NotFound is used.
+	NotFound RenderFunc
+	// Configurable http.Handler which is called when a request
+	// cannot be routed and HandleMethodNotAllowed is true.
+	// If it is not set, http.Error with http.StatusMethodNotAllowed is used.
+	// The "Allow" header with allowed request methods is set before the handler
+	// is called.
+	MethodNotAllowed http.Handler
+	// Function to handle panics recovered from http handlers.
+	// It should be used to generate a error page and return the http error code
+	// 500 (Internal Server Error).
+	// The handler can be used to keep your server from crashing because of
+	// unrecovered panics.
+	PanicHandler func(http.ResponseWriter, *http.Request, interface{})
+}
+// func(http.ResponseWriter, *http.Request, Params)
+// Make sure the Router conforms with the http.Handler interface
+// var _ http.Handler = New()
+var router = &Router{
+	RedirectTrailingSlash:  true,
+	RedirectFixedPath:      true,
+	HandleMethodNotAllowed: true,
+	HandleOPTIONS:          true,
+}
+func (r *Router) getParams() *Params {
+	ps, _ := r.paramsPool.Get().(*Params)
+	*ps = (*ps)[0:0] // reset slice
+	return ps
+}
+func (r *Router) putParams(ps *Params) {
+	if ps != nil {
+		r.paramsPool.Put(ps)
+	}
+}
+// func (r *Router) saveMatchedRoutePath(path string, handle interface{}) interface{} {
+// 	return func(w http.ResponseWriter, req *http.Request, ps Params) {
+// 		if ps == nil {
+// 			psp := r.getParams()
+// 			ps = (*psp)[0:1]
+// 			ps[0] = Param{Key: MatchedRoutePathParam, Value: path}
+// 			println("route: " + r.URL.Path)
+// 			page := createPage(info, render(NewRenderContext()))
+// 			w.Header().Set("Content-Length", strconv.Itoa(page.Len()))
+// 			w.Header().Set("Content-Type", "text/html")
+// 			w.WriteHeader(http.StatusOK)
+// 			w.Write(page.Bytes())
+// 			handle(w, req, ps)
+// 			r.putParams(psp)
+// 		} else {
+// 			ps = append(ps, Param{Key: MatchedRoutePathParam, Value: path})
+// 			handle(w, req, ps)
+// 		}
+// 	}
+// }
+// GET is a shortcut for router.Handle(http.MethodGet, path, handle)
+func (r *Router) GET(path string, handle interface{}) {
+	r.Handle(http.MethodGet, path, handle)
+}
+// HEAD is a shortcut for router.Handle(http.MethodHead, path, handle)
+func (r *Router) HEAD(path string, handle interface{}) {
+	r.Handle(http.MethodHead, path, handle)
+}
+// OPTIONS is a shortcut for router.Handle(http.MethodOptions, path, handle)
+func (r *Router) OPTIONS(path string, handle interface{}) {
+	r.Handle(http.MethodOptions, path, handle)
+}
+// POST is a shortcut for router.Handle(http.MethodPost, path, handle)
+func (r *Router) POST(path string, handle interface{}) {
+	r.Handle(http.MethodPost, path, handle)
+}
+// PUT is a shortcut for router.Handle(http.MethodPut, path, handle)
+func (r *Router) PUT(path string, handle interface{}) {
+	r.Handle(http.MethodPut, path, handle)
+}
+// PATCH is a shortcut for router.Handle(http.MethodPatch, path, handle)
+func (r *Router) PATCH(path string, handle interface{}) {
+	r.Handle(http.MethodPatch, path, handle)
+}
+// DELETE is a shortcut for router.Handle(http.MethodDelete, path, handle)
+func (r *Router) DELETE(path string, handle interface{}) {
+	r.Handle(http.MethodDelete, path, handle)
+}
+// Handle registers a new request handle with the given path and method.
+//
+// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
+// functions can be used.
+//
+// This function is intended for bulk loading and to allow the usage of less
+// frequently used, non-standardized or custom methods (e.g. for internal
+// communication with a proxy).
+func (r *Router) Handle(method, path string, handle interface{}) {
+	varsCount := uint16(0)
+	if method == "" {
+		panic("method must not be empty")
+	}
+	if len(path) < 1 || path[0] != '/' {
+		panic("path must begin with '/' in path '" + path + "'")
+	}
+	if handle == nil {
+		panic("handle must not be nil")
+	}
+	// if r.SaveMatchedRoutePath {
+	// 	varsCount++
+	// 	handle = r.saveMatchedRoutePath(path, handle)
+	// }
+	if r.trees == nil {
+		r.trees = make(map[string]*node)
+	}
+	root := r.trees[method]
+	if root == nil {
+		root = new(node)
+		r.trees[method] = root
+		r.globalAllowed = r.allowed("*", "")
+	}
+	root.addRoute(path, handle)
+	// Update maxParams
+	if paramsCount := countParams(path); paramsCount+varsCount > r.maxParams {
+		r.maxParams = paramsCount + varsCount
+	}
+	// Lazy-init paramsPool alloc func
+	if r.paramsPool.New == nil && r.maxParams > 0 {
+		r.paramsPool.New = func() interface{} {
+			ps := make(Params, 0, r.maxParams)
+			return &ps
+		}
+	}
+}
+// Handler is an adapter which allows the usage of an http.Handler as a
+// request handle.
+// The Params are available in the request context under ParamsKey.
+// func (r *Router) Handler(method, path string, handler http.Handler) {
+// 	r.Handle(method, path,
+// 		func(w http.ResponseWriter, req *http.Request, p Params) {
+// 			if len(p) > 0 {
+// 				ctx := req.Context()
+// 				ctx = context.WithValue(ctx, ParamsKey, p)
+// 				req = req.WithContext(ctx)
+// 			}
+// 			handler.ServeHTTP(w, req)
+// 		},
+// 	)
+// }
+// HandlerFunc is an adapter which allows the usage of an http.HandlerFunc as a
+// request handle.
+// func (r *Router) HandlerFunc(method, path string, handler http.HandlerFunc) {
+// 	r.Handler(method, path, handler)
+// }
+func (r *Router) recv(w http.ResponseWriter, req *http.Request) {
+	if rcv := recover(); rcv != nil {
+		r.PanicHandler(w, req, rcv)
+	}
+}
+// Lookup allows the manual lookup of a method + path combo.
+// This is e.g. useful to build a framework around this router.
+// If the path was found, it returns the handle function and the path parameter
+// values. Otherwise the third return value indicates whether a redirection to
+// the same path with an extra / without the trailing slash should be performed.
+func (r *Router) Lookup(method, path string) (interface{}, Params, bool) {
+	if root := r.trees[method]; root != nil {
+		handle, ps, tsr := root.getValue(path, r.getParams)
+		if handle == nil {
+			r.putParams(ps)
+			return nil, nil, tsr
+		}
+		if ps == nil {
+			return handle, nil, tsr
+		}
+		return handle, *ps, tsr
+	}
+	return nil, nil, false
+}
+func (r *Router) allowed(path, reqMethod string) (allow string) {
+	allowed := make([]string, 0, 9)
+	if path == "*" { // server-wide
+		// empty method is used for internal calls to refresh the cache
+		if reqMethod == "" {
+			for method := range r.trees {
+				if method == http.MethodOptions {
+					continue
+				}
+				// Add request method to list of allowed methods
+				allowed = append(allowed, method)
+			}
+		} else {
+			return r.globalAllowed
+		}
+	} else { // specific path
+		for method := range r.trees {
+			// Skip the requested method - we already tried this one
+			if method == reqMethod || method == http.MethodOptions {
+				continue
+			}
+			handle, _, _ := r.trees[method].getValue(path, nil)
+			if handle != nil {
+				// Add request method to list of allowed methods
+				allowed = append(allowed, method)
+			}
+		}
+	}
+	if len(allowed) > 0 {
+		// Add request method to list of allowed methods
+		allowed = append(allowed, http.MethodOptions)
+		// Sort allowed methods.
+		// sort.Strings(allowed) unfortunately causes unnecessary allocations
+		// due to allowed being moved to the heap and interface conversion
+		for i, l := 1, len(allowed); i < l; i++ {
+			for j := i; j > 0 && allowed[j] < allowed[j-1]; j-- {
+				allowed[j], allowed[j-1] = allowed[j-1], allowed[j]
+			}
+		}
+		// return as comma separated list
+		return strings.Join(allowed, ", ")
+	}
+	return allow
+}
+// ServeHTTP makes the router implement the http.Handler interface.
+func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	if r.PanicHandler != nil {
+		defer r.recv(w, req)
+	}
+	path := req.URL.Path
+	if root := r.trees[req.Method]; root != nil {
+		// TODO: use _ ps save it to context for useParam()
+		if handle, _, tsr := root.getValue(path, r.getParams); handle != nil {
+			println("route: " + req.URL.Path)
+			if render, ok := handle.(RenderFunc); ok {
+				page := createPage(RouteInfo{}, render(NewRenderContext()))
+				w.Header().Set("Content-Length", strconv.Itoa(page.Len()))
+				w.Header().Set("Content-Type", "text/html")
+				w.WriteHeader(http.StatusOK)
+				w.Write(page.Bytes())
+				return
+			} else {
+				handle.(func(w http.ResponseWriter, r *http.Request))(w, req)
+				return
+			}
+		} else if req.Method != http.MethodConnect && path != "/" {
+			// Moved Permanently, request with GET method
+			code := http.StatusMovedPermanently
+			if req.Method != http.MethodGet {
+				// Permanent Redirect, request with same method
+				code = http.StatusPermanentRedirect
+			}
+			if tsr && r.RedirectTrailingSlash {
+				if len(path) > 1 && path[len(path)-1] == '/' {
+					req.URL.Path = path[:len(path)-1]
+				} else {
+					req.URL.Path = path + "/"
+				}
+				http.Redirect(w, req, req.URL.String(), code)
+				return
+			}
+			// Try to fix the request path
+			if r.RedirectFixedPath {
+				fixedPath, found := root.findCaseInsensitivePath(
+					CleanPath(path),
+					r.RedirectTrailingSlash,
+				)
+				if found {
+					req.URL.Path = fixedPath
+					http.Redirect(w, req, req.URL.String(), code)
+					return
+				}
+			}
+		}
+	}
+	if req.Method == http.MethodOptions && r.HandleOPTIONS {
+		// Handle OPTIONS requests
+		if allow := r.allowed(path, http.MethodOptions); allow != "" {
+			w.Header().Set("Allow", allow)
+			if r.GlobalOPTIONS != nil {
+				r.GlobalOPTIONS.ServeHTTP(w, req)
+			}
+			return
+		}
+	} else if r.HandleMethodNotAllowed { // Handle 405
+		if allow := r.allowed(path, req.Method); allow != "" {
+			w.Header().Set("Allow", allow)
+			if r.MethodNotAllowed != nil {
+				r.MethodNotAllowed.ServeHTTP(w, req)
+			} else {
+				http.Error(w,
+					http.StatusText(http.StatusMethodNotAllowed),
+					http.StatusMethodNotAllowed,
+				)
+			}
+			return
+		}
+	}
+	// Handle 404
+	if r.NotFound != nil {
+		page := createPage(RouteInfo{}, r.NotFound(NewRenderContext()))
+		w.Header().Set("Content-Length", strconv.Itoa(page.Len()))
+		w.Header().Set("Content-Type", "text/html")
+		w.WriteHeader(http.StatusOK)
+		w.Write(page.Bytes())
+	} else {
+		page := createPage(RouteInfo{}, DefaultNotFound(NewRenderContext()))
+		w.Header().Set("Content-Length", strconv.Itoa(page.Len()))
+		w.Header().Set("Content-Type", "text/html")
+		w.WriteHeader(http.StatusOK)
+		w.Write(page.Bytes())
+	}
+}
+func DefaultNotFound(c *RenderContext) UI {
+	return Col(
+		Row(
+			"This is the default 404 - Not Found Route handler",
+		),
+		Row(
+			"Create a notfound.go file and add a  func NotFound(c *RenderContext) UI {} to override it",
+		),
+	)
+}

utils.go CHANGED Viewed

@@ -2,7 +2,6 @@ package app
 import (
 	"io"
-	"regexp"
 	"unsafe"
 	"github.com/pyros2097/wapp/js"
@@ -50,32 +49,9 @@ func stob(s string) []byte {
 	return *(*[]byte)(unsafe.Pointer(&s))
 }
-func matchPath(k, p string) bool {
-	validRoute := regexp.MustCompile(k)
-	if validRoute.MatchString(p) {
+type RouteInfo struct {
-		return true
+	Title       string
-	}
-	return false
-}
-func MatchRoute(routes map[string]RenderFunc, path string) RenderFunc {
-	for key, renderFn := range routes {
-		if matchPath(key, path) {
-			return renderFn
+	Description string
-		}
-	}
-	notFound, ok := routes["/notfound"]
-	if ok {
-		return notFound
+	Author      string
-	}
-	return func(c *RenderContext) UI {
-		return Col(
+	Keywords    string
-			Row(
-				"This is the default 404 - Not Found Route handler",
-			),
-			Row(
-				"Create a notfound.go file and add a  func NotFound(c *RenderContext) UI {} to override it",
-			),
-		)
-	}
 }

~repos /gromer

git clone https://pyrossh.dev/repos/gromer.git

gromer is a framework and cli to build multipage web apps in golang using htmx and alpinejs.