add support for overlapping parameter suffixes

Author: ibraheemdev

src/error.rs

@@ -12,15 +12,18 @@ pub enum InsertError {
         /// The existing route that the insertion is conflicting with.
         with: String,
     },
+
     /// Only one parameter per route segment is allowed.
     ///
     /// For example, `/foo-{bar}` and `/{bar}-foo` are valid routes, but `/{foo}-{bar}`
     /// is not.
     InvalidParamSegment,
+
     /// Parameters must be registered with a valid name and matching braces.
     ///
     /// Note you can use `{{` or `}}` to escape literal brackets.
     InvalidParam,
+
     /// Catch-all parameters are only allowed at the end of a path.
     InvalidCatchAll,
 }
@@ -31,8 +34,7 @@ impl fmt::Display for InsertError {
             Self::Conflict { with } => {
                 write!(
                     f,
-                    "Insertion failed due to conflict with previously registered route: {}",
-                    with
+                    "Insertion failed due to conflict with previously registered route: {with}"
                 )
             }
             Self::InvalidParamSegment => {

src/escape.rs

@@ -173,7 +173,7 @@ impl<'a> std::ops::Deref for UnescapedRef<'a> {
     }
 }
 
-impl<'a> fmt::Debug for UnescapedRef<'a> {
+impl fmt::Debug for UnescapedRef<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("UnescapedRef")
             .field("inner", &std::str::from_utf8(self.inner))

src/params.rs

@@ -4,8 +4,8 @@ use std::{fmt, iter, mem, slice};
 #[derive(PartialEq, Eq, Ord, PartialOrd, Default, Copy, Clone)]
 struct Param<'k, 'v> {
     // Keys and values are stored as byte slices internally by the router
-    // to avoid UTF8 checks when slicing, but UTF8 is still respected,
-    // so these slices are valid strings.
+    // to avoid utf8 checks when slicing. This allows us to perform utf8 
+    // validation lazily without resorting to unsafe code.
     key: &'k [u8],
     value: &'v [u8],
 }
@@ -118,6 +118,7 @@ impl<'k, 'v> Params<'k, 'v> {
     /// Inserts a key value parameter pair into the list.
     pub(crate) fn push(&mut self, key: &'k [u8], value: &'v [u8]) {
         #[cold]
+        #[inline(never)]
         fn drain_to_vec<T: Default>(len: usize, elem: T, arr: &mut [T; SMALL]) -> Vec<T> {
             let mut vec = Vec::with_capacity(len + 1);
             vec.extend(arr.iter_mut().map(mem::take));
@@ -136,6 +137,7 @@ impl<'k, 'v> Params<'k, 'v> {
                 arr[*len] = param;
                 *len += 1;
             }
+
             ParamsKind::Large(vec) => vec.push(param),
         }
     }
@@ -149,6 +151,7 @@ impl<'k, 'v> Params<'k, 'v> {
                 .map(|param| &mut param.key)
                 .enumerate()
                 .for_each(f),
+
             ParamsKind::Large(vec) => vec
                 .iter_mut()
                 .map(|param| &mut param.key)
@@ -184,7 +187,7 @@ enum ParamsIterKind<'ps, 'k, 'v> {
     Large(slice::Iter<'ps, Param<'k, 'v>>),
 }
 
-impl<'ps, 'k, 'v> Iterator for ParamsIter<'ps, 'k, 'v> {
+impl<'k, 'v> Iterator for ParamsIter<'_, 'k, 'v> {
     type Item = (&'k str, &'v str);
 
     fn next(&mut self) -> Option<Self::Item> {

src/router.rs

@@ -116,12 +116,12 @@ impl<T> Router<T> {
     /// assert_eq!(router.remove("/home/{id}/"), None);
     ///
     /// router.insert("/home/{id}/", "Hello!");
-    /// // the route does not match
+    /// // The route does not match.
     /// assert_eq!(router.remove("/home/{user}"), None);
     /// assert_eq!(router.remove("/home/{id}/"), Some("Hello!"));
     ///
     /// router.insert("/home/{id}/", "Hello!");
-    /// // invalid route
+    /// // Invalid route.
     /// assert_eq!(router.remove("/home/{id"), None);
     /// assert_eq!(router.remove("/home/{id}/"), Some("Hello!"));
     /// ```