use std::mem; use std::rc::Rc; use std::hash::{Hash, Hasher}; use std::collections::HashMap; use regex::{Regex, escape}; use percent_encoding::percent_decode; use error::UrlGenerationError; use param::Params; use resource::Resource; use httprequest::HttpRequest; use server::ServerSettings; /// Interface for application router. pub struct Router(Rc); struct Inner { prefix: String, prefix_len: usize, named: HashMap, patterns: Vec, srv: ServerSettings, } impl Router { /// Create new router pub fn new(prefix: &str, settings: ServerSettings, map: Vec<(Pattern, Option>)>) -> (Router, Vec>) { let prefix = prefix.trim().trim_right_matches('/').to_owned(); let mut named = HashMap::new(); let mut patterns = Vec::new(); let mut resources = Vec::new(); for (pattern, resource) in map { if !pattern.name().is_empty() { let name = pattern.name().into(); named.insert(name, (pattern.clone(), resource.is_none())); } if let Some(resource) = resource { patterns.push(pattern); resources.push(resource); } } let prefix_len = prefix.len(); (Router(Rc::new( Inner{ prefix, prefix_len, named, patterns, srv: settings })), resources) } /// Router prefix #[inline] pub fn prefix(&self) -> &str { &self.0.prefix } /// Server settings #[inline] pub fn server_settings(&self) -> &ServerSettings { &self.0.srv } /// Query for matched resource pub fn recognize(&self, req: &mut HttpRequest) -> Option { if self.0.prefix_len > req.path().len() { return None } let path: &str = unsafe{mem::transmute(&req.path()[self.0.prefix_len..])}; let route_path = if path.is_empty() { "/" } else { path }; let p = percent_decode(route_path.as_bytes()).decode_utf8().unwrap(); for (idx, pattern) in self.0.patterns.iter().enumerate() { if pattern.match_with_params(p.as_ref(), req.match_info_mut()) { return Some(idx) } } None } /// Check if application contains matching route. /// /// This method does not take `prefix` into account. /// For example if prefix is `/test` and router contains route `/name`, /// following path would be recognizable `/test/name` but `has_route()` call /// would return `false`. pub fn has_route(&self, path: &str) -> bool { let path = if path.is_empty() { "/" } else { path }; for pattern in &self.0.patterns { if pattern.is_match(path) { return true } } false } /// Build named resource path. /// /// Check [`HttpRequest::url_for()`](../struct.HttpRequest.html#method.url_for) /// for detailed information. pub fn resource_path(&self, name: &str, elements: U) -> Result where U: IntoIterator, I: AsRef, { if let Some(pattern) = self.0.named.get(name) { if pattern.1 { pattern.0.path(None, elements) } else { pattern.0.path(Some(&self.0.prefix), elements) } } else { Err(UrlGenerationError::ResourceNotFound) } } } impl Clone for Router { fn clone(&self) -> Router { Router(Rc::clone(&self.0)) } } #[derive(Debug, Clone, PartialEq)] enum PatternElement { Str(String), Var(String), } #[derive(Clone, Debug)] enum PatternType { Static(String), Dynamic(Regex, Vec), } #[derive(Clone)] pub struct Pattern { tp: PatternType, name: String, pattern: String, elements: Vec, } impl Pattern { /// Parse path pattern and create new `Pattern` instance. /// /// Panics if path pattern is wrong. pub fn new(name: &str, path: &str) -> Self { Pattern::with_prefix(name, path, "/") } /// Parse path pattern and create new `Pattern` instance with custom prefix pub fn with_prefix(name: &str, path: &str, prefix: &str) -> Self { let (pattern, elements, is_dynamic) = Pattern::parse(path, prefix); let tp = if is_dynamic { let re = match Regex::new(&pattern) { Ok(re) => re, Err(err) => panic!("Wrong path pattern: \"{}\" {}", path, err) }; let names = re.capture_names() .filter_map(|name| name.map(|name| name.to_owned())) .collect(); PatternType::Dynamic(re, names) } else { PatternType::Static(pattern.clone()) }; Pattern { tp, pattern, elements, name: name.into(), } } /// Returns name of the pattern pub fn name(&self) -> &str { &self.name } /// Returns path of the pattern pub fn pattern(&self) -> &str { &self.pattern } pub fn is_match(&self, path: &str) -> bool { match self.tp { PatternType::Static(ref s) => s == path, PatternType::Dynamic(ref re, _) => re.is_match(path), } } pub fn match_with_params<'a>(&'a self, path: &'a str, params: &'a mut Params<'a>) -> bool { match self.tp { PatternType::Static(ref s) => s == path, PatternType::Dynamic(ref re, ref names) => { if let Some(captures) = re.captures(path) { let mut idx = 0; for capture in captures.iter() { if let Some(ref m) = capture { if idx != 0 { params.add(names[idx-1].as_str(), m.as_str()); } idx += 1; } } true } else { false } } } } /// Build pattern path. pub fn path(&self, prefix: Option<&str>, elements: U) -> Result where U: IntoIterator, I: AsRef, { let mut iter = elements.into_iter(); let mut path = if let Some(prefix) = prefix { format!("{}/", prefix) } else { String::new() }; for el in &self.elements { match *el { PatternElement::Str(ref s) => path.push_str(s), PatternElement::Var(_) => { if let Some(val) = iter.next() { path.push_str(val.as_ref()) } else { return Err(UrlGenerationError::NotEnoughElements) } } } } Ok(path) } fn parse(pattern: &str, prefix: &str) -> (String, Vec, bool) { const DEFAULT_PATTERN: &str = "[^/]+"; let mut re1 = String::from("^") + prefix; let mut re2 = String::from(prefix); let mut el = String::new(); let mut in_param = false; let mut in_param_pattern = false; let mut param_name = String::new(); let mut param_pattern = String::from(DEFAULT_PATTERN); let mut is_dynamic = false; let mut elems = Vec::new(); for (index, ch) in pattern.chars().enumerate() { // All routes must have a leading slash so its optional to have one if index == 0 && ch == '/' { continue; } if in_param { // In parameter segment: `{....}` if ch == '}' { elems.push(PatternElement::Var(param_name.clone())); re1.push_str(&format!(r"(?P<{}>{})", ¶m_name, ¶m_pattern)); param_name.clear(); param_pattern = String::from(DEFAULT_PATTERN); in_param_pattern = false; in_param = false; } else if ch == ':' { // The parameter name has been determined; custom pattern land in_param_pattern = true; param_pattern.clear(); } else if in_param_pattern { // Ignore leading whitespace for pattern if !(ch == ' ' && param_pattern.is_empty()) { param_pattern.push(ch); } } else { param_name.push(ch); } } else if ch == '{' { in_param = true; is_dynamic = true; elems.push(PatternElement::Str(el.clone())); el.clear(); } else { re1.push_str(escape(&ch.to_string()).as_str()); re2.push(ch); el.push(ch); } } let re = if is_dynamic { re1.push('$'); re1 } else { re2 }; (re, elems, is_dynamic) } } impl PartialEq for Pattern { fn eq(&self, other: &Pattern) -> bool { self.pattern == other.pattern } } impl Eq for Pattern {} impl Hash for Pattern { fn hash(&self, state: &mut H) { self.pattern.hash(state); } } #[cfg(test)] mod tests { use super::*; use test::TestRequest; #[test] fn test_recognizer() { let routes = vec![ (Pattern::new("", "/name"), Some(Resource::default())), (Pattern::new("", "/name/{val}"), Some(Resource::default())), (Pattern::new("", "/name/{val}/index.html"), Some(Resource::default())), (Pattern::new("", "/file/{file}.{ext}"), Some(Resource::default())), (Pattern::new("", "/v{val}/{val2}/index.html"), Some(Resource::default())), (Pattern::new("", "/v/{tail:.*}"), Some(Resource::default())), (Pattern::new("", "{test}/index.html"), Some(Resource::default()))]; let (rec, _) = Router::new::<()>("", ServerSettings::default(), routes); let mut req = TestRequest::with_uri("/name").finish(); assert_eq!(rec.recognize(&mut req), Some(0)); assert!(req.match_info().is_empty()); let mut req = TestRequest::with_uri("/name/value").finish(); assert_eq!(rec.recognize(&mut req), Some(1)); assert_eq!(req.match_info().get("val").unwrap(), "value"); assert_eq!(&req.match_info()["val"], "value"); let mut req = TestRequest::with_uri("/name/value2/index.html").finish(); assert_eq!(rec.recognize(&mut req), Some(2)); assert_eq!(req.match_info().get("val").unwrap(), "value2"); let mut req = TestRequest::with_uri("/file/file.gz").finish(); assert_eq!(rec.recognize(&mut req), Some(3)); assert_eq!(req.match_info().get("file").unwrap(), "file"); assert_eq!(req.match_info().get("ext").unwrap(), "gz"); let mut req = TestRequest::with_uri("/vtest/ttt/index.html").finish(); assert_eq!(rec.recognize(&mut req), Some(4)); assert_eq!(req.match_info().get("val").unwrap(), "test"); assert_eq!(req.match_info().get("val2").unwrap(), "ttt"); let mut req = TestRequest::with_uri("/v/blah-blah/index.html").finish(); assert_eq!(rec.recognize(&mut req), Some(5)); assert_eq!(req.match_info().get("tail").unwrap(), "blah-blah/index.html"); let mut req = TestRequest::with_uri("/bbb/index.html").finish(); assert_eq!(rec.recognize(&mut req), Some(6)); assert_eq!(req.match_info().get("test").unwrap(), "bbb"); } #[test] fn test_recognizer_2() { let routes = vec![ (Pattern::new("", "/index.json"), Some(Resource::default())), (Pattern::new("", "/{source}.json"), Some(Resource::default()))]; let (rec, _) = Router::new::<()>("", ServerSettings::default(), routes); let mut req = TestRequest::with_uri("/index.json").finish(); assert_eq!(rec.recognize(&mut req), Some(0)); let mut req = TestRequest::with_uri("/test.json").finish(); assert_eq!(rec.recognize(&mut req), Some(1)); } #[test] fn test_recognizer_with_prefix() { let routes = vec![ (Pattern::new("", "/name"), Some(Resource::default())), (Pattern::new("", "/name/{val}"), Some(Resource::default()))]; let (rec, _) = Router::new::<()>("/test", ServerSettings::default(), routes); let mut req = TestRequest::with_uri("/name").finish(); assert!(rec.recognize(&mut req).is_none()); let mut req = TestRequest::with_uri("/test/name").finish(); assert_eq!(rec.recognize(&mut req), Some(0)); let mut req = TestRequest::with_uri("/test/name/value").finish(); assert_eq!(rec.recognize(&mut req), Some(1)); assert_eq!(req.match_info().get("val").unwrap(), "value"); assert_eq!(&req.match_info()["val"], "value"); // same patterns let routes = vec![ (Pattern::new("", "/name"), Some(Resource::default())), (Pattern::new("", "/name/{val}"), Some(Resource::default()))]; let (rec, _) = Router::new::<()>("/test2", ServerSettings::default(), routes); let mut req = TestRequest::with_uri("/name").finish(); assert!(rec.recognize(&mut req).is_none()); let mut req = TestRequest::with_uri("/test2/name").finish(); assert_eq!(rec.recognize(&mut req), Some(0)); let mut req = TestRequest::with_uri("/test2/name-test").finish(); assert!(rec.recognize(&mut req).is_none()); let mut req = TestRequest::with_uri("/test2/name/ttt").finish(); assert_eq!(rec.recognize(&mut req), Some(1)); assert_eq!(&req.match_info()["val"], "ttt"); } #[test] fn test_parse_static() { let re = Pattern::new("test", "/"); assert!(re.is_match("/")); assert!(!re.is_match("/a")); let re = Pattern::new("test", "/name"); assert!(re.is_match("/name")); assert!(!re.is_match("/name1")); assert!(!re.is_match("/name/")); assert!(!re.is_match("/name~")); let re = Pattern::new("test", "/name/"); assert!(re.is_match("/name/")); assert!(!re.is_match("/name")); assert!(!re.is_match("/name/gs")); let re = Pattern::new("test", "/user/profile"); assert!(re.is_match("/user/profile")); assert!(!re.is_match("/user/profile/profile")); } #[test] fn test_parse_param() { let mut req = HttpRequest::default(); let re = Pattern::new("test", "/user/{id}"); assert!(re.is_match("/user/profile")); assert!(re.is_match("/user/2345")); assert!(!re.is_match("/user/2345/")); assert!(!re.is_match("/user/2345/sdg")); req.match_info_mut().clear(); assert!(re.match_with_params("/user/profile", req.match_info_mut())); assert_eq!(req.match_info().get("id").unwrap(), "profile"); req.match_info_mut().clear(); assert!(re.match_with_params("/user/1245125", req.match_info_mut())); assert_eq!(req.match_info().get("id").unwrap(), "1245125"); let re = Pattern::new("test", "/v{version}/resource/{id}"); assert!(re.is_match("/v1/resource/320120")); assert!(!re.is_match("/v/resource/1")); assert!(!re.is_match("/resource")); req.match_info_mut().clear(); assert!(re.match_with_params("/v151/resource/adahg32", req.match_info_mut())); assert_eq!(req.match_info().get("version").unwrap(), "151"); assert_eq!(req.match_info().get("id").unwrap(), "adahg32"); } }