Make clippy happy

Author: zonque

build.rs

@@ -45,38 +45,33 @@ fn get_git_version() -> String {
     if let Ok(output) = Command::new("git")
         .args(["describe", "--tags", "--dirty", "--always"])
         .output()
+        && output.status.success()
+        && let Ok(version) = String::from_utf8(output.stdout)
     {
-        if output.status.success() {
-            if let Ok(version) = String::from_utf8(output.stdout) {
-                let version = version.trim();
-                // If version doesn't start with 'v' and contains no '-', it's just a commit hash
-                if !version.starts_with('v') && !version.contains('-') {
-                    // Get Cargo version and append git hash
-                    let cargo_version =
-                        env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.1.0".to_string());
-                    return if version.len() >= 7 {
-                        format!("{}-g{}", cargo_version, &version[..7])
-                    } else {
-                        format!("{}-g{}", cargo_version, version)
-                    };
-                }
-                return version.to_string();
-            }
+        let version = version.trim();
+        // If version doesn't start with 'v' and contains no '-', it's just a commit hash
+        if !version.starts_with('v') && !version.contains('-') {
+            // Get Cargo version and append git hash
+            let cargo_version =
+                env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.1.0".to_string());
+            return if version.len() >= 7 {
+                format!("{}-g{}", cargo_version, &version[..7])
+            } else {
+                format!("{}-g{}", cargo_version, version)
+            };
         }
+        return version.to_string();
     }
 
     // Fallback to git rev-parse for just commit hash
     if let Ok(output) = Command::new("git")
         .args(["rev-parse", "--short", "HEAD"])
         .output()
+        && output.status.success()
+        && let Ok(hash) = String::from_utf8(output.stdout)
     {
-        if output.status.success() {
-            if let Ok(hash) = String::from_utf8(output.stdout) {
-                let cargo_version =
-                    env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.1.0".to_string());
-                return format!("{}-g{}", cargo_version, hash.trim());
-            }
-        }
+        let cargo_version = env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.1.0".to_string());
+        return format!("{}-g{}", cargo_version, hash.trim());
     }
 
     // Final fallback to Cargo.toml version
@@ -87,12 +82,10 @@ fn get_git_hash() -> String {
     if let Ok(output) = Command::new("git")
         .args(["rev-parse", "--short", "HEAD"])
         .output()
+        && output.status.success()
+        && let Ok(hash) = String::from_utf8(output.stdout)
     {
-        if output.status.success() {
-            if let Ok(hash) = String::from_utf8(output.stdout) {
-                return hash.trim().to_string();
-            }
-        }
+        return hash.trim().to_string();
     }
 
     "unknown".to_string()

src/app.rs

@@ -2,12 +2,12 @@ use anyhow::Result;
 use crossterm::{
     event::{self, Event, KeyCode},
     execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
 };
 use ratatui::{
+    Terminal,
     backend::{Backend, CrosstermBackend},
     layout::Rect,
-    Terminal,
 };
 use std::{
     io,
@@ -423,12 +423,13 @@ impl App {
                     self.scroll_modal_down();
                 } else if matches!(self.active_view, ActiveView::PacketHistory) {
                     let packet_count = self.get_packet_history().len();
-                    if packet_count > 0 && self.selected_packet_index < packet_count {
-                        if let Some(packet) = self.get_selected_packet() {
-                            self.modal_packet = Some(packet);
-                            self.show_packet_modal = true;
-                            self.modal_scroll_offset = 0;
-                        }
+                    if packet_count > 0
+                        && self.selected_packet_index < packet_count
+                        && let Some(packet) = self.get_selected_packet()
+                    {
+                        self.modal_packet = Some(packet);
+                        self.show_packet_modal = true;
+                        self.modal_scroll_offset = 0;
                     }
                 }
             }
@@ -767,13 +768,13 @@ impl App {
         > = std::collections::HashMap::new();
 
         for (i, host) in hosts.iter().enumerate() {
-            if let PtpHostState::TimeReceiver(receiver_state) = &host.state {
-                if let Some(transmitter_id) = receiver_state.selected_transmitter_identity {
-                    transmitter_to_receiver_indices
-                        .entry(transmitter_id)
-                        .or_default()
-                        .push(i);
-                }
+            if let PtpHostState::TimeReceiver(receiver_state) = &host.state
+                && let Some(transmitter_id) = receiver_state.selected_transmitter_identity
+            {
+                transmitter_to_receiver_indices
+                    .entry(transmitter_id)
+                    .or_default()
+                    .push(i);
             }
         }
 
@@ -989,10 +990,10 @@ impl App {
 
     pub fn get_packet_history(&self) -> Vec<ParsedPacket> {
         // Return packets from the currently selected host
-        if let Some(ref selected_host_id) = self.selected_host_id {
-            if let Some(history) = self.ptp_tracker.get_host_packet_history(*selected_host_id) {
-                return history;
-            }
+        if let Some(ref selected_host_id) = self.selected_host_id
+            && let Some(history) = self.ptp_tracker.get_host_packet_history(*selected_host_id)
+        {
+            return history;
         }
 
         Vec::new()
@@ -1056,13 +1057,13 @@ impl App {
 
     fn restore_host_selection(&mut self) {
         // If we have a stored host ID, try to find it in the current list
-        if let Some(ref stored_host_id) = self.selected_host_id {
-            if let Some(found_index) = self.find_host_index(*stored_host_id) {
-                // Found the stored host, select it
-                self.selected_index = found_index;
-                self.ensure_host_visible(20);
-                return;
-            }
+        if let Some(ref stored_host_id) = self.selected_host_id
+            && let Some(found_index) = self.find_host_index(*stored_host_id)
+        {
+            // Found the stored host, select it
+            self.selected_index = found_index;
+            self.update_selected_host(found_index);
+            return;
         }
 
         // Either no stored host ID, or stored host not found - clamp current index
@@ -1140,11 +1141,7 @@ impl App {
     pub fn ensure_packet_visible(&mut self) {
         let visible_height = if self.visible_packet_height == 0 {
             // Defensive fallback if height hasn't been set yet
-            if self.packet_history_expanded {
-                20
-            } else {
-                8
-            }
+            if self.packet_history_expanded { 20 } else { 8 }
         } else {
             self.visible_packet_height
         };

src/ptp.rs

@@ -860,10 +860,10 @@ impl PtpTracker {
 
             // Reset all winners in this domain first
             for clock_id in &transmitters {
-                if let Some(host) = self.hosts.get_mut(clock_id) {
-                    if let PtpHostState::TimeTransmitter(ref mut state) = host.state {
-                        state.is_bmca_winner = false;
-                    }
+                if let Some(host) = self.hosts.get_mut(clock_id)
+                    && let PtpHostState::TimeTransmitter(ref mut state) = host.state
+                {
+                    state.is_bmca_winner = false;
                 }
             }
 
@@ -874,30 +874,28 @@ impl PtpTracker {
                 if let (Some(best_host), Some(candidate_host)) = (
                     self.hosts.get(&best_clock_id),
                     self.hosts.get(&candidate_clock_id),
-                ) {
-                    if let (
-                        PtpHostState::TimeTransmitter(best_state),
-                        PtpHostState::TimeTransmitter(candidate_state),
-                    ) = (&best_host.state, &candidate_host.state)
-                    {
-                        let comparison_result = candidate_state.compare_for_bmca(
-                            best_state,
-                            candidate_clock_id,
-                            best_clock_id,
-                        );
-
-                        if comparison_result == std::cmp::Ordering::Less {
-                            best_clock_id = candidate_clock_id;
-                        }
+                ) && let (
+                    PtpHostState::TimeTransmitter(best_state),
+                    PtpHostState::TimeTransmitter(candidate_state),
+                ) = (&best_host.state, &candidate_host.state)
+                {
+                    let comparison_result = candidate_state.compare_for_bmca(
+                        best_state,
+                        candidate_clock_id,
+                        best_clock_id,
+                    );
+
+                    if comparison_result == std::cmp::Ordering::Less {
+                        best_clock_id = candidate_clock_id;
                     }
                 }
             }
 
             // Mark the winner
-            if let Some(winner_host) = self.hosts.get_mut(&best_clock_id) {
-                if let PtpHostState::TimeTransmitter(ref mut state) = winner_host.state {
-                    state.is_bmca_winner = true;
-                }
+            if let Some(winner_host) = self.hosts.get_mut(&best_clock_id)
+                && let PtpHostState::TimeTransmitter(ref mut state) = winner_host.state
+            {
+                state.is_bmca_winner = true;
             }
 
             // Update receivers in this domain to select the BMCA winner as their transmitter
@@ -908,11 +906,11 @@ impl PtpTracker {
     /// Update all receivers in a domain to select the BMCA winner as their transmitter
     fn update_receivers_for_domain(&mut self, domain: u8, winner_clock_id: ClockIdentity) {
         for host in self.hosts.values_mut() {
-            if host.domain_number == Some(domain) {
-                if let PtpHostState::TimeReceiver(ref mut receiver_state) = host.state {
-                    receiver_state.selected_transmitter_identity = Some(winner_clock_id);
-                    receiver_state.selected_transmitter_confidence = 1.0; // High confidence from BMCA
-                }
+            if host.domain_number == Some(domain)
+                && let PtpHostState::TimeReceiver(ref mut receiver_state) = host.state
+            {
+                receiver_state.selected_transmitter_identity = Some(winner_clock_id);
+                receiver_state.selected_transmitter_confidence = 1.0; // High confidence from BMCA
             }
         }
     }

src/source.rs

@@ -306,11 +306,11 @@ async fn capture_on_interface(
     loop {
         match rx.next() {
             Ok(packet_data) => {
-                if let Some(raw_packet) = process_ethernet_packet(packet_data, &interface_name) {
-                    if sender.send(raw_packet).is_err() {
-                        // Receiver has been dropped, exit the loop
-                        break;
-                    }
+                if let Some(raw_packet) = process_ethernet_packet(packet_data, &interface_name)
+                    && sender.send(raw_packet).is_err()
+                {
+                    // Receiver has been dropped, exit the loop
+                    break;
                 }
             }
             Err(e) => {

src/ui.rs

@@ -1,15 +1,15 @@
 use ratatui::{
+    Frame,
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Color, Modifier, Style},
     text::{Line, Span},
     widgets::{Block, BorderType, Borders, Cell, Clear, Paragraph, Row, Table, Wrap},
-    Frame,
 };
 
 use crate::{
     app::{ActiveView, App, SortColumn, TreeNode},
     ptp::{PtpHost, PtpHostState},
-    types::{format_timestamp, ParsedPacket, PtpClockAccuracy, PtpClockClass},
+    types::{ParsedPacket, PtpClockAccuracy, PtpClockClass, format_timestamp},
     version,
 };
 
@@ -383,11 +383,7 @@ fn render_hosts_table(f: &mut Frame, area: Rect, app: &mut App) {
                 // Create indentation for tree structure
                 let indent = "  ".repeat(node.depth);
                 let tree_prefix = if node.depth > 0 {
-                    if *is_last_child {
-                        "└─ "
-                    } else {
-                        "├─ "
-                    }
+                    if *is_last_child { "└─ " } else { "├─ " }
                 } else {
                     ""
                 };