fix many clippy lints (#38)

VuiMuich · web-flow · commit 928d25822ffd · 2025-06-17T21:29:52.000+02:00
diff --git a/src/access_point.rs b/src/access_point.rs
@@ -222,7 +222,7 @@ impl AccessPoint {
                 self.connected_devices = diagnostic
                     .iter()
                     .map(|v| v["Address"].clone().trim_matches('"').to_string())
-                    .collect()
+                    .collect();
             }
         }
 
@@ -232,12 +232,12 @@ impl AccessPoint {
     pub async fn scan(&self, sender: UnboundedSender<Event>) -> AppResult<()> {
         let iwd_access_point = self.session.access_point().unwrap();
         match iwd_access_point.scan().await {
-            Ok(_) => Notification::send(
+            Ok(()) => Notification::send(
                 "Start Scanning".to_string(),
                 NotificationLevel::Info,
-                sender,
+                &sender,
             )?,
-            Err(e) => Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?,
+            Err(e) => Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?,
         }
 
         Ok(())
@@ -249,12 +249,12 @@ impl AccessPoint {
             .start(self.ssid.value(), self.psk.value())
             .await
         {
-            Ok(_) => Notification::send(
+            Ok(()) => Notification::send(
                 format!("AP Started\nSSID: {}", self.ssid.value()),
                 NotificationLevel::Info,
-                sender,
+                &sender,
             )?,
-            Err(e) => Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?,
+            Err(e) => Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?,
         }
         self.ap_start
             .store(false, std::sync::atomic::Ordering::Relaxed);
@@ -265,8 +265,10 @@ impl AccessPoint {
     pub async fn stop(&self, sender: UnboundedSender<Event>) -> AppResult<()> {
         let iwd_access_point = self.session.access_point().unwrap();
         match iwd_access_point.stop().await {
-            Ok(_) => Notification::send("AP Stopped".to_string(), NotificationLevel::Info, sender)?,
-            Err(e) => Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?,
+            Ok(()) => {
+                Notification::send("AP Stopped".to_string(), NotificationLevel::Info, &sender)?
+            }
+            Err(e) => Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?,
         }
 
         Ok(())
diff --git a/src/adapter.rs b/src/adapter.rs
@@ -226,7 +226,7 @@ impl Adapter {
         let ap_frequency = match self.device.access_point.as_ref() {
             Some(ap) => {
                 if ap.has_started {
-                    format!("{:.2} GHz", (ap.frequency.unwrap() as f32 / 1000.0))
+                    format!("{:.2} GHz", (ap.frequency.unwrap() / 1000))
                 } else {
                     "-".to_string()
                 }
@@ -1034,14 +1034,14 @@ impl Adapter {
             rows.push(Row::new(vec![
                 Cell::from("model").style(Style::default().bold().yellow()),
                 Cell::from(model.clone()),
-            ]))
+            ]));
         }
 
         if let Some(vendor) = &self.vendor {
             rows.push(Row::new(vec![
                 Cell::from("vendor").style(Style::default().bold().yellow()),
                 Cell::from(vendor.clone()),
-            ]))
+            ]));
         }
 
         let widths = [Constraint::Length(20), Constraint::Fill(1)];
diff --git a/src/app.rs b/src/app.rs
@@ -80,7 +80,7 @@ pub async fn request_confirmation(
 
     r = rx_cancel.recv() => {
             match r {
-                Ok(_) => {
+                Ok(()) => {
                         Err(anyhow!("Operation Canceled").into())},
                 Err(_) => Err(anyhow!("Failed to receive cancel signal").into()),
             }
@@ -138,8 +138,7 @@ impl App {
 
         let color_mode = match terminal_light::luma() {
             Ok(luma) if luma > 0.6 => ColorMode::Light,
-            Ok(_) => ColorMode::Dark,
-            Err(_) => ColorMode::Dark,
+            Ok(_) | Err(_) => ColorMode::Dark,
         };
 
         Ok(Self {
diff --git a/src/device.rs b/src/device.rs
@@ -37,7 +37,7 @@ impl Device {
                     Notification::send(
                         e.to_string(),
                         crate::notification::NotificationLevel::Error,
-                        sender.clone(),
+                        &sender.clone(),
                     )?;
                     None
                 }
@@ -52,7 +52,7 @@ impl Device {
                     Notification::send(
                         e.to_string(),
                         crate::notification::NotificationLevel::Error,
-                        sender,
+                        &sender,
                     )?;
                     None
                 }
@@ -110,7 +110,7 @@ impl Device {
                                     Notification::send(
                                         e.to_string(),
                                         crate::notification::NotificationLevel::Error,
-                                        sender,
+                                        &sender,
                                     )?;
                                     None
                                 }
@@ -132,7 +132,7 @@ impl Device {
                                     Notification::send(
                                         e.to_string(),
                                         crate::notification::NotificationLevel::Error,
-                                        sender,
+                                        &sender,
                                     )?;
                                     None
                                 }
diff --git a/src/event.rs b/src/event.rs
@@ -29,29 +29,29 @@ impl EventHandler {
     pub fn new(tick_rate: u64) -> Self {
         let tick_rate = Duration::from_millis(tick_rate);
         let (sender, receiver) = mpsc::unbounded_channel();
-        let _sender = sender.clone();
+        let sender_cloned = sender.clone();
         let handler = tokio::spawn(async move {
             let mut reader = crossterm::event::EventStream::new();
             let mut tick = tokio::time::interval(tick_rate);
             loop {
                 let tick_delay = tick.tick();
                 let crossterm_event = reader.next().fuse();
                 tokio::select! {
-                  _ = _sender.closed() => {
+                  () = sender_cloned.closed() => {
                     break;
                   }
                   _ = tick_delay => {
-                    _sender.send(Event::Tick).unwrap();
+                    sender_cloned.send(Event::Tick).unwrap();
                   }
                   Some(Ok(evt)) = crossterm_event => {
                     match evt {
                       CrosstermEvent::Key(key) => {
                         if key.kind == crossterm::event::KeyEventKind::Press {
-                          _sender.send(Event::Key(key)).unwrap();
+                          sender_cloned.send(Event::Key(key)).unwrap();
                         }
                       },
                       CrosstermEvent::Resize(x, y) => {
-                        _sender.send(Event::Resize(x, y)).unwrap();
+                        sender_cloned.send(Event::Resize(x, y)).unwrap();
                       },
                       _ => {}
                     }
diff --git a/src/handler.rs b/src/handler.rs
@@ -22,7 +22,7 @@ pub async fn handle_key_events(
             KeyCode::Char('q') => {
                 app.quit();
             }
-            KeyCode::Char('c') | KeyCode::Char('C') => {
+            KeyCode::Char('c' | 'C') => {
                 if key_event.modifiers == KeyModifiers::CONTROL {
                     app.quit();
                 }
@@ -113,7 +113,7 @@ pub async fn handle_key_events(
                 KeyCode::Char('q') => {
                     app.quit();
                 }
-                KeyCode::Char('c') | KeyCode::Char('C') => {
+                KeyCode::Char('c' | 'C') => {
                     if key_event.modifiers == KeyModifiers::CONTROL {
                         app.quit();
                     }
@@ -150,7 +150,7 @@ pub async fn handle_key_events(
                                 .as_mut()
                                 .unwrap()
                                 .scan(sender)
-                                .await?
+                                .await?;
                         }
                         Mode::Ap => {
                             app.adapter
@@ -159,10 +159,10 @@ pub async fn handle_key_events(
                                 .as_mut()
                                 .unwrap()
                                 .scan(sender)
-                                .await?
+                                .await?;
                         }
                         _ => {}
-                    };
+                    }
                 }
 
                 KeyCode::Tab => match app.adapter.device.mode {
@@ -201,12 +201,12 @@ pub async fn handle_key_events(
                             if let Some(ap) = &mut app.adapter.device.access_point {
                                 match ap.focused_section {
                                     APFocusedSection::SSID => {
-                                        ap.focused_section = APFocusedSection::PSK
+                                        ap.focused_section = APFocusedSection::PSK;
                                     }
                                     APFocusedSection::PSK => {
-                                        ap.focused_section = APFocusedSection::SSID
+                                        ap.focused_section = APFocusedSection::SSID;
                                     }
-                                };
+                                }
                             }
                         }
                         _ => {}
@@ -250,12 +250,12 @@ pub async fn handle_key_events(
                             if let Some(ap) = &mut app.adapter.device.access_point {
                                 match ap.focused_section {
                                     APFocusedSection::SSID => {
-                                        ap.focused_section = APFocusedSection::PSK
+                                        ap.focused_section = APFocusedSection::PSK;
                                     }
                                     APFocusedSection::PSK => {
-                                        ap.focused_section = APFocusedSection::SSID
+                                        ap.focused_section = APFocusedSection::SSID;
                                     }
-                                };
+                                }
                             }
                         }
                         _ => {}
@@ -278,14 +278,14 @@ pub async fn handle_key_events(
                                             Notification::send(
                                                 "Device Powered Off".to_string(),
                                                 crate::notification::NotificationLevel::Info,
-                                                sender.clone(),
+                                                &sender.clone(),
                                             )?;
                                         }
                                         Err(e) => {
                                             Notification::send(
                                                 e.to_string(),
                                                 crate::notification::NotificationLevel::Error,
-                                                sender.clone(),
+                                                &sender.clone(),
                                             )?;
                                         }
                                     }
@@ -296,14 +296,14 @@ pub async fn handle_key_events(
                                             Notification::send(
                                                 "Device Powered On".to_string(),
                                                 crate::notification::NotificationLevel::Info,
-                                                sender.clone(),
+                                                &sender.clone(),
                                             )?;
                                         }
                                         Err(e) => {
                                             Notification::send(
                                                 e.to_string(),
                                                 crate::notification::NotificationLevel::Error,
-                                                sender.clone(),
+                                                &sender.clone(),
                                             )?;
                                         }
                                     }
diff --git a/src/help.rs b/src/help.rs
@@ -20,7 +20,7 @@ pub struct Help {
 }
 
 impl Help {
-    pub fn new(config: Arc<Config>) -> Self {
+    pub fn new(config: &Arc<Config>) -> Self {
         let mut state = TableState::new().with_offset(0);
         state.select(Some(0));
 
@@ -159,7 +159,7 @@ impl Help {
             .keys
             .iter()
             .map(|key| {
-                Row::new(vec![key.0.to_owned(), key.1.into()]).style(match color_mode {
+                Row::new(vec![key.0.clone(), key.1.into()]).style(match color_mode {
                     ColorMode::Dark => Style::default().fg(Color::White),
                     ColorMode::Light => Style::default().fg(Color::Black),
                 })
diff --git a/src/known_network.rs b/src/known_network.rs
@@ -42,43 +42,43 @@ impl KnownNetwork {
 
     pub async fn forget(&self, sender: UnboundedSender<Event>) -> AppResult<()> {
         if let Err(e) = self.n.forget().await {
-            Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?;
+            Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;
             return Ok(());
         }
 
         Notification::send(
             "Network Removed".to_string(),
             NotificationLevel::Info,
-            sender,
+            &sender,
         )?;
         Ok(())
     }
 
     pub async fn toggle_autoconnect(&self, sender: UnboundedSender<Event>) -> AppResult<()> {
         if self.is_autoconnect {
             match self.n.set_autoconnect(false).await {
-                Ok(_) => {
+                Ok(()) => {
                     Notification::send(
                         format!("Disable Autoconnect for: {}", self.name),
                         NotificationLevel::Info,
-                        sender.clone(),
+                        &sender.clone(),
                     )?;
                 }
                 Err(e) => {
-                    Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?;
+                    Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;
                 }
             }
         } else {
             match self.n.set_autoconnect(true).await {
-                Ok(_) => {
+                Ok(()) => {
                     Notification::send(
                         format!("Enable Autoconnect for: {}", self.name),
                         NotificationLevel::Info,
-                        sender.clone(),
+                        &sender.clone(),
                     )?;
                 }
                 Err(e) => {
-                    Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?;
+                    Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;
                 }
             }
         }
diff --git a/src/main.rs b/src/main.rs
@@ -19,7 +19,7 @@ async fn main() -> AppResult<()> {
 
     let config = Arc::new(Config::new());
 
-    let help = Help::new(config.clone());
+    let help = Help::new(&config.clone());
 
     let backend = CrosstermBackend::new(io::stdout());
     let terminal = Terminal::new(backend)?;
@@ -52,7 +52,7 @@ async fn main() -> AppResult<()> {
                     tui.events.sender.clone(),
                     config.clone(),
                 )
-                .await?
+                .await?;
             }
             Event::Notification(notification) => {
                 app.notifications.push(notification);
diff --git a/src/network.rs b/src/network.rs
@@ -43,20 +43,20 @@ impl Network {
 
     pub async fn connect(&self, sender: UnboundedSender<Event>) -> AppResult<()> {
         match self.n.connect().await {
-            Ok(_) => Notification::send(
+            Ok(()) => Notification::send(
                 format!("Connected to {}", self.name),
                 NotificationLevel::Info,
-                sender,
+                &sender,
             )?,
             Err(e) => {
                 if e.to_string().contains("net.connman.iwd.Aborted") {
                     Notification::send(
                         "Connection canceled".to_string(),
                         NotificationLevel::Info,
-                        sender,
-                    )?
+                        &sender,
+                    )?;
                 } else {
-                    Notification::send(e.to_string(), NotificationLevel::Error, sender)?
+                    Notification::send(e.to_string(), NotificationLevel::Error, &sender)?;
                 }
             }
         }
diff --git a/src/notification.rs b/src/notification.rs
diff --git a/src/rfkill.rs b/src/rfkill.rs
diff --git a/src/station.rs b/src/station.rs
diff --git a/src/ui.rs b/src/ui.rs

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ pub async fn handle_key_events(`
`22`	`22`	`KeyCode::Char('q') => {`
`23`	`23`	`app.quit();`
`24`	`24`	`}`
`25`		`- KeyCode::Char('c') \| KeyCode::Char('C') => {`
	`25`	`+ KeyCode::Char('c' \| 'C') => {`
`26`	`26`	`if key_event.modifiers == KeyModifiers::CONTROL {`
`27`	`27`	`app.quit();`
`28`	`28`	`}`
`@@ -113,7 +113,7 @@ pub async fn handle_key_events(`
`113`	`113`	`KeyCode::Char('q') => {`
`114`	`114`	`app.quit();`
`115`	`115`	`}`
`116`		`- KeyCode::Char('c') \| KeyCode::Char('C') => {`
	`116`	`+ KeyCode::Char('c' \| 'C') => {`
`117`	`117`	`if key_event.modifiers == KeyModifiers::CONTROL {`
`118`	`118`	`app.quit();`
`119`	`119`	`}`
`@@ -150,7 +150,7 @@ pub async fn handle_key_events(`
`150`	`150`	`.as_mut()`
`151`	`151`	`.unwrap()`
`152`	`152`	`.scan(sender)`
`153`		`- .await?`
	`153`	`+ .await?;`
`154`	`154`	`}`
`155`	`155`	`Mode::Ap => {`
`156`	`156`	`app.adapter`
`@@ -159,10 +159,10 @@ pub async fn handle_key_events(`
`159`	`159`	`.as_mut()`
`160`	`160`	`.unwrap()`
`161`	`161`	`.scan(sender)`
`162`		`- .await?`
	`162`	`+ .await?;`
`163`	`163`	`}`
`164`	`164`	`_ => {}`
`165`		`- };`
	`165`	`+ }`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`KeyCode::Tab => match app.adapter.device.mode {`
`@@ -201,12 +201,12 @@ pub async fn handle_key_events(`
`201`	`201`	`if let Some(ap) = &mut app.adapter.device.access_point {`
`202`	`202`	`match ap.focused_section {`
`203`	`203`	`APFocusedSection::SSID => {`
`204`		`- ap.focused_section = APFocusedSection::PSK`
	`204`	`+ ap.focused_section = APFocusedSection::PSK;`
`205`	`205`	`}`
`206`	`206`	`APFocusedSection::PSK => {`
`207`		`- ap.focused_section = APFocusedSection::SSID`
	`207`	`+ ap.focused_section = APFocusedSection::SSID;`
`208`	`208`	`}`
`209`		`- };`
	`209`	`+ }`
`210`	`210`	`}`
`211`	`211`	`}`
`212`	`212`	`_ => {}`
`@@ -250,12 +250,12 @@ pub async fn handle_key_events(`
`250`	`250`	`if let Some(ap) = &mut app.adapter.device.access_point {`
`251`	`251`	`match ap.focused_section {`
`252`	`252`	`APFocusedSection::SSID => {`
`253`		`- ap.focused_section = APFocusedSection::PSK`
	`253`	`+ ap.focused_section = APFocusedSection::PSK;`
`254`	`254`	`}`
`255`	`255`	`APFocusedSection::PSK => {`
`256`		`- ap.focused_section = APFocusedSection::SSID`
	`256`	`+ ap.focused_section = APFocusedSection::SSID;`
`257`	`257`	`}`
`258`		`- };`
	`258`	`+ }`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`	`_ => {}`
`@@ -278,14 +278,14 @@ pub async fn handle_key_events(`
`278`	`278`	`Notification::send(`
`279`	`279`	`"Device Powered Off".to_string(),`
`280`	`280`	`crate::notification::NotificationLevel::Info,`
`281`		`- sender.clone(),`
	`281`	`+ &sender.clone(),`
`282`	`282`	`)?;`
`283`	`283`	`}`
`284`	`284`	`Err(e) => {`
`285`	`285`	`Notification::send(`
`286`	`286`	`e.to_string(),`
`287`	`287`	`crate::notification::NotificationLevel::Error,`
`288`		`- sender.clone(),`
	`288`	`+ &sender.clone(),`
`289`	`289`	`)?;`
`290`	`290`	`}`
`291`	`291`	`}`
`@@ -296,14 +296,14 @@ pub async fn handle_key_events(`
`296`	`296`	`Notification::send(`
`297`	`297`	`"Device Powered On".to_string(),`
`298`	`298`	`crate::notification::NotificationLevel::Info,`
`299`		`- sender.clone(),`
	`299`	`+ &sender.clone(),`
`300`	`300`	`)?;`
`301`	`301`	`}`
`302`	`302`	`Err(e) => {`
`303`	`303`	`Notification::send(`
`304`	`304`	`e.to_string(),`
`305`	`305`	`crate::notification::NotificationLevel::Error,`
`306`		`- sender.clone(),`
	`306`	`+ &sender.clone(),`
`307`	`307`	`)?;`
`308`	`308`	`}`
`309`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,43 +42,43 @@ impl KnownNetwork {`
`42`	`42`
`43`	`43`	`pub async fn forget(&self, sender: UnboundedSender<Event>) -> AppResult<()> {`
`44`	`44`	`if let Err(e) = self.n.forget().await {`
`45`		`- Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?;`
	`45`	`+ Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;`
`46`	`46`	`return Ok(());`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`Notification::send(`
`50`	`50`	`"Network Removed".to_string(),`
`51`	`51`	`NotificationLevel::Info,`
`52`		`- sender,`
	`52`	`+ &sender,`
`53`	`53`	`)?;`
`54`	`54`	`Ok(())`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`pub async fn toggle_autoconnect(&self, sender: UnboundedSender<Event>) -> AppResult<()> {`
`58`	`58`	`if self.is_autoconnect {`
`59`	`59`	`match self.n.set_autoconnect(false).await {`
`60`		`- Ok(_) => {`
	`60`	`+ Ok(()) => {`
`61`	`61`	`Notification::send(`
`62`	`62`	`format!("Disable Autoconnect for: {}", self.name),`
`63`	`63`	`NotificationLevel::Info,`
`64`		`- sender.clone(),`
	`64`	`+ &sender.clone(),`
`65`	`65`	`)?;`
`66`	`66`	`}`
`67`	`67`	`Err(e) => {`
`68`		`- Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?;`
	`68`	`+ Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`	`} else {`
`72`	`72`	`match self.n.set_autoconnect(true).await {`
`73`		`- Ok(_) => {`
	`73`	`+ Ok(()) => {`
`74`	`74`	`Notification::send(`
`75`	`75`	`format!("Enable Autoconnect for: {}", self.name),`
`76`	`76`	`NotificationLevel::Info,`
`77`		`- sender.clone(),`
	`77`	`+ &sender.clone(),`
`78`	`78`	`)?;`
`79`	`79`	`}`
`80`	`80`	`Err(e) => {`
`81`		`- Notification::send(e.to_string(), NotificationLevel::Error, sender.clone())?;`
	`81`	`+ Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ async fn main() -> AppResult<()> {`
`19`	`19`
`20`	`20`	`let config = Arc::new(Config::new());`
`21`	`21`
`22`		`- let help = Help::new(config.clone());`
	`22`	`+ let help = Help::new(&config.clone());`
`23`	`23`
`24`	`24`	`let backend = CrosstermBackend::new(io::stdout());`
`25`	`25`	`let terminal = Terminal::new(backend)?;`
`@@ -52,7 +52,7 @@ async fn main() -> AppResult<()> {`
`52`	`52`	`tui.events.sender.clone(),`
`53`	`53`	`config.clone(),`
`54`	`54`	`)`
`55`		`- .await?`
	`55`	`+ .await?;`
`56`	`56`	`}`
`57`	`57`	`Event::Notification(notification) => {`
`58`	`58`	`app.notifications.push(notification);`