From 48158bb7a20b1903317503c651a177035744b25c Mon Sep 17 00:00:00 2001 From: nolwn Date: Sun, 22 Nov 2020 20:55:18 -0800 Subject: [PATCH] Add matching routes with path parameters. --- router.go | 72 ++++++++++++++++++++++++++++++++++---------------- router_test.go | 53 +++++++++++++++++++++++++++++++------ 2 files changed, 94 insertions(+), 31 deletions(-) diff --git a/router.go b/router.go index 03b98fc..9fe3ac8 100644 --- a/router.go +++ b/router.go @@ -30,10 +30,11 @@ type route struct { } type segment struct { - children map[string]*segment - methods map[string]http.HandlerFunc - path string - variable string + children map[string]*segment + methods map[string]http.HandlerFunc + path string + parameter *segment + parameterName string } // NotFoundHandler is the default function for handling routes that are not found. If you wish to @@ -64,8 +65,7 @@ func (r *Router) AddRoute(method string, path string, callback http.HandlerFunc) } if child, ok := curr.children[key]; !ok { - seg := newSegment(curr.path, key) - curr.children[key] = seg + seg := addSegment(curr, key) curr = seg } else { curr = child @@ -114,11 +114,13 @@ func (r *Router) Handler(req *http.Request) (h http.Handler, pattern string) { continue } - if seg, ok := curr.children[v]; ok { - curr = seg - } else { + seg := getChild(v, curr) + + if seg == nil { return } + + curr = seg } if cb, ok := curr.methods[method]; ok { @@ -142,21 +144,45 @@ func (r Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { return } -func addSegment(curr *segment, keys []string) (seg *segment) { - for _, key := range keys { - if child, ok := curr.children[key]; !ok { - seg = newSegment(curr.path, key) - curr.children[key] = seg - curr = seg +func addSegment(curr *segment, key string) (seg *segment) { + if curr.parameterName == key { + seg = curr.parameter + + } else if child, ok := curr.children[key]; !ok { // child does not match... + var isParam bool + + seg, isParam = newSegment(curr.path, key) + + if isParam { + curr.parameter = seg + curr.parameterName = key[2:] + } else { - curr = child + curr.children[key] = seg } + + return + + } else { // child matches... + seg = child } return } -func newSegment(parentPath string, key string) (seg *segment) { +func getChild(key string, curr *segment) (child *segment) { + if seg, ok := curr.children[key]; ok { // is there an exact match? + + child = seg + } else if curr.parameter != nil { // could this be a parameter? + child = curr.parameter + + } + + return +} + +func newSegment(parentPath string, key string) (seg *segment, isParam bool) { var path string if parentPath == "/" { @@ -172,8 +198,8 @@ func newSegment(parentPath string, key string) (seg *segment) { seg.methods = map[string]http.HandlerFunc{} seg.path = path - if isVariable(key) { - seg.variable = key[1:] + if isParameter(key) { + isParam = true } return @@ -190,13 +216,13 @@ func setupKeys(slice []string) (keys []string) { return } -// isVariable returns true if the key is more than one character long and starts with a ':' -func isVariable(key string) (isVar bool) { - if len(key) <= 1 { +// isParameter returns true if the key is more than one character long and starts with a ':' +func isParameter(key string) (isVar bool) { + if len([]rune(key)) <= 2 { return // avoid empty variables, i.e. /somepath/:/someotherpath } - if key[0] != ':' { + if key[1] != ':' { return } diff --git a/router_test.go b/router_test.go index 966a472..85954d0 100644 --- a/router_test.go +++ b/router_test.go @@ -49,8 +49,8 @@ func TestServeHTTP(t *testing.T) { defer testOutcome("can find correct callback function", t) router := Router{} - path := "/items" - expectedBody := "I am /items" + path := "/items/things/stuff" + expectedBody := "I am /items/things/stuff" expectedCode := 200 router.AddRoute(http.MethodGet, path, func(w http.ResponseWriter, r *http.Request) { @@ -66,6 +66,39 @@ func TestServeHTTP(t *testing.T) { return } + path = "/" + expectedBody = "I am /" + + router.AddRoute(http.MethodGet, path, func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(expectedCode) + w.Write([]byte(expectedBody)) + }) + + err = matchAndCheckRoute(&router, http.MethodGet, path, expectedBody, expectedCode) + + if err != nil { + t.Error("Did not find the expected callback handler", err) + + return + } + + path = "/items/:itemid/edit" + expectedBody = "I have a path param" + reqPath := "/items/this-is-an-id/edit" + + router.AddRoute(http.MethodGet, path, func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(expectedCode) + w.Write([]byte(expectedBody)) + }) + + err = matchAndCheckRoute(&router, http.MethodGet, reqPath, expectedBody, expectedCode) + + if err != nil { + t.Error("Did not find the expected callback handler", err) + + return + } + } func matchAndCheckRoute(r *Router, method string, path string, expectedBody string, expectedCode int) (err error) { @@ -156,10 +189,14 @@ func testOutcome(message string, t *testing.T) { } // checkLookup prints out the various saved routes. It's not needed for any test, but is a helpful debugging tool. -// func checkLookup(curr *segment) { -// fmt.Printf("%p { path: %s, methods: %v, children: %v}\n", curr, curr.path, curr.methods, curr.children) +func checkLookup(curr *segment) { + fmt.Printf("%p { path: \"%s\", methods: %v, children: %v, parameter: %v, parameterName: \"%s\"}\n", curr, curr.path, curr.methods, curr.children, curr.parameter, curr.parameterName) -// for _, v := range curr.children { -// checkLookup(v) -// } -// } + for _, v := range curr.children { + checkLookup(v) + } + + if curr.parameter != nil { + checkLookup(curr.parameter) + } +}