fix: cargo clippy and workflow fix

LeChatP · LeChatP · commit 3d8a94d4b198 · 2025-08-27T02:04:44.000+02:00
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -7,7 +7,8 @@ test-root = [
     "--all-targets",
     "--config",
     "target.\"cfg(all())\".runner=\"/usr/bin/sudo -E\"",
-    "--"
+    "--",
+    "--test-threads=1"
 ]
 
 integration-test = [
@@ -32,6 +33,10 @@ coverage = [
     "build.rs", "xtask/src/*",
     "-e",
     "xtask",
+    "--out", "Html",
+    "--out", "Xml",
+    "--",
+    "--test-threads=1"
 ]
 
 [env]
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -29,7 +29,7 @@ jobs:
       run: cargo xtask dependencies -dip sudo
     
     - name: build integration coverage
-      run: sudo -E /usr/local/cargo/bin/cargo +nightly coverage --out Xml
+      run: sudo -E /usr/local/cargo/bin/cargo +nightly coverage
       env:
         RAR_AUTHENTICATION: skip
         RAR_CFG_PATH: target/rootasrole.json
diff --git a/rar-common/src/database/actor.rs b/rar-common/src/database/actor.rs
@@ -235,35 +235,35 @@ impl<'de: 'a, 'a> Deserialize<'de> for DGroups<'a> {
                 E: serde::de::Error,
             {
                 if let Ok(group) = v.parse() {
-                    return Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))));
+                    Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))))
                 } else {
-                    return Ok(DGroups::Single(DGroupType(DGenericActorType::Name(
+                    Ok(DGroups::Single(DGroupType(DGenericActorType::Name(
                         Cow::Borrowed(v),
-                    ))));
+                    ))))
                 }
             }
 
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
                 where
                     E: serde::de::Error, {
                 if let Ok(group) = v.parse() {
-                    return Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))));
+                    Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))))
                 } else {
-                    return Ok(DGroups::Single(DGroupType(DGenericActorType::Name(
+                    Ok(DGroups::Single(DGroupType(DGenericActorType::Name(
                         Cow::Owned(v.to_string()),
-                    ))));
+                    ))))
                 }
             }
 
             fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
                 where
                     E: serde::de::Error, {
                 if let Ok(group) = v.parse() {
-                    return Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))));
+                    Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))))
                 } else {
-                    return Ok(DGroups::Single(DGroupType(DGenericActorType::Name(
+                    Ok(DGroups::Single(DGroupType(DGenericActorType::Name(
                         v.into(),
-                    ))));
+                    ))))
                 }
             }
 
@@ -318,35 +318,35 @@ impl<'de: 'a, 'a> Deserialize<'de> for SGroups {
                 E: serde::de::Error,
             {
                 if let Ok(group) = v.parse() {
-                    return Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))));
+                    Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))))
                 } else {
-                    return Ok(SGroups::Single(SGroupType(SGenericActorType::Name(
+                    Ok(SGroups::Single(SGroupType(SGenericActorType::Name(
                         v.to_string(),
-                    ))));
+                    ))))
                 }
             }
 
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
                 where
                     E: serde::de::Error, {
                 if let Ok(group) = v.parse() {
-                    return Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))));
+                    Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))))
                 } else {
-                    return Ok(SGroups::Single(SGroupType(SGenericActorType::Name(
+                    Ok(SGroups::Single(SGroupType(SGenericActorType::Name(
                         v.into(),
-                    ))));
+                    ))))
                 }
             }
 
             fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
                 where
                     E: serde::de::Error, {
                 if let Ok(group) = v.parse() {
-                    return Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))));
+                    Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))))
                 } else {
-                    return Ok(SGroups::Single(SGroupType(SGenericActorType::Name(
+                    Ok(SGroups::Single(SGroupType(SGenericActorType::Name(
                         v,
-                    ))));
+                    ))))
                 }
             }
 
@@ -405,7 +405,7 @@ impl<'a> From<&'a str> for DUserType<'a> {
     }
 }
 
-impl<'a> From<String> for DUserType<'a> {
+impl From<String> for DUserType<'_> {
     fn from(name: String) -> Self {
         DUserType(DGenericActorType::Name(name.into()))
     }
@@ -463,7 +463,7 @@ impl<'a> From<&'a str> for DGenericActorType<'a> {
     }
 }
 
-impl<'a> From<u32> for DGenericActorType<'a> {
+impl From<u32> for DGenericActorType<'_> {
     fn from(name: u32) -> Self {
         DGenericActorType::Id(name)
     }
diff --git a/rar-common/src/database/de.rs b/rar-common/src/database/de.rs
@@ -24,7 +24,7 @@ impl<'de> Deserialize<'de> for SetBehavior {
     {
         struct SetBehaviorVisitor;
 
-        impl<'de> Visitor<'de> for SetBehaviorVisitor {
+        impl Visitor<'_> for SetBehaviorVisitor {
             type Value = SetBehavior;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
diff --git a/rar-common/src/database/migration.rs b/rar-common/src/database/migration.rs
@@ -199,43 +199,38 @@ mod tests {
                 },
             },
         ];
-        assert_eq!(
-            Migration::migrate(&Version::parse("1.0.0").unwrap(), &mut doc, &migrations).unwrap(),
-            true
+        assert!(
+            Migration::migrate(&Version::parse("1.0.0").unwrap(), &mut doc, &migrations).unwrap()
         );
         assert_eq!(doc, 3);
         doc = 0;
-        assert_eq!(
-            Migration::migrate(&Version::parse("2.0.0").unwrap(), &mut doc, &migrations).unwrap(),
-            true
+        assert!(
+            Migration::migrate(&Version::parse("2.0.0").unwrap(), &mut doc, &migrations).unwrap()
         );
         assert_eq!(doc, 2);
         doc = 0;
-        assert_eq!(
+        assert!(
             Migration::migrate(
                 &Version::parse("3.0.0-alpha.1").unwrap(),
                 &mut doc,
                 &migrations
             )
-            .unwrap(),
-            true
+            .unwrap()
         );
         assert_eq!(doc, 1);
         doc = 0;
-        assert_eq!(
-            Migration::migrate(&Version::parse("4.0.0").unwrap(), &mut doc, &migrations).unwrap(),
-            true
+        assert!(
+            Migration::migrate(&Version::parse("4.0.0").unwrap(), &mut doc, &migrations).unwrap()
         );
         assert_eq!(doc, -1);
         doc = 0;
-        assert_eq!(
-            Migration::migrate(
+        assert!(
+            !Migration::migrate(
                 &Version::parse(PACKAGE_VERSION).unwrap(),
                 &mut doc,
                 &migrations
             )
-            .unwrap(),
-            false
+            .unwrap()
         );
         assert_eq!(doc, 0);
     }
diff --git a/rar-common/src/database/options.rs b/rar-common/src/database/options.rs
@@ -309,7 +309,7 @@ impl Opt {
                         .split(',')
                         .filter(|s| {
                             #[cfg(feature = "pcre2")]
-                            return is_valid_env_name(&s) || is_regex(&s);
+                            return is_valid_env_name(s) || is_regex(s);
                             #[cfg(not(feature = "pcre2"))]
                             is_valid_env_name(&s)
                         })
@@ -482,7 +482,7 @@ impl EnvSet for LinkedHashSet<EnvKey> {
 
 impl EnvSet for Option<LinkedHashSet<EnvKey>> {
     fn env_matches(&self, needle: &EnvKey) -> bool {
-        self.as_ref().map_or(false, |set| set.env_matches(needle))
+        self.as_ref().is_some_and(|set| set.env_matches(needle))
     }
 }
 
diff --git a/rar-common/src/database/ser.rs b/rar-common/src/database/ser.rs
@@ -85,9 +85,9 @@ impl Serialize for SetBehavior {
         S: serde::Serializer,
     {
         if serializer.is_human_readable() {
-            return serializer.serialize_str(&self.to_string());
+            serializer.serialize_str(&self.to_string())
         } else {
-            return serializer.serialize_u32(*self as u32);
+            serializer.serialize_u32(*self as u32)
         }
     }
 }
@@ -180,36 +180,34 @@ impl Serialize for SCapabilities {
     {
         if self.default_behavior.is_none() && self.sub.is_empty() {
             super::serialize_capset(&self.add, serializer)
+        } else if serializer.is_human_readable() {
+            let mut map = serializer.serialize_map(Some(3))?;
+            if self.default_behavior.is_all() {
+                map.serialize_entry("default", &self.default_behavior)?;
+            }
+            if !self.add.is_empty() {
+                let v: Vec<String> = self.add.iter().map(|cap| cap.to_string()).collect();
+                map.serialize_entry("add", &v)?;
+            }
+            if !self.sub.is_empty() {
+                let v: Vec<String> = self.sub.iter().map(|cap| cap.to_string()).collect();
+                map.serialize_entry("del", &v)?;
+            }
+            map.end()
         } else {
-            if serializer.is_human_readable() {
-                let mut map = serializer.serialize_map(Some(3))?;
-                if self.default_behavior.is_all() {
-                    map.serialize_entry("default", &self.default_behavior)?;
-                }
-                if !self.add.is_empty() {
-                    let v: Vec<String> = self.add.iter().map(|cap| cap.to_string()).collect();
-                    map.serialize_entry("add", &v)?;
-                }
-                if !self.sub.is_empty() {
-                    let v: Vec<String> = self.sub.iter().map(|cap| cap.to_string()).collect();
-                    map.serialize_entry("del", &v)?;
-                }
-                map.end()
-            } else {
-                let mut map = serializer.serialize_map(Some(3))?;
-                if self.default_behavior.is_all() {
-                    map.serialize_entry("d", &(self.default_behavior as u32))?;
-                }
-                if !self.add.is_empty() {
-                    let v: Vec<String> = self.add.iter().map(|cap| cap.to_string()).collect();
-                    map.serialize_entry("a", &v)?;
-                }
-                if !self.sub.is_empty() {
-                    let v: Vec<String> = self.sub.iter().map(|cap| cap.to_string()).collect();
-                    map.serialize_entry("s", &v)?;
-                }
-                map.end()
+            let mut map = serializer.serialize_map(Some(3))?;
+            if self.default_behavior.is_all() {
+                map.serialize_entry("d", &(self.default_behavior as u32))?;
+            }
+            if !self.add.is_empty() {
+                let v: Vec<String> = self.add.iter().map(|cap| cap.to_string()).collect();
+                map.serialize_entry("a", &v)?;
             }
+            if !self.sub.is_empty() {
+                let v: Vec<String> = self.sub.iter().map(|cap| cap.to_string()).collect();
+                map.serialize_entry("s", &v)?;
+            }
+            map.end()
         }
     }
 }
@@ -422,7 +420,7 @@ mod tests {
     #[test]
     fn test_setbehavior_serialize() {
         let b = SetBehavior::All;
-        let value = to_value(&b).unwrap();
+        let value = to_value(b).unwrap();
         assert_eq!(value, json!("all"));
         let b = SetBehavior::None;
         let bin: Vec<u8> = Vec::new();
diff --git a/rar-common/src/lib.rs b/rar-common/src/lib.rs
@@ -281,7 +281,7 @@ impl<'de> Deserialize<'de> for FullSettings {
                 // If we have config fields, deserialize them into SConfig
                 let config = if !config_fields.is_empty() {
                     let config_value = serde_json::Value::Object(
-                        config_fields.into_iter().map(|(k, v)| (k, v)).collect(),
+                        config_fields.into_iter().collect(),
                     );
                     Some(Rc::new(RefCell::new(
                         SConfig::deserialize(config_value).map_err(serde::de::Error::custom)?,
@@ -328,20 +328,20 @@ impl LockedSettingsFile {
         if write && path.as_ref().exists() {
             let mut file = read_with_privileges(&path)?;
             if is_immutable(&file)? {
-                return Ok(with_mutable_config(&mut file, |_| {
+                return with_mutable_config(&mut file, |_| {
                     let file = open_lock_with_privileges(
                         path.as_ref(),
                         options,
                         nix::fcntl::FlockArg::LockExclusive,
                     )?;
 
-                    return Ok(LockedSettingsFile {
+                    Ok(LockedSettingsFile {
                         path: path.as_ref().to_path_buf(),
-                        data: load_full_settings(&path, &file.deref())
+                        data: load_full_settings(&path, file.deref())
                             .unwrap_or(Rc::new(RefCell::new(FullSettings::default()))),
                         fd: file,
-                    });
-                })?);
+                    })
+                });
             }
         }
 
@@ -350,7 +350,7 @@ impl LockedSettingsFile {
 
         Ok(LockedSettingsFile {
             path: path.as_ref().to_path_buf(),
-            data: load_full_settings(&path, &file.deref())
+            data: load_full_settings(&path, file.deref())
                 .unwrap_or(Rc::new(RefCell::new(FullSettings::default()))),
             fd: file,
         })
@@ -419,9 +419,9 @@ impl LockedSettingsFile {
         T: AsRef<Path>,
     {
         {
-            let storage_method = self.data.as_ref().borrow().storage.method.clone();
+            let storage_method = self.data.as_ref().borrow().storage.method;
             let binding = self.data.as_ref().borrow_mut();
-            let config = binding.config.as_ref().take().unwrap();
+            let config = binding.config.as_ref().unwrap();
             let versioned_config: Versioning<Rc<RefCell<SConfig>>> =
                 Versioning::new(config.clone());
             let mut file = open_lock_with_privileges(
@@ -699,15 +699,15 @@ mod tests {
             let filename = PathBuf::from(test_file_path)
                 .canonicalize()
                 .unwrap_or(test_file_path.into());
-            if std::fs::remove_file(&test_file_path).is_err() {
+            if std::fs::remove_file(test_file_path).is_err() {
                 debug!("Failed to delete the file: {}", filename.display());
             }
         });
         let _cleanup2 = defer(|| {
             let filename = PathBuf::from(external_file_path)
                 .canonicalize()
                 .unwrap_or(external_file_path.into());
-            if std::fs::remove_file(&external_file_path).is_err() {
+            if std::fs::remove_file(external_file_path).is_err() {
                 debug!("Failed to delete the file: {}", filename.display());
             }
         });
diff --git a/rar-common/src/util.rs b/rar-common/src/util.rs
diff --git a/xtask/src/configure.rs b/xtask/src/configure.rs
diff --git a/xtask/src/installer/uninstall.rs b/xtask/src/installer/uninstall.rs
diff --git a/xtask/src/util.rs b/xtask/src/util.rs

Original file line number	Diff line number	Diff line change
`@@ -235,35 +235,35 @@ impl<'de: 'a, 'a> Deserialize<'de> for DGroups<'a> {`
`235`	`235`	`E: serde::de::Error,`
`236`	`236`	`{`
`237`	`237`	`if let Ok(group) = v.parse() {`
`238`		`- return Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))));`
	`238`	`+ Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))))`
`239`	`239`	`} else {`
`240`		`- return Ok(DGroups::Single(DGroupType(DGenericActorType::Name(`
	`240`	`+ Ok(DGroups::Single(DGroupType(DGenericActorType::Name(`
`241`	`241`	`Cow::Borrowed(v),`
`242`		`- ))));`
	`242`	`+ ))))`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>`
`247`	`247`	`where`
`248`	`248`	`E: serde::de::Error, {`
`249`	`249`	`if let Ok(group) = v.parse() {`
`250`		`- return Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))));`
	`250`	`+ Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))))`
`251`	`251`	`} else {`
`252`		`- return Ok(DGroups::Single(DGroupType(DGenericActorType::Name(`
	`252`	`+ Ok(DGroups::Single(DGroupType(DGenericActorType::Name(`
`253`	`253`	`Cow::Owned(v.to_string()),`
`254`		`- ))));`
	`254`	`+ ))))`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`fn visit_string<E>(self, v: String) -> Result<Self::Value, E>`
`259`	`259`	`where`
`260`	`260`	`E: serde::de::Error, {`
`261`	`261`	`if let Ok(group) = v.parse() {`
`262`		`- return Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))));`
	`262`	`+ Ok(DGroups::Single(DGroupType(DGenericActorType::Id(group))))`
`263`	`263`	`} else {`
`264`		`- return Ok(DGroups::Single(DGroupType(DGenericActorType::Name(`
	`264`	`+ Ok(DGroups::Single(DGroupType(DGenericActorType::Name(`
`265`	`265`	`v.into(),`
`266`		`- ))));`
	`266`	`+ ))))`
`267`	`267`	`}`
`268`	`268`	`}`
`269`	`269`
`@@ -318,35 +318,35 @@ impl<'de: 'a, 'a> Deserialize<'de> for SGroups {`
`318`	`318`	`E: serde::de::Error,`
`319`	`319`	`{`
`320`	`320`	`if let Ok(group) = v.parse() {`
`321`		`- return Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))));`
	`321`	`+ Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))))`
`322`	`322`	`} else {`
`323`		`- return Ok(SGroups::Single(SGroupType(SGenericActorType::Name(`
	`323`	`+ Ok(SGroups::Single(SGroupType(SGenericActorType::Name(`
`324`	`324`	`v.to_string(),`
`325`		`- ))));`
	`325`	`+ ))))`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>`
`330`	`330`	`where`
`331`	`331`	`E: serde::de::Error, {`
`332`	`332`	`if let Ok(group) = v.parse() {`
`333`		`- return Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))));`
	`333`	`+ Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))))`
`334`	`334`	`} else {`
`335`		`- return Ok(SGroups::Single(SGroupType(SGenericActorType::Name(`
	`335`	`+ Ok(SGroups::Single(SGroupType(SGenericActorType::Name(`
`336`	`336`	`v.into(),`
`337`		`- ))));`
	`337`	`+ ))))`
`338`	`338`	`}`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`fn visit_string<E>(self, v: String) -> Result<Self::Value, E>`
`342`	`342`	`where`
`343`	`343`	`E: serde::de::Error, {`
`344`	`344`	`if let Ok(group) = v.parse() {`
`345`		`- return Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))));`
	`345`	`+ Ok(SGroups::Single(SGroupType(SGenericActorType::Id(group))))`
`346`	`346`	`} else {`
`347`		`- return Ok(SGroups::Single(SGroupType(SGenericActorType::Name(`
	`347`	`+ Ok(SGroups::Single(SGroupType(SGenericActorType::Name(`
`348`	`348`	`v,`
`349`		`- ))));`
	`349`	`+ ))))`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`
`@@ -405,7 +405,7 @@ impl<'a> From<&'a str> for DUserType<'a> {`
`405`	`405`	`}`
`406`	`406`	`}`
`407`	`407`
`408`		`-impl<'a> From<String> for DUserType<'a> {`
	`408`	`+impl From<String> for DUserType<'_> {`
`409`	`409`	`fn from(name: String) -> Self {`
`410`	`410`	`DUserType(DGenericActorType::Name(name.into()))`
`411`	`411`	`}`
`@@ -463,7 +463,7 @@ impl<'a> From<&'a str> for DGenericActorType<'a> {`
`463`	`463`	`}`
`464`	`464`	`}`
`465`	`465`
`466`		`-impl<'a> From<u32> for DGenericActorType<'a> {`
	`466`	`+impl From<u32> for DGenericActorType<'_> {`
`467`	`467`	`fn from(name: u32) -> Self {`
`468`	`468`	`DGenericActorType::Id(name)`
`469`	`469`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ impl<'de> Deserialize<'de> for SetBehavior {`
`24`	`24`	`{`
`25`	`25`	`struct SetBehaviorVisitor;`
`26`	`26`
`27`		`- impl<'de> Visitor<'de> for SetBehaviorVisitor {`
	`27`	`+ impl Visitor<'_> for SetBehaviorVisitor {`
`28`	`28`	`type Value = SetBehavior;`
`29`	`29`
`30`	`30`	`fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`