feat: add star routes (#28)

Author: mojixcoder

mux.go

@@ -12,6 +12,14 @@ var (
 	errMethodNotAllowed = errors.New("method is not allowed")
 )
 
+// Path parameters prefix and suffix.
+const (
+	paramPrefix     = "{"
+	paramSuffix     = "}"
+	plusParamPrefix = paramPrefix + "+"
+	starParamPrefix = paramPrefix + "*"
+)
+
 type (
 	// Router is the struct which holds all of the routes.
 	Router struct {
@@ -30,6 +38,7 @@ type (
 	Segment struct {
 		isParam bool
 		isPlus  bool
+		isStar  bool
 		tpl     string
 	}
 
@@ -59,17 +68,26 @@ func (router *Router) add(path string, handler HandlerFunc, methods []string, mi
 	routeSegments := make([]Segment, 0, len(segments))
 
 	for i, segment := range segments {
-		if strings.HasPrefix(segment, "{+") && strings.HasSuffix(segment, "}") {
+		if (strings.HasPrefix(segment, plusParamPrefix) || strings.HasPrefix(segment, starParamPrefix)) && strings.HasSuffix(segment, paramSuffix) {
+			isPlus := router.isPlus(segment)
+			isStar := !isPlus
+
 			if i == len(segments)-1 {
-				routeSegments = append(routeSegments, Segment{isParam: true, isPlus: true, tpl: segment[2 : len(segment)-1]})
+				routeSegments = append(
+					routeSegments,
+					Segment{isParam: true, isPlus: isPlus, isStar: isStar, tpl: segment[2 : len(segment)-1]},
+				)
 			} else if i == len(segments)-2 {
 				if segments[i+1] != "" {
-					panic("plus path parameters can only be the last part of a path")
+					panic("plus/star path parameters can only be the last part of a path")
 				}
-				routeSegments = append(routeSegments, Segment{isParam: true, isPlus: true, tpl: segment[2 : len(segment)-1]})
+				routeSegments = append(
+					routeSegments,
+					Segment{isParam: true, isPlus: isPlus, isStar: isStar, tpl: segment[2 : len(segment)-1]},
+				)
 				break
 			} else {
-				panic("plus path parameters can only be the last part of a path")
+				panic("plus/star path parameters can only be the last part of a path")
 			}
 		} else if strings.HasPrefix(segment, "{") && strings.HasSuffix(segment, "}") {
 			routeSegments = append(routeSegments, Segment{isParam: true, tpl: segment[1 : len(segment)-1]})
@@ -84,6 +102,7 @@ func (router *Router) add(path string, handler HandlerFunc, methods []string, mi
 // match determines if the given path and method matches the route.
 func (route *Route) match(path, method string) (Params, error) {
 	params := make(Params)
+	totalSegments := len(route.segments)
 	var end bool
 
 	for segmentIndex, segment := range route.segments {
@@ -96,14 +115,21 @@ func (route *Route) match(path, method string) (Params, error) {
 			end = true
 
 			// No slashes are left but there are still more segments.
-			if segmentIndex != len(route.segments)-1 {
-				return nil, errNotFound
+			if segmentIndex != totalSegments-1 {
+				// It means /api/v1 will be matched to /api/v1/{*param}
+				lastSegment := route.segments[totalSegments-1]
+				if segmentIndex == totalSegments-2 && lastSegment.isStar {
+					end = true
+					params[lastSegment.tpl] = ""
+				} else {
+					return nil, errNotFound
+				}
 			}
 		}
 
 		if segment.isParam {
-			if segment.isPlus {
-				if len(path) == 0 {
+			if segment.isPlus || segment.isStar {
+				if len(path) == 0 && segment.isPlus {
 					return nil, errNotFound
 				}
 
@@ -169,6 +195,15 @@ func (router *Router) find(path string, method string) (Route, Params, error) {
 
 }
 
+// isPlus returns true if path parameter is plus path parameter.
+func (router *Router) isPlus(segment string) bool {
+	var isPlus bool
+	if strings.HasPrefix(segment, plusParamPrefix) {
+		isPlus = true
+	}
+	return isPlus
+}
+
 // cleanPath normalizes the path.
 //
 // If soft is false it also removes duplicate slashes.

mux_test.go

@@ -62,11 +62,11 @@ func TestAdd(t *testing.T) {
 		router.add("/", nil, []string{http.MethodGet}, nil)
 	})
 
-	assert.PanicsWithValue(t, "plus path parameters can only be the last part of a path", func() {
+	assert.PanicsWithValue(t, "plus/star path parameters can only be the last part of a path", func() {
 		router.add("/path/{+extraPath}/asd", testHandlerFunc, []string{http.MethodGet}, nil)
 	})
 
-	assert.PanicsWithValue(t, "plus path parameters can only be the last part of a path", func() {
+	assert.PanicsWithValue(t, "plus/star path parameters can only be the last part of a path", func() {
 		router.add("/path/{+extraPath}/test/test2", testHandlerFunc, []string{http.MethodGet}, nil)
 	})
 
@@ -147,11 +147,13 @@ func TestMatch(t *testing.T) {
 
 	router.add("/", testHandlerFunc, []string{http.MethodGet}, nil)
 	router.add("/test/{var}/get", testHandlerFunc, []string{http.MethodGet, http.MethodPost}, nil)
-	router.add("/test/{var}/get/{+extraPath}", testHandlerFunc, []string{http.MethodPut}, nil)
+	router.add("/test/{var}/get/{+plusPath}", testHandlerFunc, []string{http.MethodPut}, nil)
+	router.add("/test/{var}/path/{*starPath}", testHandlerFunc, []string{http.MethodGet}, nil)
 
 	firstRoute := router.routes[0]
 	secondRoute := router.routes[1]
 	plusRoute := router.routes[2]
+	starRoute := router.routes[3]
 
 	// Don't need to add starting slash in route's match method as they are skipped in router's find method.
 	// For matching we should match relative paths, not abosulute paths.
@@ -218,18 +220,47 @@ func TestMatch(t *testing.T) {
 	// Testing plus route.
 	params, err = plusRoute.match("test/123/get/extra/path", http.MethodPut)
 	assert.NoError(t, err)
-	assert.Equal(t, Params{"var": "123", "extraPath": "extra/path"}, params)
+	assert.Equal(t, Params{"var": "123", "plusPath": "extra/path"}, params)
+
+	params, err = plusRoute.match("test/123/get/extra", http.MethodPut)
+	assert.NoError(t, err)
+	assert.Equal(t, Params{"var": "123", "plusPath": "extra"}, params)
 
 	params, err = plusRoute.match("test/123/get/extra/path", http.MethodGet)
 	assert.ErrorIs(t, err, errMethodNotAllowed)
 	assert.Nil(t, params)
 
-	params, err = plusRoute.match("test//get/extra/path", http.MethodGet)
+	params, err = plusRoute.match("test//get/extra/path", http.MethodPut)
 	assert.ErrorIs(t, err, errNotFound)
 	assert.Nil(t, params)
 
 	// At least one extra path is required
-	params, err = plusRoute.match("test/123/get/", http.MethodGet)
+	params, err = plusRoute.match("test/123/get/", http.MethodPut)
+	assert.ErrorIs(t, err, errNotFound)
+	assert.Nil(t, params)
+
+	// Testing star route.
+	params, err = starRoute.match("test/123/path/star/path", http.MethodGet)
+	assert.NoError(t, err)
+	assert.Equal(t, Params{"var": "123", "starPath": "star/path"}, params)
+
+	params, err = starRoute.match("test/123/path/star", http.MethodGet)
+	assert.NoError(t, err)
+	assert.Equal(t, Params{"var": "123", "starPath": "star"}, params)
+
+	params, err = starRoute.match("test/123/path/", http.MethodGet)
+	assert.NoError(t, err)
+	assert.Equal(t, Params{"var": "123", "starPath": ""}, params)
+
+	params, err = starRoute.match("test/123/path", http.MethodGet)
+	assert.NoError(t, err)
+	assert.Equal(t, Params{"var": "123", "starPath": ""}, params)
+
+	params, err = starRoute.match("test/123/path/star/path", http.MethodPost)
+	assert.ErrorIs(t, err, errMethodNotAllowed)
+	assert.Nil(t, params)
+
+	params, err = starRoute.match("test//path/star/path", http.MethodGet)
 	assert.ErrorIs(t, err, errNotFound)
 	assert.Nil(t, params)
 }
@@ -317,3 +348,13 @@ func TestFind(t *testing.T) {
 	assert.True(t, funcsAreEqual(testHandlerFunc, route.handler))
 	assert.True(t, funcsAreEqual(testMiddlewareFunc, route.middlewares[0]))
 }
+
+func TestRouterIsPlus(t *testing.T) {
+	router := newRouter()
+
+	isPlus := router.isPlus("{+param}")
+	assert.True(t, isPlus)
+
+	isPlus = router.isPlus("{*param}")
+	assert.False(t, isPlus)
+}