rename `with_prefix()` and move common function ...

... into `parse()`. to simplify return types and reuse code.

actix-router/src/resource.rs

@@ -48,29 +48,19 @@ impl ResourceDef {
     /// Panics if path pattern is malformed.
     pub fn new<T: IntoPattern>(path: T) -> Self {
         if path.is_single() {
-            let patterns = path.patterns();
+            ResourceDef::from_single_pattern(&path.patterns()[0], false)
-            ResourceDef::with_prefix(&patterns[0], false)
         } else {
-            let set = path.patterns();
             let mut data = Vec::new();
             let mut re_set = Vec::new();
 
-            for path in set {
+            for pattern in path.patterns() {
-                let (pattern, _, _, len) = ResourceDef::parse(&path, false, true);
+                match ResourceDef::parse(&pattern, false, true) {
-
+                    (PatternType::Dynamic(re, names, len), _) => {
-                let re = match Regex::new(&pattern) {
+                        re_set.push(re.as_str().to_owned());
-                    Ok(re) => re,
+                        data.push((re, names, len));
-                    Err(err) => panic!("Wrong path pattern: \"{}\" {}", path, err),
+                    }
-                };
+                    _ => unreachable!(),
-                // actix creates one router per thread
+                }
-                let names: Vec<_> = re
-                    .capture_names()
-                    .filter_map(|name| {
-                        name.map(|name| Box::leak(Box::new(name.to_owned())).as_str())
-                    })
-                    .collect();
-                data.push((re, names, len));
-                re_set.push(pattern);
             }
 
             ResourceDef {
@@ -89,7 +79,7 @@ impl ResourceDef {
     ///
     /// Panics if path regex pattern is malformed.
     pub fn prefix(path: &str) -> Self {
-        ResourceDef::with_prefix(path, true)
+        ResourceDef::from_single_pattern(path, true)
     }
 
     /// Parse path pattern and create new `Pattern` instance.
@@ -100,7 +90,7 @@ impl ResourceDef {
     ///
     /// Panics if path regex pattern is malformed.
     pub fn root_prefix(path: &str) -> Self {
-        ResourceDef::with_prefix(&insert_slash(path), true)
+        ResourceDef::from_single_pattern(&insert_slash(path), true)
     }
 
     /// Resource id
@@ -113,36 +103,17 @@ impl ResourceDef {
         self.id = id;
     }
 
-    /// Parse path pattern and create new `Pattern` instance with custom prefix
+    /// Parse path pattern and create a new instance
-    fn with_prefix(path: &str, for_prefix: bool) -> Self {
+    fn from_single_pattern(pattern: &str, for_prefix: bool) -> Self {
-        let path = path.to_owned();
+        let pattern = pattern.to_owned();
-        let (pattern, elements, is_dynamic, len) = ResourceDef::parse(&path, for_prefix, false);
+        let (tp, elements) = ResourceDef::parse(&pattern, for_prefix, false);
-
-        let tp = if is_dynamic {
-            let re = match Regex::new(&pattern) {
-                Ok(re) => re,
-                Err(err) => panic!("Wrong path pattern: \"{}\" {}", path, err),
-            };
-            // actix creates one router per thread
-            let names = re
-                .capture_names()
-                .filter_map(|name| {
-                    name.map(|name| Box::leak(Box::new(name.to_owned())).as_str())
-                })
-                .collect();
-            PatternType::Dynamic(re, names, len)
-        } else if for_prefix {
-            PatternType::Prefix(pattern)
-        } else {
-            PatternType::Static(pattern)
-        };
 
         ResourceDef {
             tp,
             elements,
             id: 0,
             name: String::new(),
-            pattern: path,
+            pattern: pattern.to_string(),
         }
     }
 
@@ -574,16 +545,19 @@ impl ResourceDef {
         mut pattern: &str,
         mut for_prefix: bool,
         force_dynamic: bool,
-    ) -> (String, Vec<PatternElement>, bool, usize) {
+    ) -> (PatternType, Vec<PatternElement>) {
         if !force_dynamic && pattern.find('{').is_none() && !pattern.ends_with('*') {
             return (
-                String::from(pattern),
+                if for_prefix {
+                    PatternType::Prefix(String::from(pattern))
+                } else {
+                    PatternType::Static(String::from(pattern))
+                },
                 vec![PatternElement::Str(String::from(pattern))],
-                false,
-                pattern.chars().count(),
             );
         }
 
+        let pattern_orig = pattern.to_owned();
         let mut elements = Vec::new();
         let mut re = format!("{}^", REGEX_FLAGS);
         let mut dyn_elements = 0;
@@ -623,7 +597,21 @@ impl ResourceDef {
         if !for_prefix {
             re.push('$');
         }
-        (re, elements, true, pattern.chars().count())
+
+        let re = match Regex::new(&re) {
+            Ok(re) => re,
+            Err(err) => panic!("Wrong path pattern: \"{}\" {}", pattern_orig, err),
+        };
+        // actix creates one router per thread
+        let names = re
+            .capture_names()
+            .filter_map(|name| name.map(|name| Box::leak(Box::new(name.to_owned())).as_str()))
+            .collect();
+
+        (
+            PatternType::Dynamic(re, names, pattern.chars().count()),
+            elements,
+        )
     }
 }