chore: allow insert empty str

Author: fundon

src/lib.rs

@@ -168,28 +168,33 @@ impl<T> PathTree<T> {
     }
 
     pub fn insert(&mut self, path: &str, value: T) -> usize {
-        if path.is_empty() {
-            return self.id;
-        }
-
         let mut node = &mut self.node;
-        let pieces = Parser::new(path).collect::<Vec<_>>();
 
-        for piece in &pieces {
-            match piece {
-                Piece::String(s) => {
-                    node = node.insert_bytes(&s[..]);
-                }
-                Piece::Parameter(_, k) => {
-                    node = node.insert_parameter(*k);
+        let (overwritten, pieces) = if path.is_empty() {
+            (false, Vec::new())
+        } else {
+            let pieces = Parser::new(path).collect::<Vec<_>>();
+            for piece in &pieces {
+                match piece {
+                    Piece::String(s) => {
+                        node = node.insert_bytes(&s[..]);
+                    }
+                    Piece::Parameter(_, k) => {
+                        node = node.insert_parameter(*k);
+                    }
                 }
             }
-        }
+            (true, pieces)
+        };
 
-        self.routes.push((value, pieces));
         if let Some(id) = node.value {
+            self.routes[id].0 = value;
+            if overwritten {
+                self.routes[id].1 = pieces;
+            }
             id
         } else {
+            self.routes.push((value, pieces));
             let id = self.id;
             node.value = Some(id);
             self.id += 1;

src/node.rs

@@ -35,13 +35,13 @@ impl<T: fmt::Debug> Node<T> {
 
     pub fn insert_bytes(&mut self, mut bytes: &[u8]) -> &mut Self {
         let diff = match &mut self.kind {
-            NodeKind::String(p) => {
-                if p.is_empty() {
-                    *p = bytes.to_vec();
+            NodeKind::String(s) => {
+                if s.is_empty() {
+                    *s = bytes.to_vec();
                     return self;
                 }
 
-                let cursor = p
+                let cursor = s
                     .iter()
                     .zip(bytes.iter())
                     .take_while(|(a, b)| a == b)
@@ -51,10 +51,10 @@ impl<T: fmt::Debug> Node<T> {
                     true
                 } else {
                     // split node
-                    if cursor < p.len() {
-                        let (prefix, suffix) = p.split_at(cursor);
+                    if cursor < s.len() {
+                        let (prefix, suffix) = s.split_at(cursor);
                         let mut node = Node::new(NodeKind::String(prefix.to_vec()), None);
-                        *p = suffix.to_vec();
+                        *s = suffix.to_vec();
                         ::std::mem::swap(self, &mut node);
                         self.nodes0.get_or_insert_with(Vec::new).push(node);
                     }

tests/tree.rs

@@ -1693,6 +1693,16 @@ fn basic() {
     assert_eq!(r.value, &0);
     assert_eq!(r.params(), vec![]);
 
+    tree.insert("", 14);
+    let r = tree.find("/").unwrap();
+    assert_eq!(r.value, &14);
+    assert_eq!(r.params(), vec![]);
+
+    tree.insert("/", 15);
+    let r = tree.find("/").unwrap();
+    assert_eq!(r.value, &15);
+    assert_eq!(r.params(), vec![]);
+
     let r = tree.find("/login").unwrap();
     assert_eq!(r.value, &1);
     assert_eq!(r.params(), vec![]);