.github/workflows/ci.yml

@@ -13,15 +13,14 @@ jobs:
   test:
     env:
       GOPATH: ${{ github.workspace }}
-      GO111MODULE: off
 
     defaults:
       run:
         working-directory: ${{ env.GOPATH }}/src/github.com/${{ github.repository }}
 
     strategy:
       matrix:
-        go-version: [1.15.x, 1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x, 1.21.x]
+        go-version: [1.15.x, 1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x, 1.21.x, 1.22.x]
         os: [ubuntu-latest, windows-latest]
 
     runs-on: ${{ matrix.os }}

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v5.0.12 (2024-02-16)
+
+- History of changes: see https://github.com/go-chi/chi/compare/v5.0.11...v5.0.12
+
+
 ## v5.0.11 (2023-12-19)
 
 - History of changes: see https://github.com/go-chi/chi/compare/v5.0.10...v5.0.11

README.md

@@ -354,6 +354,7 @@ with `net/http` can be used with chi's mux.
 | [RouteHeaders]         | Route handling for request headers                                      |
 | [SetHeader]            | Short-hand middleware to set a response header key/value                |
 | [StripSlashes]         | Strip slashes on routing paths                                          |
+| [Sunset]               | Sunset set Deprecation/Sunset header to response                        |
 | [Throttle]             | Puts a ceiling on the number of concurrent requests                     |
 | [Timeout]              | Signals to the request context when the timeout deadline is reached     |
 | [URLFormat]            | Parse extension from url and put it on request context                  |
@@ -380,6 +381,7 @@ with `net/http` can be used with chi's mux.
 [RouteHeaders]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RouteHeaders
 [SetHeader]: https://pkg.go.dev/github.com/go-chi/chi/middleware#SetHeader
 [StripSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#StripSlashes
+[Sunset]: https://pkg.go.dev/github.com/go-chi/chi/v5/middleware#Sunset
 [Throttle]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Throttle
 [ThrottleBacklog]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleBacklog
 [ThrottleWithOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleWithOpts

middleware/maybe.go

@@ -4,7 +4,7 @@ import "net/http"
 
 // Maybe middleware will allow you to change the flow of the middleware stack execution depending on return
 // value of maybeFn(request). This is useful for example if you'd like to skip a middleware handler if
-// a request does not satisfied the maybeFn logic.
+// a request does not satisfy the maybeFn logic.
 func Maybe(mw func(http.Handler) http.Handler, maybeFn func(r *http.Request) bool) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

mux.go

@@ -107,12 +107,24 @@ func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {
 // Handle adds the route `pattern` that matches any http method to
 // execute the `handler` http.Handler.
 func (mx *Mux) Handle(pattern string, handler http.Handler) {
+	parts := strings.SplitN(pattern, " ", 2)
+	if len(parts) == 2 {
+		mx.Method(parts[0], parts[1], handler)
+		return
+	}
+
 	mx.handle(mALL, pattern, handler)
 }
 
 // HandleFunc adds the route `pattern` that matches any http method to
 // execute the `handlerFn` http.HandlerFunc.
 func (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) {
+	parts := strings.SplitN(pattern, " ", 2)
+	if len(parts) == 2 {
+		mx.Method(parts[0], parts[1], handlerFn)
+		return
+	}
+
 	mx.handle(mALL, pattern, handlerFn)
 }
 
@@ -440,6 +452,10 @@ func (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	// Find the route
 	if _, _, h := mx.tree.FindRoute(rctx, method, routePath); h != nil {
+		if supportsPathValue {
+			setPathValue(rctx, r)
+		}
+
 		h.ServeHTTP(w, r)
 		return
 	}

mux_test.go

@@ -640,6 +640,89 @@ func TestMuxWith(t *testing.T) {
 	}
 }
 
+func TestMuxHandlePatternValidation(t *testing.T) {
+	testCases := []struct {
+		name           string
+		pattern        string
+		shouldPanic    bool
+		method         string // Method to be used for the test request
+		path           string // Path to be used for the test request
+		expectedBody   string // Expected response body
+		expectedStatus int    // Expected HTTP status code
+	}{
+		// Valid patterns
+		{
+			name:           "Valid pattern without HTTP GET",
+			pattern:        "/user/{id}",
+			shouldPanic:    false,
+			method:         "GET",
+			path:           "/user/123",
+			expectedBody:   "without-prefix GET",
+			expectedStatus: http.StatusOK,
+		},
+		{
+			name:           "Valid pattern with HTTP POST",
+			pattern:        "POST /products/{id}",
+			shouldPanic:    false,
+			method:         "POST",
+			path:           "/products/456",
+			expectedBody:   "with-prefix POST",
+			expectedStatus: http.StatusOK,
+		},
+		// Invalid patterns
+		{
+			name:        "Invalid pattern with no method",
+			pattern:     "INVALID/user/{id}",
+			shouldPanic: true,
+		},
+		{
+			name:        "Invalid pattern with supported method",
+			pattern:     "GET/user/{id}",
+			shouldPanic: true,
+		},
+		{
+			name:        "Invalid pattern with unsupported method",
+			pattern:     "UNSUPPORTED /unsupported-method",
+			shouldPanic: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil && !tc.shouldPanic {
+					t.Errorf("Unexpected panic for pattern %s:\n%v", tc.pattern, r)
+				}
+			}()
+
+			r1 := NewRouter()
+			r1.Handle(tc.pattern, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.Write([]byte(tc.expectedBody))
+			}))
+
+			// Test that HandleFunc also handles method patterns
+			r2 := NewRouter()
+			r2.HandleFunc(tc.pattern, func(w http.ResponseWriter, r *http.Request) {
+				w.Write([]byte(tc.expectedBody))
+			})
+
+			if !tc.shouldPanic {
+				for _, r := range []Router{r1, r2} {
+					// Use testRequest for valid patterns
+					ts := httptest.NewServer(r)
+					defer ts.Close()
+
+					resp, body := testRequest(t, ts, tc.method, tc.path, nil)
+					if body != tc.expectedBody || resp.StatusCode != tc.expectedStatus {
+						t.Errorf("Expected status %d and body %s; got status %d and body %s for pattern %s",
+							tc.expectedStatus, tc.expectedBody, resp.StatusCode, body, tc.pattern)
+					}
+				}
+			}
+		})
+	}
+}
+
 func TestRouterFromMuxWith(t *testing.T) {
 	t.Parallel()
 

path_value.go

@@ -0,0 +1,20 @@
+//go:build go1.22
+// +build go1.22
+
+package chi
+
+import "net/http"
+
+// supportsPathValue is true if the Go version is 1.22 and above.
+//
+// If this is true, `net/http.Request` has methods `SetPathValue` and `PathValue`.
+const supportsPathValue = true
+
+// setPathValue sets the path values in the Request value
+// based on the provided request context.
+func setPathValue(rctx *Context, r *http.Request) {
+	for i, key := range rctx.URLParams.Keys {
+		value := rctx.URLParams.Values[i]
+		r.SetPathValue(key, value)
+	}
+}

path_value_fallback.go

@@ -0,0 +1,19 @@
+//go:build !go1.22
+// +build !go1.22
+
+package chi
+
+import "net/http"
+
+// supportsPathValue is true if the Go version is 1.22 and above.
+//
+// If this is true, `net/http.Request` has methods `SetPathValue` and `PathValue`.
+const supportsPathValue = false
+
+// setPathValue sets the path values in the Request value
+// based on the provided request context.
+//
+// setPathValue is only supported in Go 1.22 and above so
+// this is just a blank function so that it compiles.
+func setPathValue(rctx *Context, r *http.Request) {
+}

path_value_test.go

@@ -0,0 +1,77 @@
+//go:build go1.22
+// +build go1.22
+
+package chi
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestPathValue(t *testing.T) {
+	testCases := []struct {
+		name         string
+		pattern      string
+		method       string
+		pathKeys     []string
+		requestPath  string
+		expectedBody string
+	}{
+		{
+			name:         "Basic path value",
+			pattern:      "/hubs/{hubID}",
+			method:       "GET",
+			pathKeys:     []string{"hubID"},
+			requestPath:  "/hubs/392",
+			expectedBody: "392",
+		},
+		{
+			name:         "Two path values",
+			pattern:      "/users/{userID}/conversations/{conversationID}",
+			method:       "POST",
+			pathKeys:     []string{"userID", "conversationID"},
+			requestPath:  "/users/Gojo/conversations/2948",
+			expectedBody: "Gojo 2948",
+		},
+		{
+			name:         "Wildcard path",
+			pattern:      "/users/{userID}/friends/*",
+			method:       "POST",
+			pathKeys:     []string{"userID", "*"},
+			requestPath:  "/users/Gojo/friends/all-of-them/and/more",
+			expectedBody: "Gojo all-of-them/and/more",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			r := NewRouter()
+
+			r.Handle(tc.method+" "+tc.pattern, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				pathValues := []string{}
+				for _, pathKey := range tc.pathKeys {
+					pathValue := r.PathValue(pathKey)
+					if pathValue == "" {
+						pathValue = "NOT_FOUND:" + pathKey
+					}
+
+					pathValues = append(pathValues, pathValue)
+				}
+
+				body := strings.Join(pathValues, " ")
+
+				w.Write([]byte(body))
+			}))
+
+			ts := httptest.NewServer(r)
+			defer ts.Close()
+
+			_, body := testRequest(t, ts, tc.method, tc.requestPath, nil)
+			if body != tc.expectedBody {
+				t.Fatalf("expecting %q, got %q", tc.expectedBody, body)
+			}
+		})
+	}
+}