chore: fix clippy warnings

fraidev · fraidev · commit 2bb1fd73a341 · 2025-08-31T14:33:51.000-03:00
diff --git a/crates/bit_rev/src/peer_connection.rs b/crates/bit_rev/src/peer_connection.rs
@@ -395,16 +395,16 @@ impl PeerHandler {
                 debug!("peer sent bitfield");
                 let p_state = self.peers_state.states.get_mut(&self.peer);
 
-                if p_state.is_none() {
+                if let Some(mut ps) = p_state {
+                    ps.bitfield = Bitfield::new(vec);
+                } else {
                     self.peers_state.states.insert(
                         self.peer,
                         PeerState {
                             bitfield: Bitfield::new(vec),
                             peer_interested: false,
                         },
                     );
-                } else {
-                    p_state.unwrap().bitfield = Bitfield::new(vec);
                 }
 
                 self.on_bitfield_notify.notify_waiters();
diff --git a/crates/bit_rev/src/protocol_udp.rs b/crates/bit_rev/src/protocol_udp.rs
@@ -6,13 +6,14 @@ use std::net::{SocketAddr, ToSocketAddrs};
 use std::time::Duration;
 use tokio::net::UdpSocket;
 use tokio::time::{timeout, Instant};
-use tracing::{debug, info};
+use tracing::debug;
 
 use crate::file::TorrentMeta;
 
 const PROTOCOL_ID: u64 = 0x41727101980;
 const ACTION_CONNECT: u32 = 0;
 const ACTION_ANNOUNCE: u32 = 1;
+#[allow(dead_code)]
 const ACTION_SCRAPE: u32 = 2;
 const ACTION_ERROR: u32 = 3;
 
@@ -39,6 +40,16 @@ pub struct UdpAnnounceResponse {
     pub peers: Vec<UdpPeer>,
 }
 
+pub struct AnnounceOptions {
+    pub torrent_meta: TorrentMeta,
+    pub peer_id: [u8; 20],
+    pub port: u16,
+    pub uploaded: u64,
+    pub downloaded: u64,
+    pub left: u64,
+    pub event: u32,
+}
+
 impl UdpTracker {
     pub fn new(url: String) -> Self {
         Self {
@@ -50,29 +61,35 @@ impl UdpTracker {
 
     pub async fn announce(
         &mut self,
-        torrent_meta: &TorrentMeta,
-        peer_id: &[u8; 20],
-        port: u16,
-        uploaded: u64,
-        downloaded: u64,
-        left: u64,
-        event: u32,
+        announce_options: &AnnounceOptions,
     ) -> Result<UdpAnnounceResponse> {
         // Check if we need to connect/reconnect
-        if self.connection_id.is_none() 
-            || self.last_connect.map_or(true, |t| t.elapsed() > Duration::from_secs(60))
+        if self.connection_id.is_none()
+            || self
+                .last_connect
+                .map_or_else(|| true, |t| t.elapsed() > Duration::from_secs(60))
         {
             self.connect().await?;
         }
 
-        let connection_id = self.connection_id.ok_or_else(|| anyhow!("No connection ID"))?;
-        
+        let connection_id = self
+            .connection_id
+            .ok_or_else(|| anyhow!("No connection ID"))?;
+
         let socket = UdpSocket::bind("0.0.0.0:0").await?;
         let addr = self.parse_udp_url()?;
         // info!("Using UDP tracker at {}", addr);
-        
+
         let transaction_id: u32 = rand::thread_rng().gen();
-        
+
+        let torrent_meta = &announce_options.torrent_meta;
+        let peer_id = &announce_options.peer_id;
+        let port = announce_options.port;
+        let uploaded = announce_options.uploaded;
+        let downloaded = announce_options.downloaded;
+        let left = announce_options.left;
+        let event = announce_options.event;
+
         // Build announce request
         let mut request = Vec::new();
         request.write_u64::<BigEndian>(connection_id)?;
@@ -95,16 +112,16 @@ impl UdpTracker {
         // Receive response with timeout
         let mut buf = [0u8; 1024];
         let (len, _) = timeout(Duration::from_secs(15), socket.recv_from(&mut buf)).await??;
-        
+
         self.parse_announce_response(&buf[..len], transaction_id)
     }
 
     async fn connect(&mut self) -> Result<()> {
         let socket = UdpSocket::bind("0.0.0.0:0").await?;
         let addr = self.parse_udp_url()?;
-        
+
         let transaction_id: u32 = rand::thread_rng().gen();
-        
+
         // Build connect request
         let mut request = Vec::new();
         request.write_u64::<BigEndian>(PROTOCOL_ID)?;
@@ -117,70 +134,81 @@ impl UdpTracker {
         // Receive response with timeout
         let mut buf = [0u8; 16];
         let (len, _) = timeout(Duration::from_secs(15), socket.recv_from(&mut buf)).await??;
-        
+
         if len < 16 {
             return Err(anyhow!("Connect response too short: {} bytes", len));
         }
 
         let mut cursor = Cursor::new(&buf[..len]);
         let action = cursor.read_u32::<BigEndian>()?;
         let response_transaction_id = cursor.read_u32::<BigEndian>()?;
-        
+
         if action == ACTION_ERROR {
             let error_msg = String::from_utf8_lossy(&buf[8..len]);
             return Err(anyhow!("Tracker error: {}", error_msg));
         }
-        
+
         if action != ACTION_CONNECT {
             return Err(anyhow!("Invalid action in connect response: {}", action));
         }
-        
+
         if response_transaction_id != transaction_id {
             return Err(anyhow!("Transaction ID mismatch in connect response"));
         }
 
         self.connection_id = Some(cursor.read_u64::<BigEndian>()?);
         self.last_connect = Some(Instant::now());
-        
-        debug!("UDP tracker connected with connection_id: {:?}", self.connection_id);
+
+        debug!(
+            "UDP tracker connected with connection_id: {:?}",
+            self.connection_id
+        );
         Ok(())
     }
 
     fn parse_udp_url(&self) -> Result<SocketAddr> {
         if !self.url.starts_with("udp://") {
             return Err(anyhow!("Invalid UDP tracker URL: {}", self.url));
         }
-        
+
         let url_without_scheme = &self.url[6..]; // Remove "udp://"
-        
+
         // Split at the first '/' to separate hostname:port from path
-        let host_port = url_without_scheme.split('/').next()
+        let host_port = url_without_scheme
+            .split('/')
+            .next()
             .ok_or_else(|| anyhow!("Invalid UDP tracker URL format: {}", self.url))?;
-        
-        let addr = host_port.to_socket_addrs()?.next()
+
+        let addr = host_port
+            .to_socket_addrs()?
+            .next()
             .ok_or_else(|| anyhow!("Could not resolve UDP tracker address: {}", host_port))?;
-        
+
         Ok(addr)
     }
 
-    fn parse_announce_response(&self, data: &[u8], expected_transaction_id: u32) -> Result<UdpAnnounceResponse> {
+    fn parse_announce_response(
+        &self,
+        data: &[u8],
+        expected_transaction_id: u32,
+    ) -> Result<UdpAnnounceResponse> {
         if data.len() < 20 {
             return Err(anyhow!("Announce response too short: {} bytes", data.len()));
         }
 
         let mut cursor = Cursor::new(data);
         let action = cursor.read_u32::<BigEndian>()?;
         let transaction_id = cursor.read_u32::<BigEndian>()?;
-        
+
         if action == ACTION_ERROR {
             let error_msg = String::from_utf8_lossy(&data[8..]);
             return Err(anyhow!("Tracker error: {}", error_msg));
         }
-        
+
         if action != ACTION_ANNOUNCE {
             return Err(anyhow!("Invalid action in announce response: {}", action));
         }
-        
+
         if transaction_id != expected_transaction_id {
             return Err(anyhow!("Transaction ID mismatch in announce response"));
         }
@@ -192,16 +220,21 @@ impl UdpTracker {
         let mut peers = Vec::new();
         let remaining_bytes = data.len() - 20;
         let peer_count = remaining_bytes / 6; // Each peer is 6 bytes (4 IP + 2 port)
-        
+
         for _ in 0..peer_count {
             let mut ip = [0u8; 4];
             cursor.read_exact(&mut ip)?;
             let port = cursor.read_u16::<BigEndian>()?;
-            
+
             peers.push(UdpPeer { ip, port });
         }
 
-        debug!("UDP announce response: {} seeders, {} leechers, {} peers", seeders, leechers, peers.len());
+        debug!(
+            "UDP announce response: {} seeders, {} leechers, {} peers",
+            seeders,
+            leechers,
+            peers.len()
+        );
 
         Ok(UdpAnnounceResponse {
             action,
@@ -227,13 +260,23 @@ pub async fn request_udp_peers(
     port: u16,
 ) -> Result<UdpAnnounceResponse> {
     let mut tracker = UdpTracker::new(tracker_url.to_string());
-    
+
     let uploaded = 0;
     let downloaded = 0;
     let left = torrent_meta.torrent_file.info.length.unwrap_or(0) as u64;
     let event = 2; // started event
-    
-    tracker.announce(torrent_meta, peer_id, port, uploaded, downloaded, left, event).await
+
+    let announce_options = AnnounceOptions {
+        torrent_meta: torrent_meta.clone(),
+        peer_id: *peer_id,
+        port,
+        uploaded,
+        downloaded,
+        left,
+        event,
+    };
+
+    tracker.announce(&announce_options).await
 }
 
 #[cfg(test)]
diff --git a/crates/bit_rev/tests/integration_tests.rs b/crates/bit_rev/tests/integration_tests.rs
@@ -64,7 +64,7 @@ async fn successful_handshake_test() {
     // Wait for the server to start
     tokio::time::sleep(Duration::from_millis(200)).await;
     let peer_addr = SocketAddr::new(std::net::Ipv4Addr::new(127, 0, 0, 1).into(), port);
-    let protocol = Protocol::connect(peer_addr.clone(), info_hash, client_peer_id)
+    let protocol = Protocol::connect(peer_addr, info_hash, client_peer_id)
         .await
         .expect("Failed to connect");
 
diff --git a/crates/util/src/paths.rs b/crates/util/src/paths.rs
@@ -447,7 +447,7 @@ mod tests {
         let path = Path::new("/work/node_modules");
         let path_matcher = PathMatcher::new("**/node_modules/**").unwrap();
         assert!(
-            path_matcher.is_match(&path),
+            path_matcher.is_match(path),
             "Path matcher {path_matcher} should match {path:?}"
         );
     }
@@ -457,7 +457,7 @@ mod tests {
         let path = Path::new("/Users/someonetoignore/work/zed/zed.dev/node_modules");
         let path_matcher = PathMatcher::new("**/node_modules/**").unwrap();
         assert!(
-            path_matcher.is_match(&path),
+            path_matcher.is_match(path),
             "Path matcher {path_matcher} should match {path:?}"
         );
     }
