allow empty pattern

router/src/de.rs

@@ -2,7 +2,7 @@ use serde::de::{self, Deserializer, Error as DeError, Visitor};
 use serde::forward_to_deserialize_any;
 
 use crate::path::{Path, PathIter};
-use crate::ResourcePath;
+use crate::Resource;
 
 macro_rules! unsupported_type {
     ($trait_fn:ident, $name:expr) => {
@@ -33,17 +33,17 @@ macro_rules! parse_single_value {
     }
 }
 
-pub struct PathDeserializer<'de, T: ResourcePath + 'de> {
+pub struct PathDeserializer<'de, T: Resource + 'de> {
     path: &'de Path<T>,
 }
 
-impl<'de, T: ResourcePath + 'de> PathDeserializer<'de, T> {
+impl<'de, T: Resource + 'de> PathDeserializer<'de, T> {
     pub fn new(path: &'de Path<T>) -> Self {
         PathDeserializer { path }
     }
 }
 
-impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
+impl<'de, T: Resource + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
     type Error = de::value::Error;
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -206,12 +206,12 @@ impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T>
     parse_single_value!(deserialize_char, visit_char, "char");
 }
 
-struct ParamsDeserializer<'de, T: ResourcePath> {
+struct ParamsDeserializer<'de, T: Resource> {
     params: PathIter<'de, T>,
     current: Option<(&'de str, &'de str)>,
 }
 
-impl<'de, T: ResourcePath> de::MapAccess<'de> for ParamsDeserializer<'de, T> {
+impl<'de, T: Resource> de::MapAccess<'de> for ParamsDeserializer<'de, T> {
     type Error = de::value::Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
@@ -406,11 +406,11 @@ impl<'de> Deserializer<'de> for Value<'de> {
     unsupported_type!(deserialize_identifier, "identifier");
 }
 
-struct ParamsSeq<'de, T: ResourcePath> {
+struct ParamsSeq<'de, T: Resource> {
     params: PathIter<'de, T>,
 }
 
-impl<'de, T: ResourcePath> de::SeqAccess<'de> for ParamsSeq<'de, T> {
+impl<'de, T: Resource> de::SeqAccess<'de> for ParamsSeq<'de, T> {
     type Error = de::value::Error;
 
     fn next_element_seed<U>(&mut self, seed: U) -> Result<Option<U::Value>, Self::Error>

router/src/lib.rs

@@ -9,23 +9,23 @@ pub use self::path::Path;
 pub use self::resource::ResourceDef;
 pub use self::router::{ResourceInfo, Router, RouterBuilder};
 
-pub trait ResourcePath {
+pub trait Resource {
     fn path(&self) -> &str;
 }
 
-impl ResourcePath for String {
+impl Resource for String {
     fn path(&self) -> &str {
         self.as_str()
     }
 }
 
-impl<'a> ResourcePath for &'a str {
+impl<'a> Resource for &'a str {
     fn path(&self) -> &str {
         self
     }
 }
 
-impl<T: AsRef<[u8]>> ResourcePath for string::String<T> {
+impl<T: AsRef<[u8]>> Resource for string::String<T> {
     fn path(&self) -> &str {
         &*self
     }
@@ -39,10 +39,10 @@ pub use self::url::Url;
 
 #[cfg(feature = "http")]
 mod http_support {
-    use super::ResourcePath;
+    use super::Resource;
     use http::Uri;
 
-    impl ResourcePath for Uri {
+    impl Resource for Uri {
         fn path(&self) -> &str {
             self.path()
         }

router/src/path.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 use serde::de;
 
 use crate::de::PathDeserializer;
-use crate::ResourcePath;
+use crate::Resource;
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum PathItem {
@@ -42,7 +42,7 @@ impl<T: Clone> Clone for Path<T> {
     }
 }
 
-impl<T: ResourcePath> Path<T> {
+impl<T: Resource> Path<T> {
     pub fn new(path: T) -> Path<T> {
         Path {
             path,
@@ -165,7 +165,7 @@ pub struct PathIter<'a, T> {
     params: &'a Path<T>,
 }
 
-impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
+impl<'a, T: Resource> Iterator for PathIter<'a, T> {
     type Item = (&'a str, &'a str);
 
     #[inline]
@@ -183,7 +183,7 @@ impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
     }
 }
 
-impl<'a, T: ResourcePath> Index<&'a str> for Path<T> {
+impl<'a, T: Resource> Index<&'a str> for Path<T> {
     type Output = str;
 
     fn index(&self, name: &'a str) -> &str {
@@ -192,7 +192,7 @@ impl<'a, T: ResourcePath> Index<&'a str> for Path<T> {
     }
 }
 
-impl<T: ResourcePath> Index<usize> for Path<T> {
+impl<T: Resource> Index<usize> for Path<T> {
     type Output = str;
 
     fn index(&self, idx: usize) -> &str {

router/src/resource.rs

@@ -5,7 +5,7 @@ use std::rc::Rc;
 use regex::{escape, Regex};
 
 use crate::path::{Path, PathItem};
-use crate::ResourcePath;
+use crate::Resource;
 
 const MAX_DYNAMIC_SEGMENTS: usize = 16;
 
@@ -119,7 +119,7 @@ impl ResourceDef {
     }
 
     /// Is the given path and parameters a match against this pattern?
-    pub fn match_path<T: ResourcePath>(&self, path: &mut Path<T>) -> bool {
+    pub fn match_path<T: Resource>(&self, path: &mut Path<T>) -> bool {
         match self.tp {
             PatternType::Static(ref s) => {
                 if s == path.path() {

router/src/router.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use crate::path::Path;
 use crate::resource::ResourceDef;
-use crate::ResourcePath;
+use crate::Resource;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub(crate) enum ResourceId {
@@ -41,34 +41,30 @@ impl<T> Router<T> {
         }
     }
 
-    pub fn recognize<U: ResourcePath>(&self, path: &mut Path<U>) -> Option<(&T, ResourceInfo)> {
-        if !path.path().is_empty() {
-            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
-                if resource.match_path(path) {
-                    let info = ResourceInfo {
-                        rmap: self.rmap.clone(),
-                        resource: ResourceId::Normal(idx as u16),
-                    };
-                    return Some((&self.resources[idx], info));
-                }
+    pub fn recognize<U: Resource>(&self, path: &mut Path<U>) -> Option<(&T, ResourceInfo)> {
+        for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+            if resource.match_path(path) {
+                let info = ResourceInfo {
+                    rmap: self.rmap.clone(),
+                    resource: ResourceId::Normal(idx as u16),
+                };
+                return Some((&self.resources[idx], info));
             }
         }
         None
     }
 
-    pub fn recognize_mut<U: ResourcePath>(
+    pub fn recognize_mut<U: Resource>(
         &mut self,
         path: &mut Path<U>,
     ) -> Option<(&mut T, ResourceInfo)> {
-        if !path.path().is_empty() {
-            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
-                if resource.match_path(path) {
-                    let info = ResourceInfo {
-                        rmap: self.rmap.clone(),
-                        resource: ResourceId::Normal(idx as u16),
-                    };
-                    return Some((&mut self.resources[idx], info));
-                }
+        for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+            if resource.match_path(path) {
+                let info = ResourceInfo {
+                    rmap: self.rmap.clone(),
+                    resource: ResourceId::Normal(idx as u16),
+                };
+                return Some((&mut self.resources[idx], info));
             }
         }
         None

router/src/url.rs

@@ -1,6 +1,6 @@
 use std::rc::Rc;
 
-use crate::ResourcePath;
+use crate::Resource;
 
 #[allow(dead_code)]
 const GEN_DELIMS: &[u8] = b":/?#[]@";
@@ -67,7 +67,7 @@ impl Url {
     }
 }
 
-impl ResourcePath for Url {
+impl Resource for Url {
     fn path(&self) -> &str {
         self.path()
     }