path.go (1)

501-520: Helper looks correct; simplify and add brief doc

Logic is sound. Tiny simplification and a short doc comment improve readability without changing behavior.

+// hasPartialMatchBoundary reports whether matchedLength either consumes the full path
+// or ends at a '/' boundary (before or after).
 func hasPartialMatchBoundary(path string, matchedLength int) bool {
 	if matchedLength < 0 || matchedLength > len(path) {
 		return false
 	}
-	if matchedLength == len(path) {
-		return true
-	}
-	if matchedLength == 0 {
-		return false
-	}
-	if path[matchedLength-1] == slashDelimiter {
-		return true
-	}
-	if matchedLength < len(path) && path[matchedLength] == slashDelimiter {
-		return true
-	}
-
-	return false
+	if matchedLength == 0 || matchedLength == len(path) {
+		return matchedLength == len(path)
+	}
+	return path[matchedLength-1] == slashDelimiter || path[matchedLength] == slashDelimiter
 }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

docs/guide/routing.md (1)

327-329: Clarify boundary semantics; avoid time-relative wording.

Spell out that the boundary is "/" or end-of-path and include the trailing-slash case; also drop "now" to keep docs timeless.

Apply this edit to the note:

-:::note
-Prefix matches must now end at a slash boundary (or be an exact match). For example, `/api` runs for `/api` and `/api/users` but no longer for `/apiv2`. Parameter tokens such as `:name`, `:name?`, `*`, and `+` are still expanded before this boundary check runs.
-:::
+:::note
+Prefix matches end at a slash boundary ("/") or are an exact match. For example, `/api` matches `/api`, `/api/`, and `/api/users`, but not `/apiv2`. Parameter tokens such as `:name`, `:name?`, `*`, and `+` are expanded before this boundary check runs.
+:::

Please confirm that /api indeed matches /api/ under the new rule; if not, we should adjust the example accordingly and explicitly state the trailing-slash behavior.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: ckoch786
PR: gofiber/fiber#3230
File: docs/whats_new.md:944-951
Timestamp: 2024-12-15T19:56:45.935Z
Learning: Detailed usage examples and explanations for new methods like `RemoveRoute` and `RemoveRouteByName` are documented in `docs/api/app.md`, so it's unnecessary to duplicate them in `docs/whats_new.md`.

router_test.go (2)

312-324: Good negative case; add a positive control for exact boundary.

Keep this test; also assert that exact "/foo" matches to guard against regressions.

 func Test_Route_Match_Middleware_NoBoundary(t *testing.T) {
   t.Parallel()

   app := New()

   app.Use("/foo", func(c Ctx) error {
     return c.SendStatus(StatusOK)
   })

   resp, err := app.Test(httptest.NewRequest(MethodGet, "/foobar", nil))
   require.NoError(t, err, "app.Test(req)")
   require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")
+
+  // positive control: exact boundary must match
+  resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo", nil))
+  require.NoError(t, err)
+  require.Equal(t, StatusOK, resp.StatusCode)
 }

---

708-801: Drop redundant tt := tt in these subtests

Remove both occurrences in router_test.go (lines 690 and 777); the subtests do not call t.Parallel(), so the extra capture is unnecessary and unblocks the linter.

- for _, tt := range testCases {
-   tt := tt
+ for _, tt := range testCases {
    t.Run(tt.name, func(t *testing.T) {
      app := New(Config{StrictRouting: tt.strictRouting})

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

path_test.go (1)

176-224: Add a few more edge cases to harden boundary semantics.

Consider covering start-of-path, trailing-slash exact match, and UTF‑8 adjacent to the boundary.

Suggested additions:

   testCases := []struct {
@@
     {
       name:          "no boundary",
       path:          "/demo/child",
       matchedLength: len("/dem"),
       expected:      false,
     },
+    {
+      name:          "boundary at start (previous is implicit start slash)",
+      path:          "/child",
+      matchedLength: 1, // after leading '/'
+      expected:      true,
+    },
+    {
+      name:          "exact match with trailing slash",
+      path:          "/demo/",
+      matchedLength: len("/demo/"),
+      expected:      true,
+    },
+    {
+      name:          "UTF-8 next rune slash",
+      path:          "/dęmo/child",
+      matchedLength: len("/dęmo"), // next byte is '/'
+      expected:      true,
+    },

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

path_test.go (1)

173-233: Optional: align naming with file convention and clarify subtest titles; add root-path edge case.

• For consistency with nearby tests (e.g., Test_Path_*), consider renaming the function.
• “rune” → “char” in titles is clearer since checks are byte-wise against '/'.
• Add a root “/” exact-match case.

Apply:

-func TestHasPartialMatchBoundary(t *testing.T) {
+func Test_Path_hasPartialMatchBoundary(t *testing.T) {
@@
-        {
-            name:          "previous rune slash",
+        {
+            name:          "previous char is slash",
             path:          "/demo/child",
             matchedLength: len("/demo/"),
             expected:      true,
         },
         {
-            name:          "next rune slash",
+            name:          "next char is slash",
             path:          "/demo/child",
             matchedLength: len("/demo"),
             expected:      true,
         },
@@
         {
             name:          "no boundary",
             path:          "/demo/child",
             matchedLength: len("/dem"),
             expected:      false,
         },
+        {
+            name:          "root exact",
+            path:          "/",
+            matchedLength: len("/"),
+            expected:      true,
+        },

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro