Handle updating the hostname when the first path segment is empty

Author: theskim

url/src/lib.rs

@@ -246,6 +246,7 @@ pub struct Url {
     path_start: u32,             // Before initial '/', if any
     query_start: Option<u32>,    // Before '?', unlike Position::QueryStart
     fragment_start: Option<u32>, // Before '#', unlike Position::FragmentStart
+    empty_first_segment: bool,
 }
 
 /// Full configuration for the URL parser.
@@ -2124,12 +2125,25 @@ impl Url {
 
     /// opt_new_port: None means leave unchanged, Some(None) means remove any port number.
     fn set_host_internal(&mut self, host: Host<String>, opt_new_port: Option<Option<u16>>) {
+        // Check if the first segment is empty and there are at least two segments
+        // Update self.empty_first_segment flag since the hostname overwrites the blank segment
+        if self
+            .path_segments()
+            .map(|mut segments| {
+                let empty_first_segment = segments.next().map_or(false, |first| first.is_empty());
+                empty_first_segment && segments.next().is_some()
+            })
+            .unwrap_or(false)
+        {
+            self.empty_first_segment = true;
+        }
+
         let old_suffix_pos = if opt_new_port.is_some() {
             self.path_start
         } else {
             self.host_end
         };
-        let suffix = self.slice(old_suffix_pos..).to_owned();
+        let mut suffix = self.slice(old_suffix_pos..).to_owned();
         self.serialization.truncate(self.host_start as usize);
         if !self.has_authority() {
             debug_assert!(self.slice(self.scheme_end..self.host_start) == ":");
@@ -2143,6 +2157,23 @@ impl Url {
         self.host_end = to_u32(self.serialization.len()).unwrap();
         self.host = host.into();
 
+        // Adjust serialization to switch between host and empty segment
+        if self.empty_first_segment {
+            if suffix.starts_with("/.//") {
+                suffix = suffix["/.".len()..].to_string();
+            } else if self.host == HostInternal::None && suffix.starts_with("/") {
+                if let Some(index) = self.serialization.find(":") {
+                    if self.serialization.len() == index + "://".len()
+                        && self.serialization.as_bytes().get(index + 1) == Some(&b'/')
+                        && self.serialization.as_bytes().get(index + 2) == Some(&b'/')
+                    {
+                        self.serialization
+                            .replace_range(index..index + "://".len(), ":/.");
+                    }
+                }
+            }
+        }
+
         if let Some(new_port) = opt_new_port {
             self.port = new_port;
             if let Some(port) = new_port {
@@ -2157,6 +2188,10 @@ impl Url {
             *index += new_suffix_pos;
         };
         adjust(&mut self.path_start);
+        // pathname should be "//p" not "p" given that the first segment was empty
+        if self.empty_first_segment {
+            self.path_start -= "//".len() as u32;
+        }
         if let Some(ref mut index) = self.query_start {
             adjust(index)
         }
@@ -2605,6 +2640,7 @@ impl Url {
             path_start: host_end,
             query_start: None,
             fragment_start: None,
+            empty_first_segment: false,
         })
     }
 

url/src/parser.rs

@@ -554,6 +554,7 @@ impl<'a> Parser<'a> {
                     path_start: host_end,
                     query_start,
                     fragment_start,
+                    empty_first_segment: false,
                 });
             } else {
                 self.serialization.push_str("file://");
@@ -605,6 +606,7 @@ impl<'a> Parser<'a> {
                     path_start: host_end,
                     query_start,
                     fragment_start,
+                    empty_first_segment: false,
                 });
             }
         }
@@ -685,6 +687,7 @@ impl<'a> Parser<'a> {
                             path_start,
                             query_start,
                             fragment_start,
+                            empty_first_segment: false,
                         })
                     }
                 }
@@ -708,6 +711,7 @@ impl<'a> Parser<'a> {
                 path_start,
                 query_start,
                 fragment_start,
+                empty_first_segment: false,
             })
         }
     }
@@ -1436,6 +1440,7 @@ impl<'a> Parser<'a> {
             path_start,
             query_start,
             fragment_start,
+            empty_first_segment: false,
         })
     }
 

url/tests/expected_failures.txt

@@ -36,8 +36,6 @@
 <file:/.//p>
 <http://example.net/path> set hostname to <example.com:8080>
 <http://example.net:8080/path> set hostname to <example.com:>
-<non-spec:/.//p> set hostname to <h>
-<non-spec:/.//p> set hostname to <>
 <foo:///some/path> set pathname to <>
 <file:///var/log/system.log> set href to <http://0300.168.0xF0>
 <file://monkey/> set pathname to <\\\\>

url/tests/unit.rs

@@ -1382,6 +1382,7 @@ fn serde_error_message() {
 
 #[test]
 fn test_can_be_a_base_with_set_path() {
+    use url::quirks;
     let mut url = Url::parse("web+demo:/").unwrap();
     assert!(!url.cannot_be_a_base());
 
@@ -1396,6 +1397,10 @@ fn test_can_be_a_base_with_set_path() {
     assert_eq!(segments, vec!["", "not-a-host"]);
 
     assert_eq!(url.as_str(), "web+demo:/.//not-a-host");
+    quirks::set_hostname(&mut url, "test").unwrap();
+    assert_eq!(url.as_str(), "web+demo://test//not-a-host");
+    quirks::set_hostname(&mut url, "").unwrap();
+    assert_eq!(url.as_str(), "web+demo:/.//not-a-host");
 }
 
 #[test]