Add path_segments to PathAndSegments

src/uri/path.rs

@@ -1,11 +1,11 @@
-use std::{cmp, fmt, str};
 use std::str::FromStr;
+use std::{cmp, fmt, str};
 
 use bytes::Bytes;
 
+use super::{ErrorKind, InvalidUri, InvalidUriBytes, URI_CHARS};
 use byte_str::ByteStr;
 use convert::HttpTryFrom;
-use super::{ErrorKind, InvalidUri, InvalidUriBytes, URI_CHARS};
 
 /// Represents the path component of a URI
 #[derive(Clone)]
@@ -56,10 +56,7 @@ impl PathAndQuery {
                     //
                     // Allowed: 0x21 / 0x24 - 0x3B / 0x3D / 0x3F - 0x7E
                     match b {
-                        0x21 |
-                        0x24...0x3B |
-                        0x3D |
-                        0x3F...0x7E => {},
+                        0x21 | 0x24...0x3B | 0x3D | 0x3F...0x7E => {}
                         _ => return Err(ErrorKind::InvalidUriChar.into()),
                     }
                 }
@@ -108,8 +105,7 @@ impl PathAndQuery {
     pub fn from_static(src: &'static str) -> Self {
         let src = Bytes::from_static(src.as_bytes());
 
-        PathAndQuery::from_shared(src)
-            .unwrap()
+        PathAndQuery::from_shared(src).unwrap()
     }
 
     pub(super) fn empty() -> Self {
@@ -169,6 +165,27 @@ impl PathAndQuery {
 
         ret
     }
+    /// Returs the segments of path component
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::uri::*;
+    ///
+    /// let path_and_query: PathAndQuery = "/hello/world".parse().unwrap();
+    ///
+    /// assert!(path_and_query.path_segments().is_some());
+    /// assert_eq!(path_and_query.path_segments().unwrap().collect::<Vec<_>>(), vec!["hello",
+    /// "world"])
+    /// ```
+    pub fn path_segments(&self) -> Option<str::Split<char>> {
+        let path = self.path();
+        if path.starts_with('/') {
+            Some(path[1..].split('/'))
+        } else {
+            None
+        }
+    }
 
     /// Returns the query string component
     ///

src/uri/tests.rs

@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use super::{ErrorKind, InvalidUri, Uri, URI_CHARS, Port};
+use super::{ErrorKind, InvalidUri, Port, Uri, URI_CHARS};
 
 #[test]
 fn test_char_table() {
@@ -12,9 +12,9 @@ fn test_char_table() {
 }
 
 macro_rules! part {
-    ($s:expr) => (
+    ($s:expr) => {
         Some(&$s.parse().unwrap())
-    )
+    };
 }
 
 macro_rules! test_parse {
@@ -138,7 +138,6 @@ test_parse! {
     port_part = Port::from_str("3000").ok(),
 }
 
-
 test_parse! {
     test_uri_parse_absolute_with_default_port_http,
     "http://127.0.0.1:80",
@@ -377,6 +376,24 @@ test_parse! {
     query = Some("foo={bar|baz}\\^`"),
 }
 
+#[test]
+fn test_uri_parse_segments() {
+    use super::*;
+    let path: PathAndQuery = "/foo/bar/baz".parse().unwrap();
+    assert!(path.path_segments().is_some());
+    assert_eq!(
+        path.path_segments().unwrap().collect::<Vec<_>>(),
+        vec!["foo", "bar", "baz"]
+    );
+
+    let path: PathAndQuery = "/foo/bar/baz/".parse().unwrap();
+    assert!(path.path_segments().is_some());
+    assert_eq!(
+        path.path_segments().unwrap().collect::<Vec<_>>(),
+        vec!["foo", "bar", "baz", ""]
+    );
+}
+
 #[test]
 fn test_uri_parse_error() {
     fn err(s: &str) {