make all baseline tests pass

Done by Sonnet 4.5

Author: Byron

gix-url/src/lib.rs

@@ -380,6 +380,9 @@ impl Url {
 
         out.write_all(self.scheme.as_str().as_bytes())?;
         out.write_all(b"://")?;
+
+        let needs_brackets = self.port.is_some() && self.host.as_ref().is_some_and(|h| Self::is_ipv6(h));
+
         match (&self.user, &self.host) {
             (Some(user), Some(host)) => {
                 out.write_all(percent_encode(user).as_bytes())?;
@@ -388,10 +391,22 @@ impl Url {
                     out.write_all(percent_encode(password).as_bytes())?;
                 }
                 out.write_all(b"@")?;
+                if needs_brackets {
+                    out.write_all(b"[")?;
+                }
                 out.write_all(host.as_bytes())?;
+                if needs_brackets {
+                    out.write_all(b"]")?;
+                }
             }
             (None, Some(host)) => {
+                if needs_brackets {
+                    out.write_all(b"[")?;
+                }
                 out.write_all(host.as_bytes())?;
+                if needs_brackets {
+                    out.write_all(b"]")?;
+                }
             }
             (None, None) => {}
             (Some(_user), None) => {
@@ -403,11 +418,22 @@ impl Url {
         if let Some(port) = &self.port {
             write!(out, ":{port}")?;
         }
+        // For SSH and Git URLs, add leading '/' if path doesn't start with '/'
+        // This handles paths like "~repo" which serialize as "/~repo" in URL form
+        if matches!(self.scheme, Scheme::Ssh | Scheme::Git) && !self.path.starts_with(b"/") {
+            out.write_all(b"/")?;
+        }
         out.write_all(&self.path)?;
         Ok(())
     }
 
+    fn is_ipv6(host: &str) -> bool {
+        host.contains(':') && !host.starts_with('[')
+    }
+
     fn write_alternative_form_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
+        let needs_brackets = self.host.as_ref().is_some_and(|h| Self::is_ipv6(h));
+
         match (&self.user, &self.host) {
             (Some(user), Some(host)) => {
                 out.write_all(user.as_bytes())?;
@@ -416,10 +442,22 @@ impl Url {
                     "BUG: cannot serialize password in alternative form"
                 );
                 out.write_all(b"@")?;
+                if needs_brackets {
+                    out.write_all(b"[")?;
+                }
                 out.write_all(host.as_bytes())?;
+                if needs_brackets {
+                    out.write_all(b"]")?;
+                }
             }
             (None, Some(host)) => {
+                if needs_brackets {
+                    out.write_all(b"[")?;
+                }
                 out.write_all(host.as_bytes())?;
+                if needs_brackets {
+                    out.write_all(b"]")?;
+                }
             }
             (None, None) => {}
             (Some(_user), None) => {

gix-url/src/parse.rs

@@ -70,7 +70,23 @@ pub(crate) fn find_scheme(input: &BStr) -> InputScheme {
         return InputScheme::Url { protocol_end };
     }
 
-    if let Some(colon) = input.find_byte(b':') {
+    // Find colon, but skip over IPv6 brackets if present
+    let colon = if input.starts_with(b"[") {
+        // IPv6 address, find the closing bracket first
+        if let Some(bracket_end) = input.find_byte(b']') {
+            // Look for colon after the bracket
+            input[bracket_end + 1..]
+                .find_byte(b':')
+                .map(|pos| bracket_end + 1 + pos)
+        } else {
+            // No closing bracket, treat as regular search
+            input.find_byte(b':')
+        }
+    } else {
+        input.find_byte(b':')
+    };
+
+    if let Some(colon) = colon {
         // allow user to select files containing a `:` by passing them as absolute or relative path
         // this is behavior explicitly mentioned by the scp and git manuals
         let explicitly_local = &input[..colon].contains(&b'/');
@@ -111,20 +127,57 @@ pub(crate) fn url(input: &BStr, protocol_end: usize) -> Result<crate::Url, Error
     // Normalize empty path to "/" for http/https URLs only
     let path = if url.path.is_empty() && matches!(scheme, Scheme::Http | Scheme::Https) {
         "/".into()
+    } else if matches!(scheme, Scheme::Ssh | Scheme::Git) && url.path.starts_with("/~") {
+        // For SSH and Git protocols, strip leading '/' from paths starting with '~'
+        // e.g., "ssh://host/~repo" -> path is "~repo", not "/~repo"
+        url.path[1..].into()
     } else {
         url.path.into()
     };
 
+    let user = url_user(&url, UrlKind::Url)?;
+    let password = url
+        .password
+        .map(|s| percent_decoded_utf8(s, UrlKind::Url))
+        .transpose()?;
+    let port = url.port;
+
+    // For SSH URLs, strip brackets from IPv6 addresses
+    let host = if scheme == Scheme::Ssh {
+        url.host.map(|mut h| {
+            // Check if we have bracketed IPv6 with trailing colon: "[::1]:"
+            if h.starts_with('[') {
+                if h.ends_with("]:") {
+                    // "[::1]:" -> "::1"  (strip brackets and colon)
+                    h = h[1..h.len() - 2].to_string();
+                } else if h.ends_with(']') {
+                    // "[::1]" -> "::1"  (just strip brackets)
+                    h = h[1..h.len() - 1].to_string();
+                }
+            } else {
+                // For non-bracketed hosts, only strip trailing colon if it's not part of IPv6
+                // Count colons: if there's only one colon and it's at the end, strip it
+                // Otherwise (multiple colons or colon not at end), keep it
+                let colon_count = h.chars().filter(|&c| c == ':').count();
+                if colon_count == 1 && h.ends_with(':') {
+                    // Regular host with empty port "host:" -> "host"
+                    h = h[..h.len() - 1].to_string();
+                }
+                // For bare IPv6 with trailing colon "::1:", keep it as is (colon_count > 1)
+            }
+            h
+        })
+    } else {
+        url.host
+    };
+
     Ok(crate::Url {
         serialize_alternative_form: false,
         scheme,
-        user: url_user(&url, UrlKind::Url)?,
-        password: url
-            .password
-            .map(|s| percent_decoded_utf8(s, UrlKind::Url))
-            .transpose()?,
-        host: url.host,
-        port: url.port,
+        user,
+        password,
+        host,
+        port,
         path,
     })
 }
@@ -166,16 +219,33 @@ pub(crate) fn scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
         source,
     })?;
 
+    // For SCP-like SSH URLs, strip leading '/' from paths starting with '/~'
+    // e.g., "user@host:/~repo" -> path is "~repo", not "/~repo"
+    let path = if path.starts_with("/~") { &path[1..] } else { path };
+
+    let user = url_user(&url, UrlKind::Scp)?;
+    let password = url
+        .password
+        .map(|s| percent_decoded_utf8(s, UrlKind::Scp))
+        .transpose()?;
+    let port = url.port;
+
+    // For SCP-like SSH URLs, strip brackets from IPv6 addresses
+    let host = url.host.map(|h| {
+        if h.starts_with('[') && h.ends_with(']') {
+            h[1..h.len() - 1].to_string()
+        } else {
+            h
+        }
+    });
+
     Ok(crate::Url {
         serialize_alternative_form: true,
         scheme: Scheme::from(url.scheme.as_str()),
-        user: url_user(&url, UrlKind::Scp)?,
-        password: url
-            .password
-            .map(|s| percent_decoded_utf8(s, UrlKind::Scp))
-            .transpose()?,
-        host: url.host,
-        port: url.port,
+        user,
+        password,
+        host,
+        port,
         path: path.into(),
     })
 }

gix-url/src/simple_url.rs

@@ -115,18 +115,25 @@ impl<'a> ParsedUrl<'a> {
         // Handle IPv6 addresses: [::1] or [::1]:port
         if host_port.starts_with('[') {
             if let Some(bracket_end) = host_port.find(']') {
-                // IPv6 addresses are case-insensitive, normalize to lowercase
-                let host = Some(host_port[..=bracket_end].to_ascii_lowercase());
                 let remaining = &host_port[bracket_end + 1..];
 
                 if remaining.is_empty() {
+                    // IPv6 addresses are case-insensitive, normalize to lowercase
+                    let host = Some(host_port[..=bracket_end].to_ascii_lowercase());
                     return Ok((host, None));
                 } else if let Some(port_str) = remaining.strip_prefix(':') {
+                    if port_str.is_empty() {
+                        // Empty port like "[::1]:" - preserve the trailing colon for Git compatibility
+                        let host = Some(host_port.to_ascii_lowercase());
+                        return Ok((host, None));
+                    }
                     let port = port_str.parse::<u16>().map_err(|_| UrlParseError::InvalidPort)?;
                     // Validate port is in valid range (1-65535, port 0 is invalid)
                     if port == 0 {
                         return Err(UrlParseError::InvalidPort);
                     }
+                    // IPv6 addresses are case-insensitive, normalize to lowercase
+                    let host = Some(host_port[..=bracket_end].to_ascii_lowercase());
                     return Ok((host, Some(port)));
                 } else {
                     return Err(UrlParseError::InvalidDomainCharacter);
@@ -137,27 +144,41 @@ impl<'a> ParsedUrl<'a> {
         }
 
         // Handle regular host:port
-        // Use rfind to handle IPv6 addresses without brackets (edge case)
+        // Use rfind to find the last colon
         if let Some(colon_pos) = host_port.rfind(':') {
+            let before_last_colon = &host_port[..colon_pos];
+            let after_last_colon = &host_port[colon_pos + 1..];
+
             // Check if this looks like a port (all digits after colon)
-            let potential_port = &host_port[colon_pos + 1..];
-            if potential_port.is_empty() {
-                // Empty port like "host:" - strip the trailing colon
-                let host_str = &host_port[..colon_pos];
-                return Ok((Some(Self::normalize_hostname(host_str)?), None));
-            } else if potential_port.chars().all(|c| c.is_ascii_digit()) {
-                let host_str = &host_port[..colon_pos];
-                let host = Self::normalize_hostname(host_str)?;
-                let port = potential_port.parse::<u16>().map_err(|_| UrlParseError::InvalidPort)?;
-                // Validate port is in valid range (1-65535, port 0 is invalid)
-                if port == 0 {
-                    return Err(UrlParseError::InvalidPort);
+            // But avoid treating IPv6 addresses as host:port
+            // IPv6 addresses have colons in the part before the last colon (e.g., "::1" has "::" before the last ":")
+            let has_colon_before_last = before_last_colon.contains(':');
+            let is_all_digits_after =
+                !after_last_colon.is_empty() && after_last_colon.chars().all(|c| c.is_ascii_digit());
+
+            // Treat as port separator only if:
+            // 1. There's no colon before the last colon (normal host:port)
+            // 2. OR it's explicitly empty (host: with trailing colon)
+            if !has_colon_before_last {
+                if after_last_colon.is_empty() {
+                    // Empty port like "host:" - store host with trailing colon
+                    // This is needed for Git compatibility where "host:" != "host"
+                    return Ok((Some(Self::normalize_hostname(host_port)?), None));
+                } else if is_all_digits_after {
+                    let host = Self::normalize_hostname(before_last_colon)?;
+                    let port = after_last_colon
+                        .parse::<u16>()
+                        .map_err(|_| UrlParseError::InvalidPort)?;
+                    // Validate port is in valid range (1-65535, port 0 is invalid)
+                    if port == 0 {
+                        return Err(UrlParseError::InvalidPort);
+                    }
+                    return Ok((Some(host), Some(port)));
                 }
-                return Ok((Some(host), Some(port)));
             }
         }
 
-        // No port, just host
+        // No port, just host (including bare IPv6 addresses)
         Ok((Some(Self::normalize_hostname(host_port)?), None))
     }