berkus
/
actix-net
mirror of https://github.com/fafhrd91/actix-net
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'master' into patch-1

This commit is contained in:
Rob Ede 2021-07-16 18:22:42 +01:00 committed by GitHub
parent 5dadd30bff 5b1ff30dd9
commit b2330ce68a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 176 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
actix-router/CHANGES.md
View File

@ -1,6 +1,12 @@
# Changes # Changes
## Unreleased - 2021-xx-xx ## Unreleased - 2021-xx-xx
* Fix segment interpolation leaving `Path` in unintended state after matching. [#368]
* Path tail pattern now works as expected after a dynamic segment (e.g. `/user/{uid}/*`). [#366]
* Fixed a bug where, in multi-patterns, static patterns are interpreted as regex. [#366]
[#368]: https://github.com/actix/actix-net/pull/368
[#366]: https://github.com/actix/actix-net/pull/366
## 0.4.0 - 2021-06-06 ## 0.4.0 - 2021-06-06

451
actix-router/src/resource.rs
View File

@ -24,12 +24,12 @@ pub struct ResourceDef {
tp: PatternType, tp: PatternType,
name: String, name: String,
pattern: String, pattern: String,
elements: Vec<PatternElement>, elements: Option<Vec<PatternElement>>,
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
enum PatternElement { enum PatternElement {
Str(String), Const(String),
Var(String), Var(String),
} }
@ -38,8 +38,8 @@ enum PatternElement {
enum PatternType { enum PatternType {
Static(String), Static(String),
Prefix(String), Prefix(String),
Dynamic(Regex, Vec<&'static str>, usize), Dynamic(Regex, Vec<&'static str>),
DynamicSet(RegexSet, Vec<(Regex, Vec<&'static str>, usize)>), DynamicSet(RegexSet, Vec<(Regex, Vec<&'static str>)>),
} }
impl ResourceDef { impl ResourceDef {
@ -48,35 +48,25 @@ impl ResourceDef {
/// Panics if path pattern is malformed. /// Panics if path pattern is malformed.
pub fn new<T: IntoPattern>(path: T) -> Self { pub fn new<T: IntoPattern>(path: T) -> Self {
if path.is_single() { if path.is_single() {
let patterns = path.patterns(); ResourceDef::from_single_pattern(&path.patterns()[0], false)
ResourceDef::with_prefix(&patterns[0], false)
} else { } else {
let set = path.patterns();
let mut data = Vec::new(); let mut data = Vec::new();
let mut re_set = Vec::new(); let mut re_set = Vec::new();
for path in set { for pattern in path.patterns() {
let (pattern, _, _, len) = ResourceDef::parse(&path, false); match ResourceDef::parse(&pattern, false, true) {
(PatternType::Dynamic(re, names), _) => {
let re = match Regex::new(&pattern) { re_set.push(re.as_str().to_owned());
Ok(re) => re, data.push((re, names));
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 { ResourceDef {
id: 0, id: 0,
tp: PatternType::DynamicSet(RegexSet::new(re_set).unwrap(), data), tp: PatternType::DynamicSet(RegexSet::new(re_set).unwrap(), data),
elements: Vec::new(), elements: None,
name: String::new(), name: String::new(),
pattern: "".to_owned(), pattern: "".to_owned(),
} }
@ -89,7 +79,7 @@ impl ResourceDef {
/// ///
/// Panics if path regex pattern is malformed. /// Panics if path regex pattern is malformed.
pub fn prefix(path: &str) -> Self { 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. /// Parse path pattern and create new `Pattern` instance.
@ -100,7 +90,7 @@ impl ResourceDef {
/// ///
/// Panics if path regex pattern is malformed. /// Panics if path regex pattern is malformed.
pub fn root_prefix(path: &str) -> Self { pub fn root_prefix(path: &str) -> Self {
ResourceDef::with_prefix(&insert_slash(path), true) ResourceDef::from_single_pattern(&insert_slash(path), true)
} }
/// Resource id /// Resource id
@ -113,36 +103,17 @@ impl ResourceDef {
self.id = id; 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); 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 { ResourceDef {
tp, tp,
elements, pattern,
elements: Some(elements),
id: 0, id: 0,
name: String::new(), name: String::new(),
pattern: path,
} }
} }
@ -167,7 +138,7 @@ impl ResourceDef {
match self.tp { match self.tp {
PatternType::Static(ref s) => s == path, PatternType::Static(ref s) => s == path,
PatternType::Prefix(ref s) => path.starts_with(s), PatternType::Prefix(ref s) => path.starts_with(s),
PatternType::Dynamic(ref re, _, _) => re.is_match(path), PatternType::Dynamic(ref re, _) => re.is_match(path),
PatternType::DynamicSet(ref re, _) => re.is_match(path), PatternType::DynamicSet(ref re, _) => re.is_match(path),
} }
} }
@ -185,25 +156,7 @@ impl ResourceDef {
None None
} }
} }
PatternType::Dynamic(ref re, _, len) => { PatternType::Dynamic(ref re, _) => re.find(path).map(|m| m.end()),
if let Some(captures) = re.captures(path) {
let mut pos = 0;
let mut passed = false;
for capture in captures.iter() {
if let Some(ref m) = capture {
if !passed {
passed = true;
continue;
}
pos = m.end();
}
}
Some(pos + len)
} else {
None
}
}
PatternType::Prefix(ref s) => { PatternType::Prefix(ref s) => {
let len = if path == s { let len = if path == s {
s.len() s.len()
@ -221,121 +174,16 @@ impl ResourceDef {
Some(min(p_len, len)) Some(min(p_len, len))
} }
PatternType::DynamicSet(ref re, ref params) => { PatternType::DynamicSet(ref re, ref params) => {
if let Some(idx) = re.matches(path).into_iter().next() { let idx = re.matches(path).into_iter().next()?;
let (ref pattern, _, len) = params[idx]; let (ref pattern, _) = params[idx];
if let Some(captures) = pattern.captures(path) { pattern.find(path).map(|m| m.end())
let mut pos = 0;
let mut passed = false;
for capture in captures.iter() {
if let Some(ref m) = capture {
if !passed {
passed = true;
continue;
}
pos = m.end();
}
}
Some(pos + len)
} else {
None
}
} else {
None
}
} }
} }
} }
/// Is the given path and parameters a match against this pattern. /// 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: ResourcePath>(&self, path: &mut Path<T>) -> bool {
match self.tp { self.match_path_checked(path, &|_, _| true, &Some(()))
PatternType::Static(ref s) => {
if s == path.path() {
path.skip(path.len() as u16);
true
} else {
false
}
}
PatternType::Prefix(ref s) => {
let r_path = path.path();
let len = if s == r_path {
s.len()
} else if r_path.starts_with(s)
&& (s.ends_with('/') || r_path.split_at(s.len()).1.starts_with('/'))
{
if s.ends_with('/') {
s.len() - 1
} else {
s.len()
}
} else {
return false;
};
let r_path_len = r_path.len();
path.skip(min(r_path_len, len) as u16);
true
}
PatternType::Dynamic(ref re, ref names, len) => {
let mut pos = 0;
let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] = Default::default();
if let Some(captures) = re.captures(path.path()) {
for (no, name) in names.iter().enumerate() {
if let Some(m) = captures.name(&name) {
pos = m.end();
segments[no] = PathItem::Segment(m.start() as u16, m.end() as u16);
} else {
log::error!(
"Dynamic path match but not all segments found: {}",
name
);
return false;
}
}
} else {
return false;
}
for i in 0..names.len() {
path.add(names[i], mem::take(&mut segments[i]));
}
path.skip((pos + len) as u16);
true
}
PatternType::DynamicSet(ref re, ref params) => {
if let Some(idx) = re.matches(path.path()).into_iter().next() {
let (ref pattern, ref names, len) = params[idx];
let mut pos = 0;
let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] = Default::default();
if let Some(captures) = pattern.captures(path.path()) {
for (no, name) in names.iter().enumerate() {
if let Some(m) = captures.name(&name) {
pos = m.end();
segments[no] =
PathItem::Segment(m.start() as u16, m.end() as u16);
} else {
log::error!(
"Dynamic path match but not all segments found: {}",
name
);
return false;
}
}
} else {
return false;
}
for i in 0..names.len() {
path.add(names[i], mem::take(&mut segments[i]));
}
path.skip((pos + len) as u16);
true
} else {
false
}
}
}
} }
/// Is the given path and parameters a match against this pattern? /// Is the given path and parameters a match against this pattern?
@ -350,19 +198,19 @@ impl ResourceDef {
R: Resource<T>, R: Resource<T>,
F: Fn(&R, &Option<U>) -> bool, F: Fn(&R, &Option<U>) -> bool,
{ {
match self.tp { let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] = Default::default();
PatternType::Static(ref s) => {
if s == res.resource_path().path() && check(res, user_data) {
let path = res.resource_path(); let path = res.resource_path();
path.skip(path.len() as u16);
true let (matched_len, matched_vars) = match self.tp {
} else { PatternType::Static(ref s) => {
false if s != path.path() {
return false;
} }
(path.path().len(), None)
} }
PatternType::Prefix(ref s) => { PatternType::Prefix(ref s) => {
let len = { let len = {
let r_path = res.resource_path().path(); let r_path = path.path();
if s == r_path { if s == r_path {
s.len() s.len()
} else if r_path.starts_with(s) } else if r_path.starts_with(s)
@ -377,85 +225,80 @@ impl ResourceDef {
return false; return false;
} }
}; };
if !check(res, user_data) { (min(path.path().len(), len), None)
return false;
} }
let path = res.resource_path(); PatternType::Dynamic(ref re, ref names) => {
path.skip(min(path.path().len(), len) as u16); let captures = match re.captures(path.path()) {
true Some(captures) => captures,
} _ => return false,
PatternType::Dynamic(ref re, ref names, len) => { };
let mut pos = 0;
let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] = Default::default();
if let Some(captures) = re.captures(res.resource_path().path()) {
for (no, name) in names.iter().enumerate() { for (no, name) in names.iter().enumerate() {
if let Some(m) = captures.name(&name) { if let Some(m) = captures.name(&name) {
pos = m.end();
segments[no] = PathItem::Segment(m.start() as u16, m.end() as u16); segments[no] = PathItem::Segment(m.start() as u16, m.end() as u16);
} else { } else {
log::error!( log::error!("Dynamic path match but not all segments found: {}", name);
"Dynamic path match but not all segments found: {}",
name
);
return false; return false;
} }
} }
} else { (captures[0].len(), Some(names))
return false;
}
if !check(res, user_data) {
return false;
}
let path = res.resource_path();
for i in 0..names.len() {
path.add(names[i], mem::take(&mut segments[i]));
}
path.skip((pos + len) as u16);
true
} }
PatternType::DynamicSet(ref re, ref params) => { PatternType::DynamicSet(ref re, ref params) => {
let path = res.resource_path().path(); let path = path.path();
if let Some(idx) = re.matches(path).into_iter().next() { let (pattern, names) = match re.matches(path).into_iter().next() {
let (ref pattern, ref names, len) = params[idx]; Some(idx) => &params[idx],
let mut pos = 0; _ => return false,
let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] = Default::default(); };
let captures = match pattern.captures(path.path()) {
if let Some(captures) = pattern.captures(path) { Some(captures) => captures,
_ => return false,
};
for (no, name) in names.iter().enumerate() { for (no, name) in names.iter().enumerate() {
if let Some(m) = captures.name(&name) { if let Some(m) = captures.name(&name) {
pos = m.end(); segments[no] = PathItem::Segment(m.start() as u16, m.end() as u16);
segments[no] =
PathItem::Segment(m.start() as u16, m.end() as u16);
} else { } else {
log::error!( log::error!("Dynamic path match but not all segments found: {}", name);
"Dynamic path match but not all segments found: {}",
name
);
return false; return false;
} }
} }
} else { (captures[0].len(), Some(names))
return false;
} }
};
if !check(res, user_data) { if !check(res, user_data) {
return false; return false;
} }
// Modify `path` to skip matched part and store matched segments
let path = res.resource_path(); let path = res.resource_path();
for i in 0..names.len() { if let Some(vars) = matched_vars {
path.add(names[i], mem::take(&mut segments[i])); for i in 0..vars.len() {
path.add(vars[i], mem::take(&mut segments[i]));
} }
path.skip((pos + len) as u16); }
path.skip(matched_len as u16);
true true
} else { }
false
} /// Build resource path with a closure that maps variable elements' names to values.
fn build_resource_path<F, I>(&self, path: &mut String, mut vars: F) -> bool
where
F: FnMut(&str) -> Option<I>,
I: AsRef<str>,
{
for el in match self.elements {
Some(ref elements) => elements,
None => return false,
} {
match *el {
PatternElement::Const(ref val) => path.push_str(val),
PatternElement::Var(ref name) => match vars(name) {
Some(val) => path.push_str(val.as_ref()),
_ => return false,
},
} }
} }
true
} }
/// Build resource path from elements. Returns `true` on success. /// Build resource path from elements. Returns `true` on success.
@ -464,28 +307,7 @@ impl ResourceDef {
U: Iterator<Item = I>, U: Iterator<Item = I>,
I: AsRef<str>, I: AsRef<str>,
{ {
match self.tp { self.build_resource_path(path, |_| elements.next())
PatternType::Prefix(ref p) => path.push_str(p),
PatternType::Static(ref p) => path.push_str(p),
PatternType::Dynamic(..) => {
for el in &self.elements {
match *el {
PatternElement::Str(ref s) => path.push_str(s),
PatternElement::Var(_) => {
if let Some(val) = elements.next() {
path.push_str(val.as_ref())
} else {
return false;
}
}
}
}
}
PatternType::DynamicSet(..) => {
return false;
}
}
true
} }
/// Build resource path from elements. Returns `true` on success. /// Build resource path from elements. Returns `true` on success.
@ -499,28 +321,7 @@ impl ResourceDef {
V: AsRef<str>, V: AsRef<str>,
S: std::hash::BuildHasher, S: std::hash::BuildHasher,
{ {
match self.tp { self.build_resource_path(path, |name| elements.get(name))
PatternType::Prefix(ref p) => path.push_str(p),
PatternType::Static(ref p) => path.push_str(p),
PatternType::Dynamic(..) => {
for el in &self.elements {
match *el {
PatternElement::Str(ref s) => path.push_str(s),
PatternElement::Var(ref name) => {
if let Some(val) = elements.get(name) {
path.push_str(val.as_ref())
} else {
return false;
}
}
}
}
}
PatternType::DynamicSet(..) => {
return false;
}
}
true
} }
fn parse_param(pattern: &str) -> (PatternElement, String, &str, bool) { fn parse_param(pattern: &str) -> (PatternElement, String, &str, bool) {
@ -573,28 +374,25 @@ impl ResourceDef {
fn parse( fn parse(
mut pattern: &str, mut pattern: &str,
mut for_prefix: bool, mut for_prefix: bool,
) -> (String, Vec<PatternElement>, bool, usize) { force_dynamic: bool,
if pattern.find('{').is_none() { ) -> (PatternType, Vec<PatternElement>) {
return if let Some(path) = pattern.strip_suffix('*') { if !force_dynamic && pattern.find('{').is_none() && !pattern.ends_with('*') {
let re = format!("{}^{}(.*)", REGEX_FLAGS, path); let tp = if for_prefix {
(re, vec![PatternElement::Str(String::from(path))], true, 0) PatternType::Prefix(String::from(pattern))
} else { } else {
( PatternType::Static(String::from(pattern))
String::from(pattern),
vec![PatternElement::Str(String::from(pattern))],
false,
pattern.chars().count(),
)
}; };
return (tp, vec![PatternElement::Const(String::from(pattern))]);
} }
let pattern_orig = pattern;
let mut elements = Vec::new(); let mut elements = Vec::new();
let mut re = format!("{}^", REGEX_FLAGS); let mut re = format!("{}^", REGEX_FLAGS);
let mut dyn_elements = 0; let mut dyn_elements = 0;
while let Some(idx) = pattern.find('{') { while let Some(idx) = pattern.find('{') {
let (prefix, rem) = pattern.split_at(idx); let (prefix, rem) = pattern.split_at(idx);
elements.push(PatternElement::Str(String::from(prefix))); elements.push(PatternElement::Const(String::from(prefix)));
re.push_str(&escape(prefix)); re.push_str(&escape(prefix));
let (param_pattern, re_part, rem, tail) = Self::parse_param(rem); let (param_pattern, re_part, rem, tail) = Self::parse_param(rem);
if tail { if tail {
@ -607,7 +405,14 @@ impl ResourceDef {
dyn_elements += 1; dyn_elements += 1;
} }
elements.push(PatternElement::Str(String::from(pattern))); if let Some(path) = pattern.strip_suffix('*') {
elements.push(PatternElement::Const(String::from(path)));
re.push_str(&escape(path));
re.push_str("(.*)");
pattern = "";
}
elements.push(PatternElement::Const(String::from(pattern)));
re.push_str(&escape(pattern)); re.push_str(&escape(pattern));
if dyn_elements > MAX_DYNAMIC_SEGMENTS { if dyn_elements > MAX_DYNAMIC_SEGMENTS {
@ -620,7 +425,18 @@ impl ResourceDef {
if !for_prefix { if !for_prefix {
re.push('$'); 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), elements)
} }
} }
@ -674,6 +490,10 @@ mod tests {
assert!(!re.is_match("/name/")); assert!(!re.is_match("/name/"));
assert!(!re.is_match("/name~")); assert!(!re.is_match("/name~"));
let mut path = Path::new("/name");
assert!(re.match_path(&mut path));
assert_eq!(path.unprocessed(), "");
assert_eq!(re.is_prefix_match("/name"), Some(5)); assert_eq!(re.is_prefix_match("/name"), Some(5));
assert_eq!(re.is_prefix_match("/name1"), None); assert_eq!(re.is_prefix_match("/name1"), None);
assert_eq!(re.is_prefix_match("/name/"), None); assert_eq!(re.is_prefix_match("/name/"), None);
@ -687,6 +507,10 @@ mod tests {
let re = ResourceDef::new("/user/profile"); let re = ResourceDef::new("/user/profile");
assert!(re.is_match("/user/profile")); assert!(re.is_match("/user/profile"));
assert!(!re.is_match("/user/profile/profile")); assert!(!re.is_match("/user/profile/profile"));
let mut path = Path::new("/user/profile");
assert!(re.match_path(&mut path));
assert_eq!(path.unprocessed(), "");
} }
#[test] #[test]
@ -700,10 +524,12 @@ mod tests {
let mut path = Path::new("/user/profile"); let mut path = Path::new("/user/profile");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "profile"); assert_eq!(path.get("id").unwrap(), "profile");
assert_eq!(path.unprocessed(), "");
let mut path = Path::new("/user/1245125"); let mut path = Path::new("/user/1245125");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "1245125"); assert_eq!(path.get("id").unwrap(), "1245125");
assert_eq!(path.unprocessed(), "");
let re = ResourceDef::new("/v{version}/resource/{id}"); let re = ResourceDef::new("/v{version}/resource/{id}");
assert!(re.is_match("/v1/resource/320120")); assert!(re.is_match("/v1/resource/320120"));
@ -714,6 +540,7 @@ mod tests {
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("version").unwrap(), "151"); assert_eq!(path.get("version").unwrap(), "151");
assert_eq!(path.get("id").unwrap(), "adage32"); assert_eq!(path.get("id").unwrap(), "adage32");
assert_eq!(path.unprocessed(), "");
let re = ResourceDef::new("/{id:[[:digit:]]{6}}"); let re = ResourceDef::new("/{id:[[:digit:]]{6}}");
assert!(re.is_match("/012345")); assert!(re.is_match("/012345"));
@ -724,6 +551,7 @@ mod tests {
let mut path = Path::new("/012345"); let mut path = Path::new("/012345");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "012345"); assert_eq!(path.get("id").unwrap(), "012345");
assert_eq!(path.unprocessed(), "");
} }
#[allow(clippy::cognitive_complexity)] #[allow(clippy::cognitive_complexity)]
@ -733,6 +561,7 @@ mod tests {
"/user/{id}", "/user/{id}",
"/v{version}/resource/{id}", "/v{version}/resource/{id}",
"/{id:[[:digit:]]{6}}", "/{id:[[:digit:]]{6}}",
"/static",
]); ]);
assert!(re.is_match("/user/profile")); assert!(re.is_match("/user/profile"));
assert!(re.is_match("/user/2345")); assert!(re.is_match("/user/2345"));
@ -742,10 +571,12 @@ mod tests {
let mut path = Path::new("/user/profile"); let mut path = Path::new("/user/profile");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "profile"); assert_eq!(path.get("id").unwrap(), "profile");
assert_eq!(path.unprocessed(), "");
let mut path = Path::new("/user/1245125"); let mut path = Path::new("/user/1245125");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "1245125"); assert_eq!(path.get("id").unwrap(), "1245125");
assert_eq!(path.unprocessed(), "");
assert!(re.is_match("/v1/resource/320120")); assert!(re.is_match("/v1/resource/320120"));
assert!(!re.is_match("/v/resource/1")); assert!(!re.is_match("/v/resource/1"));
@ -761,6 +592,10 @@ mod tests {
assert!(!re.is_match("/01234567")); assert!(!re.is_match("/01234567"));
assert!(!re.is_match("/XXXXXX")); assert!(!re.is_match("/XXXXXX"));
assert!(re.is_match("/static"));
assert!(!re.is_match("/a/static"));
assert!(!re.is_match("/static/a"));
let mut path = Path::new("/012345"); let mut path = Path::new("/012345");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "012345"); assert_eq!(path.get("id").unwrap(), "012345");
@ -820,6 +655,12 @@ mod tests {
assert!(re.is_match("/user/2345")); assert!(re.is_match("/user/2345"));
assert!(re.is_match("/user/2345/")); assert!(re.is_match("/user/2345/"));
assert!(re.is_match("/user/2345/sdg")); assert!(re.is_match("/user/2345/sdg"));
let re = ResourceDef::new("/user/{id}/*");
assert!(!re.is_match("/user/2345"));
let mut path = Path::new("/user/2345/sdg");
assert!(re.match_path(&mut path));
assert_eq!(path.get("id").unwrap(), "2345");
} }
#[test] #[test]
@ -878,6 +719,14 @@ mod tests {
assert!(re.is_match("/name1")); assert!(re.is_match("/name1"));
assert!(re.is_match("/name~")); assert!(re.is_match("/name~"));
let mut path = Path::new("/name");
assert!(re.match_path(&mut path));
assert_eq!(path.unprocessed(), "");
let mut path = Path::new("/name/test");
assert!(re.match_path(&mut path));
assert_eq!(path.unprocessed(), "/test");
assert_eq!(re.is_prefix_match("/name"), Some(5)); assert_eq!(re.is_prefix_match("/name"), Some(5));
assert_eq!(re.is_prefix_match("/name/"), Some(5)); assert_eq!(re.is_prefix_match("/name/"), Some(5));
assert_eq!(re.is_prefix_match("/name/test/test"), Some(5)); assert_eq!(re.is_prefix_match("/name/test/test"), Some(5));
@ -893,6 +742,10 @@ mod tests {
assert!(re.is_match("/name/")); assert!(re.is_match("/name/"));
assert!(re.is_match("/name/gs")); assert!(re.is_match("/name/gs"));
assert!(!re.is_match("/name")); assert!(!re.is_match("/name"));
let mut path = Path::new("/name/gs");
assert!(re.match_path(&mut path));
assert_eq!(path.unprocessed(), "/gs");
} }
#[test] #[test]
@ -910,11 +763,13 @@ mod tests {
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(&path["name"], "test2"); assert_eq!(&path["name"], "test2");
assert_eq!(&path[0], "test2"); assert_eq!(&path[0], "test2");
assert_eq!(path.unprocessed(), "");
let mut path = Path::new("/test2/subpath1/subpath2/index.html"); let mut path = Path::new("/test2/subpath1/subpath2/index.html");
assert!(re.match_path(&mut path)); assert!(re.match_path(&mut path));
assert_eq!(&path["name"], "test2"); assert_eq!(&path["name"], "test2");
assert_eq!(&path[0], "test2"); assert_eq!(&path[0], "test2");
assert_eq!(path.unprocessed(), "subpath1/subpath2/index.html");
} }
#[test] #[test]

2
actix-rt/CHANGES.md
View File

@ -8,7 +8,7 @@
`Ready` object in ok variant. [#293] `Ready` object in ok variant. [#293]
* Breakage is acceptable since `ActixStream` was not intended to be public. * Breakage is acceptable since `ActixStream` was not intended to be public.
[#293] https://github.com/actix/actix-net/pull/293 [#293]: https://github.com/actix/actix-net/pull/293
## 2.1.0 - 2021-02-24 ## 2.1.0 - 2021-02-24