Fix clippy lint and formatting issues

Co-authored-by: Byron <63622+Byron@users.noreply.github.com>

Author: Copilot

gix-url/src/parse.rs

@@ -285,9 +285,7 @@ fn input_to_utf8_and_url(input: &BStr, kind: UrlKind) -> Result<(&str, crate::si
             // If the parser rejected it as RelativeUrlWithoutBase, map to Error::RelativeUrl
             // to match the expected error type for malformed URLs like "invalid:://"
             match source {
-                crate::simple_url::ParseError::RelativeUrlWithoutBase => Error::RelativeUrl {
-                    url: input.to_owned(),
-                },
+                crate::simple_url::ParseError::RelativeUrlWithoutBase => Error::RelativeUrl { url: input.to_owned() },
                 _ => Error::Url {
                     url: input.to_owned(),
                     kind,

gix-url/src/simple_url.rs

@@ -32,30 +32,28 @@ impl<'a> ParsedUrl<'a> {
     /// Expected format: scheme://[user[:password]@]host[:port]/path
     pub(crate) fn parse(input: &'a str) -> Result<Self, ParseError> {
         // Find scheme by looking for first ':'
-        let first_colon = input
-            .find(':')
-            .ok_or(ParseError::RelativeUrlWithoutBase)?;
-        
+        let first_colon = input.find(':').ok_or(ParseError::RelativeUrlWithoutBase)?;
+
         let scheme = &input[..first_colon];
-        
+
         // Verify it's followed by "//"
         if !input[first_colon..].starts_with("://") {
             return Err(ParseError::RelativeUrlWithoutBase);
         }
-        
+
         // Start after "://"
         let after_scheme = &input[first_colon + 3..];
-        
+
         // Check for relative URL (scheme without proper authority)
         if scheme.is_empty() {
             return Err(ParseError::RelativeUrlWithoutBase);
         }
-        
+
         // Validate scheme characters
         if !scheme.chars().all(is_valid_scheme_char) {
             return Err(ParseError::RelativeUrlWithoutBase);
         }
-        
+
         // Find path start (first '/' after scheme)
         let path_start = after_scheme.find('/').unwrap_or(after_scheme.len());
         let authority = &after_scheme[..path_start];
@@ -65,34 +63,30 @@ impl<'a> ParsedUrl<'a> {
             // No path specified - leave empty (caller can default to / if needed)
             ""
         };
-        
+
         // Parse authority: [user[:password]@]host[:port]
         let (username, password, host, port) = if let Some(at_pos) = authority.rfind('@') {
             // Has user info
             let user_info = &authority[..at_pos];
             let host_port = &authority[at_pos + 1..];
-            
+
             let (user, pass) = if let Some(colon_pos) = user_info.find(':') {
                 let pass_str = &user_info[colon_pos + 1..];
                 // Treat empty password as None
-                let pass = if pass_str.is_empty() {
-                    None
-                } else {
-                    Some(pass_str)
-                };
+                let pass = if pass_str.is_empty() { None } else { Some(pass_str) };
                 (&user_info[..colon_pos], pass)
             } else {
                 (user_info, None)
             };
-            
+
             let (h, p) = Self::parse_host_port(host_port)?;
             (user, pass, h, p)
         } else {
             // No user info
             let (h, p) = Self::parse_host_port(authority)?;
             ("", None, h, p)
         };
-        
+
         Ok(ParsedUrl {
             scheme,
             username,
@@ -102,25 +96,22 @@ impl<'a> ParsedUrl<'a> {
             path,
         })
     }
-    
+
     fn parse_host_port(host_port: &str) -> Result<(Option<&str>, Option<u16>), ParseError> {
         if host_port.is_empty() {
             return Ok((None, None));
         }
-        
+
         // Handle IPv6 addresses: [::1] or [::1]:port
         if host_port.starts_with('[') {
             if let Some(bracket_end) = host_port.find(']') {
                 let host = Some(&host_port[..bracket_end + 1]);
                 let remaining = &host_port[bracket_end + 1..];
-                
+
                 if remaining.is_empty() {
                     return Ok((host, None));
-                } else if remaining.starts_with(':') {
-                    let port_str = &remaining[1..];
-                    let port = port_str
-                        .parse::<u16>()
-                        .map_err(|_| ParseError::InvalidPort)?;
+                } else if let Some(port_str) = remaining.strip_prefix(':') {
+                    let port = port_str.parse::<u16>().map_err(|_| ParseError::InvalidPort)?;
                     // Validate port is in valid range (1-65535, port 0 is invalid)
                     if port == 0 {
                         return Err(ParseError::InvalidPort);
@@ -133,7 +124,7 @@ impl<'a> ParsedUrl<'a> {
                 return Err(ParseError::InvalidDomainCharacter);
             }
         }
-        
+
         // Handle regular host:port
         // Use rfind to handle IPv6 addresses without brackets (edge case)
         if let Some(colon_pos) = host_port.rfind(':') {
@@ -145,45 +136,43 @@ impl<'a> ParsedUrl<'a> {
                 return Ok((Some(host), None));
             } else if potential_port.chars().all(|c| c.is_ascii_digit()) {
                 let host = &host_port[..colon_pos];
-                let port = potential_port
-                    .parse::<u16>()
-                    .map_err(|_| ParseError::InvalidPort)?;
+                let port = potential_port.parse::<u16>().map_err(|_| ParseError::InvalidPort)?;
                 // Validate port is in valid range (1-65535, port 0 is invalid)
                 if port == 0 {
                     return Err(ParseError::InvalidPort);
                 }
                 return Ok((Some(host), Some(port)));
             }
         }
-        
+
         // No port, just host
         Ok((Some(host_port), None))
     }
-    
+
     pub(crate) fn scheme(&self) -> &str {
         self.scheme
     }
-    
+
     pub(crate) fn username(&self) -> &str {
         self.username
     }
-    
+
     pub(crate) fn password(&self) -> Option<&str> {
         self.password
     }
-    
+
     pub(crate) fn host_str(&self) -> Option<&str> {
         self.host
     }
-    
+
     pub(crate) fn port(&self) -> Option<u16> {
         self.port
     }
-    
+
     pub(crate) fn path(&self) -> &str {
         self.path
     }
-    
+
     /// Check if this URL cannot be a base (is relative).
     /// For our purposes, since we only parse URLs with "://", they can all be a base.
     pub(crate) fn cannot_be_a_base(&self) -> bool {