chore: clippy

subscriptions/network-manager/src/available_wifi.rs

@@ -22,13 +22,9 @@ pub async fn handle_wireless_device(
     let mut scan_changed = device.receive_last_scan_changed().await;
 
     if let Some(t) = scan_changed.next().await {
-        match t.get().await {
-            Ok(-1) => {
-                tracing::error!("wireless device scan errored");
-                return Ok(Default::default());
-            }
-
-            _ => (),
+        if let Ok(-1) = t.get().await {
+            tracing::error!("wireless device scan errored");
+            return Ok(Default::default());
         }
     }
 

subscriptions/network-manager/src/devices.rs

@@ -36,8 +36,8 @@ pub struct KnownDeviceConnection {
     pub uuid: Arc<str>,
 }
 
-pub async fn list<'a>(
-    conn: &'a zbus::Connection,
+pub async fn list(
+    conn: &zbus::Connection,
     device_type_filter: fn(DeviceType) -> bool,
 ) -> zbus::Result<Vec<DeviceInfo>> {
     let nm = NetworkManager::new(conn).await?;

subscriptions/network-manager/src/hw_address.rs

@@ -16,19 +16,23 @@ impl HwAddress {
         }
         u64::from_str_radix(columnless_vec.join("").as_str(), 16)
             .ok()
-            .and_then(|address| Some(HwAddress { address }))
+            .map(|address| HwAddress { address })
     }
     pub fn from_string(arg: &String) -> Option<Self> {
         HwAddress::from_str(arg.as_str())
     }
-    pub fn to_string(&self) -> String {
-        format!("{:#x}", self.address)
+}
+
+impl std::fmt::Display for HwAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let hex = format!("{:#x}", self.address)
             .trim_start_matches("0x")
             .chars()
             .collect::<Vec<_>>()
             .chunks(2)
             .map(|chunk| chunk.iter().cloned().collect::<String>())
             .collect::<Vec<String>>()
-            .join(":")
+            .join(":");
+        write!(f, "{}", hex)
     }
 }

subscriptions/network-manager/src/lib.rs

@@ -620,7 +620,7 @@ impl NetworkManagerState {
 
                     std::str::from_utf8(&output.stdout)
                         .ok()
-                        .map_or(false, |stdout| stdout.contains("Soft blocked: yes"))
+                        .is_some_and(|stdout| stdout.contains("Soft blocked: yes"))
                 }),
             network_manager
                 .wireless_enabled()
@@ -714,7 +714,7 @@ impl NetworkManagerState {
             .iter()
             .filter(|a| {
                 known_ssid.contains(&a.ssid)
-                    && !active_conns.iter().any(|ac| &ac.name() == a.ssid.as_ref())
+                    && !active_conns.iter().any(|ac| ac.name() == a.ssid.as_ref())
             })
             .cloned()
             .collect();
@@ -733,7 +733,7 @@ impl NetworkManagerState {
         self.wireless_access_points = Vec::new();
     }
 
-    async fn connect_wifi<'a>(
+    async fn connect_wifi(
         &self,
         conn: &zbus::Connection,
         ssid: &str,
@@ -844,8 +844,8 @@ impl NetworkManagerState {
                 let (_, active_conn) = nm
                     .add_and_activate_connection(conn_settings, device.inner().path(), &ap.path)
                     .await?;
-                let dummy = ActiveConnectionProxy::new(&conn, active_conn).await?;
-                let active = ActiveConnectionProxy::builder(&conn)
+                let dummy = ActiveConnectionProxy::new(conn, active_conn).await?;
+                let active = ActiveConnectionProxy::builder(conn)
                     .destination(dummy.inner().destination().to_owned())
                     .unwrap()
                     .interface(dummy.inner().interface().to_owned())
@@ -867,14 +867,13 @@ impl NetworkManagerState {
                 } else if let Ok(enums::ActiveConnectionState::Deactivated) = state {
                     return Err(Error::ConnectionActivate);
                 }
-                match tokio::time::timeout(Duration::from_secs(20), changes.next()).await {
-                    Ok(Some(s)) => {
-                        let state = s.get().await.unwrap_or_default().into();
-                        if matches!(state, enums::ActiveConnectionState::Activated) {
-                            return Ok(());
-                        }
+                if let Ok(Some(s)) =
+                    tokio::time::timeout(Duration::from_secs(20), changes.next()).await
+                {
+                    let state = s.get().await.unwrap_or_default().into();
+                    if matches!(state, enums::ActiveConnectionState::Activated) {
+                        return Ok(());
                     }
-                    _ => {}
                 };
 
                 count -= 1;