add support for parameter suffixes

Author: ibraheemdev

src/error.rs

@@ -14,8 +14,8 @@ pub enum InsertError {
     },
     /// Only one parameter per route segment is allowed.
     ///
-    /// Static segments are also allowed before a parameter, but not after it. For example,
-    /// `/foo-{bar}` is a valid route, but `/{bar}-foo` is not.
+    /// 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.
     ///

src/tree.rs

@@ -38,6 +38,9 @@ pub(crate) enum NodeType {
     Root,
     /// A route parameter, e.g. `/{id}`.
     Param,
+    /// A route parameter that is followed by a static suffix
+    /// before a trailing slash, ex: `/{id}.png`.
+    ParamSuffix { suffix_start: usize },
     /// A catch-all parameter, e.g. `/*file`.
     CatchAll,
     /// A static prefix, e.g. `/foo`.
@@ -127,7 +130,11 @@ impl<T> Node<T> {
             // After matching against a wildcard the next character is always `/`.
             //
             // Continue searching in the child node if it already exists.
-            if current.node_type == NodeType::Param && current.children.len() == 1 {
+            if matches!(
+                current.node_type,
+                NodeType::Param | NodeType::ParamSuffix { .. }
+            ) && current.children.len() == 1
+            {
                 debug_assert_eq!(next, b'/');
                 current = &mut current.children[0];
                 current.priority += 1;
@@ -173,11 +180,14 @@ impl<T> Node<T> {
                 current = current.children.last_mut().unwrap();
                 current.priority += 1;
 
+                let segment = remaining
+                    .iter()
+                    .position(|b| *b == b'/')
+                    .unwrap_or(remaining.len());
+
                 // Make sure the route parameter matches.
-                if let Some(wildcard) = remaining.get(..current.prefix.len()) {
-                    if *wildcard != *current.prefix {
-                        return Err(InsertError::conflict(&route, remaining, current));
-                    }
+                if remaining[..segment] != *current.prefix {
+                    return Err(InsertError::conflict(&route, remaining, current));
                 }
 
                 // Catch-all routes cannot have children.
@@ -402,10 +412,39 @@ impl<T> Node<T> {
                 prefix = prefix.slice_off(wildcard.start);
             }
 
+            let (node_type, wildcard) = match prefix.get(wildcard.len()) {
+                // The entire route segment consists of the wildcard.
+                None | Some(&b'/') => {
+                    let wildcard_prefix = prefix.slice_until(wildcard.len());
+                    prefix = prefix.slice_off(wildcard_prefix.len());
+                    (NodeType::Param, wildcard_prefix)
+                }
+                // The route parameter is followed a static suffix within the current segment.
+                _ => {
+                    let end = prefix
+                        .iter()
+                        .position(|&b| b == b'/')
+                        .unwrap_or(prefix.len());
+
+                    let wildcard_prefix = prefix.slice_until(end);
+                    let suffix = wildcard_prefix.slice_off(wildcard.len());
+
+                    // Multiple parameters within the same segment, e.g. `/{foo}{bar}`.
+                    if matches!(find_wildcard(suffix), Ok(Some(_))) {
+                        return Err(InsertError::InvalidParamSegment);
+                    }
+
+                    prefix = prefix.slice_off(end);
+
+                    let suffix_start = wildcard.len();
+                    (NodeType::ParamSuffix { suffix_start }, wildcard_prefix)
+                }
+            };
+
             // Add the parameter as a child node.
             let child = Self {
-                node_type: NodeType::Param,
-                prefix: prefix.slice_until(wildcard.len()).to_owned(),
+                node_type,
+                prefix: wildcard.to_owned(),
                 ..Self::default()
             };
 
@@ -415,8 +454,7 @@ impl<T> Node<T> {
             current.priority += 1;
 
             // If the route doesn't end in the wildcard, we have to insert the suffix as a child.
-            if wildcard.len() < prefix.len() {
-                prefix = prefix.slice_off(wildcard.len());
+            if !prefix.is_empty() {
                 let child = Self {
                     priority: 1,
                     ..Self::default()
@@ -616,6 +654,76 @@ impl<T> Node<T> {
                     // Otherwise, there are no matching routes in the tree.
                     return Err(MatchError::NotFound);
                 }
+                NodeType::ParamSuffix { suffix_start } => {
+                    let suffix = &current.prefix[suffix_start..];
+
+                    // Double `//` implying an empty parameter, no match.
+                    if path[0] == b'/' {
+                        try_backtrack!();
+                        return Err(MatchError::NotFound);
+                    }
+
+                    // The path cannot contain the suffix.
+                    if path.len() <= suffix.len() {
+                        try_backtrack!();
+                        return Err(MatchError::NotFound);
+                    }
+
+                    // Skip the first path byte to ensure a non-empty parameter.
+                    for i in 1..=(path.len() - suffix.len()) {
+                        // Reached a `/` before the suffix, no match.
+                        if path[i] == b'/' {
+                            try_backtrack!();
+                            return Err(MatchError::NotFound);
+                        }
+
+                        // Ensure the suffix matches.
+                        if path[i..][..suffix.len()] != *suffix {
+                            continue;
+                        }
+
+                        let param = &path[..i];
+                        let rest = &path[i + suffix.len()..];
+
+                        if rest.is_empty() {
+                            let value = match current.value {
+                                // Found the matching value.
+                                Some(ref value) => value,
+                                // Otherwise, this route does not match.
+                                None => {
+                                    try_backtrack!();
+                                    return Err(MatchError::NotFound);
+                                }
+                            };
+
+                            // Store the parameter value.
+                            // Parameters are normalized so the key is irrelevant for now.
+                            params.push(b"", param);
+
+                            // Remap the keys of any route parameters we accumulated during the search.
+                            params.for_each_key_mut(|(i, key)| *key = &current.remapping[i]);
+
+                            return Ok((value, params));
+                        }
+
+                        // If there is a static child, continue the search.
+                        if let [child] = current.children.as_slice() {
+                            // Store the parameter value.
+                            // Parameters are normalized so the key is irrelevant for now.
+                            params.push(b"", param);
+
+                            // Continue searching.
+                            path = rest;
+                            current = child;
+                            backtracking = false;
+                            continue 'walk;
+                        }
+
+                        // Otherwise, this route does not match.
+                        try_backtrack!();
+                        return Err(MatchError::NotFound);
+                    }
+                }
                 NodeType::CatchAll => {
                     // Catch-all segments are only allowed at the end of the route, meaning
                     // this node must contain the value.
@@ -785,13 +893,6 @@ fn find_wildcard(path: UnescapedRef<'_>) -> Result<Option<Range<usize>>, InsertE
                         return Err(InsertError::InvalidParam);
                     }
 
-                    if let Some(&c) = path.get(i + 1) {
-                        // Prefixes after route parameters are not supported.
-                        if c != b'/' {
-                            return Err(InsertError::InvalidParamSegment);
-                        }
-                    }
-
                     return Ok(Some(start..i + 1));
                 }
                 // `*` and `/` are invalid in parameter names.

tests/insert.rs

@@ -48,6 +48,19 @@ fn wildcard_conflict() {
         ("/user_{bar}", Err(conflict("/user_{name}"))),
         ("/id{id}", Ok(())),
         ("/id/{id}", Ok(())),
+        ("/x/{id}", Ok(())),
+        ("/x/{id}/", Ok(())),
+        ("/x/{id}y", Err(conflict("/x/{id}/"))),
+        ("/x/{id}y/", Err(conflict("/x/{id}/"))),
+        ("/x/x{id}", Ok(())),
+        ("/x/x{id}y", Err(conflict("/x/x{id}"))),
+        ("/qux/id", Ok(())),
+        ("/qux/{id}y", Ok(())),
+        ("/qux/{id}", Err(conflict("/qux/{id}y"))),
+        ("/qux/{id}/", Err(conflict("/qux/{id}y"))),
+        ("/qux/{id}x", Err(conflict("/qux/{id}y"))),
+        ("/qux/x{id}y", Ok(())),
+        ("/qux/x{id}", Err(conflict("/qux/x{id}y"))),
     ])
     .run()
 }
@@ -210,7 +223,6 @@ fn invalid_param() {
         ("}", Err(InsertError::InvalidParam)),
         ("x{y", Err(InsertError::InvalidParam)),
         ("x}", Err(InsertError::InvalidParam)),
-        ("/{foo}s", Err(InsertError::InvalidParamSegment)),
     ])
     .run();
 }

tests/match.rs

@@ -591,6 +591,37 @@ fn empty_param() {
     .run();
 }
 
+#[test]
+fn wildcard_suffix() {
+    MatchTest {
+        routes: vec![
+            "/",
+            "/{foo}x",
+            "/foox",
+            "/{foo}x/bar",
+            "/{foo}x/bar/baz",
+            "/x{foo}",
+            "/x{foo}/bar",
+        ],
+        matches: vec![
+            ("/", "/", p! {}),
+            ("/foox", "/foox", p! {}),
+            ("/barx", "/{foo}x", p! { "foo" => "bar" }),
+            ("/mx", "/{foo}x", p! { "foo" => "m" }),
+            ("/mx/", "", Err(())),
+            ("/mxm", "", Err(())),
+            ("/mx/bar", "/{foo}x/bar", p! { "foo" => "m" }),
+            ("/mxm/bar", "", Err(())),
+            ("/x", "", Err(())),
+            ("/xfoo", "/x{foo}", p! { "foo" => "foo" }),
+            ("/xfoox", "/x{foo}", p! { "foo" => "foox" }),
+            ("/xfoox/bar", "/x{foo}/bar", p! { "foo" => "foox" }),
+            ("/xfoox/bar/baz", "/{foo}x/bar/baz", p! { "foo" => "xfoo" }),
+        ],
+    }
+    .run();
+}
+
 #[test]
 fn basic() {
     MatchTest {