fix: Clippy warnings

rust/agama-cli/src/auth.rs

@@ -199,7 +199,7 @@ async fn get_jwt(url: String, password: String) -> anyhow::Result<String> {
     let body = response
         .json::<std::collections::HashMap<String, String>>()
         .await?;
-    let value = body.get(&"token".to_string());
+    let value = body.get("token");
 
     if let Some(token) = value {
         return Ok(token.clone());

rust/agama-lib/src/dbus.rs

@@ -62,9 +62,7 @@ macro_rules! property_from_dbus {
 pub fn to_owned_hash(source: &HashMap<&str, Value<'_>>) -> HashMap<String, OwnedValue> {
     let mut owned = HashMap::new();
     for (key, value) in source.iter() {
-        if let Ok(owned_value) = value.try_into() {
-            owned.insert(key.to_string(), owned_value);
-        }
+        owned.insert(key.to_string(), value.into());
     }
     owned
 }
@@ -74,7 +72,7 @@ pub fn to_owned_hash(source: &HashMap<&str, Value<'_>>) -> HashMap<String, Owned
 /// TODO: should we merge this feature with the "DeviceSid"?
 pub fn extract_id_from_path(path: &OwnedObjectPath) -> Result<u32, zvariant::Error> {
     path.as_str()
-        .rsplit_once("/")
+        .rsplit_once('/')
         .and_then(|(_, id)| id.parse::<u32>().ok())
         .ok_or_else(|| {
             zvariant::Error::Message(format!("Could not extract the ID from {}", path.as_str()))
@@ -92,7 +90,7 @@ mod tests {
     #[test]
     fn test_get_property() {
         let data: HashMap<String, OwnedValue> = HashMap::from([
-            ("Id".to_string(), (1 as u8).into()),
+            ("Id".to_string(), 1_u8.into()),
             ("Device".to_string(), Str::from_static("/dev/sda").into()),
         ]);
         let id: u8 = get_property(&data, "Id").unwrap();
@@ -104,16 +102,14 @@ mod tests {
 
     #[test]
     fn test_get_property_wrong_type() {
-        let data: HashMap<String, OwnedValue> =
-            HashMap::from([("Id".to_string(), (1 as u8).into())]);
+        let data: HashMap<String, OwnedValue> = HashMap::from([("Id".to_string(), 1_u8.into())]);
         let result: Result<u16, _> = get_property(&data, "Id");
         assert_eq!(result, Err(zvariant::Error::IncorrectType));
     }
 
     #[test]
     fn test_get_optional_property() {
-        let data: HashMap<String, OwnedValue> =
-            HashMap::from([("Id".to_string(), (1 as u8).into())]);
+        let data: HashMap<String, OwnedValue> = HashMap::from([("Id".to_string(), 1_u8.into())]);
         let id: Option<u8> = get_optional_property(&data, "Id").unwrap();
         assert_eq!(id, Some(1));
 

rust/agama-lib/src/software/client.rs

@@ -92,7 +92,7 @@ impl<'a> SoftwareClient<'a> {
             .await?
             .into_iter()
             .filter_map(|(id, reason)| match SelectedBy::try_from(reason) {
-                Ok(reason) if reason == SelectedBy::User => Some(id),
+                Ok(SelectedBy::User) => Some(id),
                 Ok(_reason) => None,
                 Err(e) => {
                     log::warn!("Ignoring pattern {}. Error: {}", &id, e);

rust/agama-lib/src/storage/client/iscsi.rs

@@ -163,7 +163,7 @@ impl<'a> ISCSIClient<'a> {
 
         let result = self
             .initiator_proxy
-            .discover(address, port as u32, options_ref)
+            .discover(address, port, options_ref)
             .await?;
         Ok(result == 0)
     }

rust/agama-lib/src/storage/model.rs

@@ -18,12 +18,9 @@ impl TryFrom<i32> for DeviceSid {
     type Error = zbus::zvariant::Error;
 
     fn try_from(value: i32) -> Result<Self, Self::Error> {
-        u32::try_from(value).map(|v| v.into()).or_else(|_| {
-            Err(Self::Error::Message(format!(
-                "Cannot convert sid from {}",
-                value
-            )))
-        })
+        u32::try_from(value)
+            .map(|v| v.into())
+            .map_err(|_| Self::Error::Message(format!("Cannot convert sid from {}", value)))
     }
 }
 
@@ -48,7 +45,7 @@ impl TryFrom<zbus::zvariant::ObjectPath<'_>> for DeviceSid {
 
     fn try_from(path: zbus::zvariant::ObjectPath) -> Result<Self, Self::Error> {
         path.as_str()
-            .rsplit_once("/")
+            .rsplit_once('/')
             .and_then(|(_, sid)| sid.parse::<u32>().ok())
             .ok_or_else(|| Self::Error::Message(format!("Cannot parse sid from {}", path)))
             .map(DeviceSid)
@@ -68,12 +65,9 @@ impl TryFrom<i64> for DeviceSize {
     type Error = zbus::zvariant::Error;
 
     fn try_from(value: i64) -> Result<Self, Self::Error> {
-        u64::try_from(value).map(|v| v.into()).or_else(|_| {
-            Err(Self::Error::Message(format!(
-                "Cannot convert size from {}",
-                value
-            )))
-        })
+        u64::try_from(value)
+            .map(|v| v.into())
+            .map_err(|_| Self::Error::Message(format!("Cannot convert size from {}", value)))
     }
 }
 
@@ -94,9 +88,9 @@ impl TryFrom<zbus::zvariant::Value<'_>> for DeviceSize {
     }
 }
 
-impl<'a> Into<zbus::zvariant::Value<'a>> for DeviceSize {
-    fn into(self) -> Value<'a> {
-        Value::new(self.0)
+impl<'a> From<DeviceSize> for zbus::zvariant::Value<'a> {
+    fn from(val: DeviceSize) -> Self {
+        Value::new(val.0)
     }
 }
 
@@ -188,11 +182,11 @@ impl TryFrom<zbus::zvariant::Value<'_>> for SpaceActionSettings {
     }
 }
 
-impl<'a> Into<zbus::zvariant::Value<'a>> for SpaceActionSettings {
-    fn into(self) -> zbus::zvariant::Value<'a> {
+impl<'a> From<SpaceActionSettings> for zbus::zvariant::Value<'a> {
+    fn from(val: SpaceActionSettings) -> Self {
         let result: HashMap<&str, Value> = HashMap::from([
-            ("Device", Value::new(self.device)),
-            ("Action", Value::new(self.action.as_dbus_string())),
+            ("Device", Value::new(val.device)),
+            ("Action", Value::new(val.action.as_dbus_string())),
         ]);
 
         Value::new(result)
@@ -218,41 +212,41 @@ pub struct ProposalSettingsPatch {
     pub volumes: Option<Vec<Volume>>,
 }
 
-impl<'a> Into<HashMap<&'static str, Value<'a>>> for ProposalSettingsPatch {
-    fn into(self) -> HashMap<&'static str, Value<'a>> {
+impl<'a> From<ProposalSettingsPatch> for HashMap<&'static str, Value<'a>> {
+    fn from(val: ProposalSettingsPatch) -> Self {
         let mut result = HashMap::new();
-        if let Some(target) = self.target {
+        if let Some(target) = val.target {
             result.insert("Target", Value::new(target.as_dbus_string()));
         }
-        if let Some(dev) = self.target_device {
+        if let Some(dev) = val.target_device {
             result.insert("TargetDevice", Value::new(dev));
         }
-        if let Some(devs) = self.target_pv_devices {
+        if let Some(devs) = val.target_pv_devices {
             result.insert("TargetPVDevices", Value::new(devs));
         }
-        if let Some(value) = self.configure_boot {
+        if let Some(value) = val.configure_boot {
             result.insert("ConfigureBoot", Value::new(value));
         }
-        if let Some(value) = self.boot_device {
+        if let Some(value) = val.boot_device {
             result.insert("BootDevice", Value::new(value));
         }
-        if let Some(value) = self.encryption_password {
+        if let Some(value) = val.encryption_password {
             result.insert("EncryptionPassword", Value::new(value));
         }
-        if let Some(value) = self.encryption_method {
+        if let Some(value) = val.encryption_method {
             result.insert("EncryptionMethod", Value::new(value));
         }
-        if let Some(value) = self.encryption_pbkd_function {
+        if let Some(value) = val.encryption_pbkd_function {
             result.insert("EncryptionPBKDFunction", Value::new(value));
         }
-        if let Some(value) = self.space_policy {
+        if let Some(value) = val.space_policy {
             result.insert("SpacePolicy", Value::new(value));
         }
-        if let Some(value) = self.space_actions {
+        if let Some(value) = val.space_actions {
             let list: Vec<Value> = value.into_iter().map(|a| a.into()).collect();
             result.insert("SpaceActions", Value::new(list));
         }
-        if let Some(value) = self.volumes {
+        if let Some(value) = val.volumes {
             let list: Vec<Value> = value.into_iter().map(|a| a.into()).collect();
             result.insert("Volumes", Value::new(list));
         }
@@ -338,14 +332,14 @@ pub enum VolumeTarget {
     Filesystem,
 }
 
-impl<'a> Into<zbus::zvariant::Value<'a>> for VolumeTarget {
-    fn into(self) -> zbus::zvariant::Value<'a> {
-        let str = match self {
-            Self::Default => "default",
-            Self::NewPartition => "new_partition",
-            Self::NewVg => "new_vg",
-            Self::Device => "device",
-            Self::Filesystem => "filesystem",
+impl<'a> From<VolumeTarget> for zbus::zvariant::Value<'a> {
+    fn from(val: VolumeTarget) -> Self {
+        let str = match val {
+            VolumeTarget::Default => "default",
+            VolumeTarget::NewPartition => "new_partition",
+            VolumeTarget::NewVg => "new_vg",
+            VolumeTarget::Device => "device",
+            VolumeTarget::Filesystem => "filesystem",
         };
 
         Value::new(str)
@@ -419,23 +413,23 @@ pub struct Volume {
     outline: Option<VolumeOutline>,
 }
 
-impl<'a> Into<zbus::zvariant::Value<'a>> for Volume {
-    fn into(self) -> zbus::zvariant::Value<'a> {
+impl<'a> From<Volume> for zbus::zvariant::Value<'a> {
+    fn from(val: Volume) -> Self {
         let mut result: HashMap<&str, Value> = HashMap::from([
-            ("MountPath", Value::new(self.mount_path)),
-            ("MountOptions", Value::new(self.mount_options)),
-            ("Target", self.target.into()),
-            ("FsType", Value::new(self.fs_type)),
-            ("AutoSize", Value::new(self.auto_size)),
-            ("Snapshots", Value::new(self.snapshots)),
+            ("MountPath", Value::new(val.mount_path)),
+            ("MountOptions", Value::new(val.mount_options)),
+            ("Target", val.target.into()),
+            ("FsType", Value::new(val.fs_type)),
+            ("AutoSize", Value::new(val.auto_size)),
+            ("Snapshots", Value::new(val.snapshots)),
         ]);
-        if let Some(dev) = self.target_device {
+        if let Some(dev) = val.target_device {
             result.insert("TargetDevice", Value::new(dev));
         }
-        if let Some(value) = self.min_size {
+        if let Some(value) = val.min_size {
             result.insert("MinSize", value.into());
         }
-        if let Some(value) = self.max_size {
+        if let Some(value) = val.max_size {
             result.insert("MaxSize", value.into());
         }
         // intentionally skip outline as it is not send to dbus and act as read only parameter

rust/agama-server/src/agama-web-server.rs

@@ -351,6 +351,7 @@ fn write_token(path: &str, secret: &str) -> io::Result<()> {
     let token = generate_token(secret);
     let mut file = fs::OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(true)
         .mode(0o400)
         .open(path)?;

rust/agama-server/src/dbus.rs

@@ -150,7 +150,7 @@ impl DBusObjectChangesStream {
             .path(manager_path.clone())?
             .interface("org.freedesktop.DBus.ObjectManager")?
             .build();
-        let stream = MessageStream::for_match_rule(rule, &connection, None).await?;
+        let stream = MessageStream::for_match_rule(rule, connection, None).await?;
         Ok(stream)
     }
 
@@ -168,7 +168,7 @@ impl DBusObjectChangesStream {
             .interface("org.freedesktop.DBus.Properties")?
             .member("PropertiesChanged")?
             .build();
-        let stream = MessageStream::for_match_rule(rule, &connection, None).await?;
+        let stream = MessageStream::for_match_rule(rule, connection, None).await?;
         Ok(stream)
     }
 }
@@ -182,10 +182,10 @@ impl Stream for DBusObjectChangesStream {
             let item = ready!(pinned.inner.as_mut().poll_next(cx));
             let next_value = match item {
                 Some((PROPERTIES_CHANGED, message)) => {
-                    Self::handle_properties_changed(message, &pinned.interface)
+                    Self::handle_properties_changed(message, pinned.interface)
                 }
                 Some((OBJECTS_MANAGER, message)) => {
-                    Self::handle_added_or_removed(message, &pinned.interface)
+                    Self::handle_added_or_removed(message, pinned.interface)
                 }
                 _ => None,
             };
@@ -216,7 +216,7 @@ where
     }
 
     pub fn remove(&mut self, path: &OwnedObjectPath) -> Option<T> {
-        self.objects.remove(&path)
+        self.objects.remove(path)
     }
 }
 

rust/agama-server/src/l10n/dbus.rs

@@ -25,9 +25,9 @@ impl L10nInterface {
                 "The locales list cannot be empty".to_string(),
             ));
         }
-        backend.set_locales(&locales).map_err(|e| {
-            zbus::fdo::Error::Failed(format!("Could not set the locales: {}", e.to_string()))
-        })?;
+        backend
+            .set_locales(&locales)
+            .map_err(|e| zbus::fdo::Error::Failed(format!("Could not set the locales: {}", e)))?;
         Ok(())
     }
 
@@ -59,9 +59,9 @@ impl L10nInterface {
             .parse()
             .map_err(|_e| zbus::fdo::Error::InvalidArgs("Cannot parse keymap ID".to_string()))?;
 
-        backend.set_keymap(keymap_id).map_err(|e| {
-            zbus::fdo::Error::Failed(format!("Could not set the keymap: {}", e.to_string()))
-        })?;
+        backend
+            .set_keymap(keymap_id)
+            .map_err(|e| zbus::fdo::Error::Failed(format!("Could not set the keymap: {}", e)))?;
 
         Ok(())
     }
@@ -76,9 +76,9 @@ impl L10nInterface {
     pub fn set_timezone(&mut self, timezone: &str) -> Result<(), zbus::fdo::Error> {
         let mut backend = self.backend.write().unwrap();
 
-        backend.set_timezone(timezone).map_err(|e| {
-            zbus::fdo::Error::Failed(format!("Could not set the timezone: {}", e.to_string()))
-        })?;
+        backend
+            .set_timezone(timezone)
+            .map_err(|e| zbus::fdo::Error::Failed(format!("Could not set the timezone: {}", e)))?;
         Ok(())
     }
 

rust/agama-server/src/l10n/l10n.rs

@@ -68,7 +68,7 @@ impl L10n {
                 return Err(LocaleError::UnknownLocale(loc.to_string()))?;
             }
         }
-        self.locales = locales.clone();
+        self.locales.clone_from(locales);
         Ok(())
     }
 
@@ -77,7 +77,7 @@ impl L10n {
         if !self.timezones_db.exists(&timezone.to_string()) {
             return Err(LocaleError::UnknownTimezone(timezone.to_string()))?;
         }
-        self.timezone = timezone.to_owned();
+        timezone.clone_into(&mut self.timezone);
         Ok(())
     }
 
@@ -92,7 +92,7 @@ impl L10n {
 
     // TODO: use LocaleError
     pub fn translate(&mut self, locale: &LocaleId) -> Result<(), Error> {
-        helpers::set_service_locale(&locale);
+        helpers::set_service_locale(locale);
         self.timezones_db.read(&locale.language)?;
         self.locales_db.read(&locale.language)?;
         self.ui_locale = locale.clone();

rust/agama-server/src/l10n/locale.rs

@@ -108,8 +108,7 @@ impl LocalesDatabase {
     fn get_locales_list() -> Result<Vec<LocaleId>, Error> {
         const LOCALES_LIST_PATH: &str = "/etc/agama.d/locales";
 
-        let locales = fs::read_to_string(LOCALES_LIST_PATH)
-            .map(|content| Self::get_locales_from_string(content));
+        let locales = fs::read_to_string(LOCALES_LIST_PATH).map(Self::get_locales_from_string);
 
         if let Ok(locales) = locales {
             if !locales.is_empty() {
@@ -123,7 +122,7 @@ impl LocalesDatabase {
             .context("Failed to get the list of locales")?;
 
         let locales = String::from_utf8(result.stdout)
-            .map(|content| Self::get_locales_from_string(content))
+            .map(Self::get_locales_from_string)
             .context("Invalid UTF-8 sequence from list-locales")?;
 
         Ok(locales)