muxer: fix route matching and add wildcard support

This patch fixes a critical issue in the route matching logic where nested paths
like /validate/foo/bar/ and other paths with wildcards would incorrectly receive
"Method not allowed" errors, despite having valid handlers registered.

The problem was that our regex pattern handling didn't properly support wildcards
(*) in routes, which is essential for things like auth middleware where we need
to match and validate arbitrary paths. The fix introduces proper wildcard
handling while maintaining backward compatibility with the existing param-based
routes.

Key changes:
- Add support for * wildcard at the end of routes
- Properly handle nested paths in wildcard matches using /(.+)
- Maintain backward compatibility for :param style routes using ([-\w.]+)
- Add comprehensive test coverage for wildcard behavior

Author: shellfu

router.go

@@ -126,17 +126,34 @@ as its parameters.
 	      // handle the request
 	      // ...
 	  })
-
-	If there's an error compiling the regular expression that matches the path, it returns the error.
 */
 func (r *Router) HandleRoute(method, path string, handler http.HandlerFunc) {
-	// Parse path to extract parameter names
 	paramNames := make([]string, 0)
+
+	// First handle catch-all wildcard
+	if strings.Contains(path, "*") {
+		base := strings.TrimSuffix(path, "*")
+		base = strings.TrimSuffix(base, "/")
+		// Match everything after the base path, but don't capture the leading slash
+		pathRegex := regexp.QuoteMeta(base) + `/(.+)`
+		paramNames = append(paramNames, "path")
+
+		r.routes = append(r.routes, Route{
+			method:   method,
+			path:     regexp.MustCompile("^" + pathRegex + "$"),
+			handler:  handler,
+			params:   paramNames,
+			template: path,
+		})
+		return
+	}
+
+	// Handle standard path parameters with the original pattern
 	re := regexp.MustCompile(`:([\w-]+)`)
 	pathRegex := re.ReplaceAllStringFunc(path, func(m string) string {
 		paramName := m[1:]
 		paramNames = append(paramNames, paramName)
-		return `([-\w.]+)`
+		return `([-\w.]+)` // Maintain original pattern
 	})
 
 	exactPath := regexp.MustCompile("^" + pathRegex + "$")

router_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
@@ -179,7 +178,7 @@ func TestSubrouter(t *testing.T) {
 	// Create subrouter for www.example.com
 	example := router.Subrouter("www.example.com")
 	example.HandlerFunc(http.MethodGet, "/example", func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, "Example")
+		fmt.Fprint(w, "Example") // nolint: errcheck
 	})
 
 	// Create subrouter for /api
@@ -388,7 +387,7 @@ func TestMaxRequestBodySize(t *testing.T) {
 	router := NewRouter(WithMaxRequestBodySize(maxRequestBodySize))
 
 	handlerFunc := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		body, err := ioutil.ReadAll(r.Body)
+		body, err := io.ReadAll(r.Body)
 		if err != nil {
 			w.WriteHeader(http.StatusRequestEntityTooLarge)
 			return
@@ -619,3 +618,117 @@ func TestCurrentRoute(t *testing.T) {
 		})
 	}
 }
+
+func TestNestedParams(t *testing.T) {
+	router := NewRouter()
+
+	// Track captured params
+	var capturedParams map[string]string
+
+	router.HandleRoute("GET", "/foo/:id/bar/:desc", func(w http.ResponseWriter, r *http.Request) {
+		capturedParams = router.Params(r)
+	})
+
+	req := httptest.NewRequest("GET", "/foo/123/bar/test-1", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	expected := map[string]string{
+		"id":   "123",
+		"desc": "test-1",
+	}
+
+	if !reflect.DeepEqual(capturedParams, expected) {
+		t.Errorf("expected params %v, got %v", expected, capturedParams)
+	}
+}
+
+func TestWildcardRoutes(t *testing.T) {
+	tests := []struct {
+		name          string
+		method        string
+		routePath     string
+		requestPath   string
+		expectedCode  int
+		expectedParam string
+		wantMatch     bool
+	}{
+		{
+			name:          "simple wildcard",
+			method:        http.MethodGet,
+			routePath:     "/validate/*",
+			requestPath:   "/validate/foo",
+			expectedCode:  http.StatusOK,
+			expectedParam: "foo",
+			wantMatch:     true,
+		},
+		{
+			name:          "nested wildcard",
+			method:        http.MethodGet,
+			routePath:     "/validate/*",
+			requestPath:   "/validate/foo/bar",
+			expectedCode:  http.StatusOK,
+			expectedParam: "foo/bar",
+			wantMatch:     true,
+		},
+		{
+			name:          "wildcard with query params",
+			method:        http.MethodGet,
+			routePath:     "/validate/*",
+			requestPath:   "/validate/foo?key=value",
+			expectedCode:  http.StatusOK,
+			expectedParam: "foo",
+			wantMatch:     true,
+		},
+		{
+			name:          "no match without prefix",
+			method:        http.MethodGet,
+			routePath:     "/validate/*",
+			requestPath:   "/foo/bar",
+			expectedCode:  http.StatusNotFound,
+			expectedParam: "",
+			wantMatch:     false,
+		},
+		{
+			name:          "method not allowed",
+			method:        http.MethodGet,
+			routePath:     "/validate/*",
+			requestPath:   "/validate/foo",
+			expectedCode:  http.StatusMethodNotAllowed,
+			expectedParam: "",
+			wantMatch:     false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			router := NewRouter()
+
+			router.HandleRoute(tc.method, tc.routePath, func(w http.ResponseWriter, r *http.Request) {
+				if tc.wantMatch {
+					params := router.Params(r)
+					if got := params["path"]; got != tc.expectedParam {
+						t.Errorf("expected param %q, got %q", tc.expectedParam, got)
+					}
+				}
+				w.WriteHeader(http.StatusOK)
+			})
+
+			var method string
+			if tc.name == "method not allowed" {
+				method = http.MethodPost
+			} else {
+				method = tc.method
+			}
+
+			req := httptest.NewRequest(method, tc.requestPath, nil)
+			w := httptest.NewRecorder()
+
+			router.ServeHTTP(w, req)
+
+			if got := w.Code; got != tc.expectedCode {
+				t.Errorf("expected status code %d, got %d", tc.expectedCode, got)
+			}
+		})
+	}
+}