fix: required parameter should not be empty

src/node.rs

@@ -210,6 +210,11 @@ impl<T: fmt::Debug> Node<T> {
                             });
                         }
                     } else {
+                        // if it's normal, parameter should not be empty
+                        if k == &Kind::Normal && bytes[0] == b'/' {
+                            return None;
+                        }
+
                         // static
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
                             nodes.iter().find_map(|node| match &node.key {
@@ -334,12 +339,39 @@ impl<T: fmt::Debug> Node<T> {
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
                             nodes.iter().find_map(|node| {
                                 if let Key::String(s) = &node.key {
-                                    let right_length = if is_one_or_more {
+                                    let is_slash = is_one_or_more && s.len() == 1 && s[0] == b'/';
+                                    if is_slash {
+                                        let r = bytes
+                                            .iter()
+                                            .enumerate()
+                                            .filter_map(|(n, b)| (s[0] == *b).then_some(n))
+                                            .find_map(|n| {
+                                                node.nodes0.as_ref().and_then(|nodes| {
+                                                    nodes.iter().find_map(|node| {
+                                                        node.find_with(
+                                                            start + n + 1,
+                                                            &bytes[n + 1..],
+                                                            ranges,
+                                                        )
+                                                        .inspect(|_| {
+                                                            ranges.push(start..start + n);
+                                                        })
+                                                    })
+                                                })
+                                            });
+
+                                        if r.is_some() {
+                                            return r;
+                                        }
+                                    }
+
+                                    let has_right_length = if is_one_or_more {
                                         m > s.len()
                                     } else {
                                         m >= s.len()
                                     };
-                                    if right_length {
+
+                                    if has_right_length {
                                         return bytes
                                             .iter()
                                             .enumerate()
@@ -481,15 +513,23 @@ impl<T: fmt::Debug> fmt::Debug for Node<T> {
     }
 }
 
+const KINDS: [u8; 5] = [b'/', b':', b'?', b'+', b'*'];
+
+#[inline]
+fn find_index(c: u8) -> Option<usize> {
+    KINDS.iter().position(|e| *e == c)
+}
+
 #[inline]
 fn compare(a: u8, b: u8) -> Ordering {
     if a == b {
-        Ordering::Equal
-    } else if a == b'/' {
-        Ordering::Greater
-    } else if b == b'/' {
-        Ordering::Less
-    } else {
-        a.cmp(&b)
+        return Ordering::Equal;
+    }
+
+    match (find_index(a), find_index(b)) {
+        (Some(m), Some(n)) => m.cmp(&n),
+        (Some(_), None) => Ordering::Greater,
+        (None, Some(_)) => Ordering::Less,
+        (None, None) => a.cmp(&b),
     }
 }

src/parser.rs

@@ -1,6 +1,10 @@
 use alloc::{string::ToString, vec::Vec};
 use core::{iter::Peekable, str::CharIndices};
 
+/// Types of path segments.
+///
+/// Represents the matching pattern for parameters in URL paths.
+/// Different kinds determine how parameters match URL path segments.
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub enum Kind {
     /// `:` 58

tests/issues.rs

@@ -0,0 +1,65 @@
+use path_tree::PathTree;
+
+#[test]
+fn test_44() {
+    let mut tree = PathTree::new();
+    let _ = tree.insert("/test/:me", 0);
+    let _ = tree.insert("/test/:me?", 1);
+    let _ = tree.insert("/test/:me/now", 2);
+    let _ = tree.insert("/test/:me?/now", 3);
+    let _ = tree.insert("/test/:this+/now", 4);
+    let _ = tree.insert("/test/:this+/*", 5);
+    let _ = tree.insert("/test/:this+/now/*", 6);
+
+    let (value, path) = tree.find("/test/").unwrap();
+    assert_eq!(value, &1);
+    assert_eq!(path.params(), &[("me", "")]);
+
+    let (value, path) = tree.find("/test/now").unwrap();
+    assert_eq!(value, &0);
+    assert_eq!(path.params(), &[("me", "now")]);
+
+    // not found
+    let result = tree.find("/test//");
+    assert!(result.is_none());
+
+    let (value, path) = tree.find("/test//now").unwrap();
+    assert_eq!(value, &3);
+    assert_eq!(path.params(), &[("me", "")]);
+
+    let (value, path) = tree.find(r"/test/\/now").unwrap();
+    assert_eq!(value, &2);
+    assert_eq!(path.params(), &[("me", r"\")]);
+
+    // trim `/`
+    let trimmed = "/test//now"
+        .split('/')
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>();
+    let mut path = trimmed.join("/");
+    // add leading `/`
+    path.insert(0, '/');
+    assert_eq!(path, "/test/now");
+    let (value, path) = tree.find(&path).unwrap();
+    assert_eq!(value, &0);
+    assert_eq!(path.params(), &[("me", "now")]);
+
+    let (value, path) = tree.find("/test/multiple/paths/now").unwrap();
+    assert_eq!(value, &4);
+    assert_eq!(path.params(), &[("this", "multiple/paths")]);
+
+    let (value, path) = tree.find("/test/multiple/paths/noww").unwrap();
+    assert_eq!(value, &5);
+    assert_eq!(path.params(), &[("this", "multiple"), ("*1", "paths/noww")]);
+
+    let (value, path) = tree.find("/test/multiple/paths/now/12h").unwrap();
+    assert_eq!(value, &6);
+    assert_eq!(path.params(), &[("this", "multiple/paths"), ("*1", "12h")]);
+
+    let (value, path) = tree.find("/test/multiple/paths/today/12h").unwrap();
+    assert_eq!(value, &5);
+    assert_eq!(
+        path.params(),
+        &[("this", "multiple"), ("*1", "paths/today/12h")]
+    );
+}