fix(uri): allow empty paths in uri::Builder

Author: seanmonstar

src/error.rs

@@ -47,6 +47,13 @@ impl fmt::Display for Error {
 }
 
 impl Error {
+    pub(crate) fn is_empty_uri(&self) -> bool {
+        match self.inner {
+            ErrorKind::Uri(ref err) => err.is_empty(),
+            _ => false,
+        }
+    }
+
     /// Return true if the underlying error has the same type as T.
     pub fn is<T: error::Error + 'static>(&self) -> bool {
         self.get_ref().is::<T>()

src/uri/builder.rs

@@ -96,7 +96,17 @@ impl Builder {
         <T as TryInto<PathAndQuery>>::Error: Into<crate::Error>,
     {
         self.map(move |mut parts| {
-            let p_and_q = p_and_q.try_into().map_err(Into::into)?;
+            let p_and_q = match p_and_q.try_into() {
+                Ok(p_and_q) => p_and_q,
+                Err(err) => {
+                    let err = err.into();
+                    if err.is_empty_uri() {
+                        PathAndQuery::empty()
+                    } else {
+                        return Err(err);
+                    }
+                }
+            };
             parts.path_and_query = Some(p_and_q);
             Ok(parts)
         })
@@ -202,6 +212,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn build_from_empty_path_and_query() {
+        let uri = Builder::new()
+            .scheme(Scheme::HTTP)
+            .authority("localhost:8080")
+            .path_and_query("")
+            .build()
+            .unwrap();
+
+        assert_eq!(uri, "http://localhost:8080");
+        assert_eq!(uri.path(), "/");
+    }
+
+    #[test]
+    fn empty_path_and_query_remains_strict() {
+        assert!(PathAndQuery::try_from("").is_err());
+    }
+
+    #[test]
+    fn authority_form_path_and_query_remains_strict() {
+        assert!(Builder::new()
+            .path_and_query("localhost:8080")
+            .build()
+            .is_err());
+    }
+
     #[test]
     fn build_from_uri() {
         let original_uri = Uri::default();

src/uri/mod.rs

@@ -1068,6 +1068,10 @@ impl From<ErrorKind> for InvalidUriParts {
 }
 
 impl InvalidUri {
+    pub(crate) fn is_empty(&self) -> bool {
+        self.0 == ErrorKind::Empty
+    }
+
     fn s(&self) -> &str {
         match self.0 {
             ErrorKind::InvalidUriChar => "invalid uri character",