fixup: clippy errors

Signed-off-by: Philip H. <[email protected]>

Author: pheiduck

src/config.rs

@@ -185,7 +185,7 @@ impl fmt::Display for Device {
         if self.zram_fraction.is_some() || self.max_zram_size_mb.is_some() {
             f.write_str(" (")?;
             if let Some(zf) = self.zram_fraction {
-                write!(f, "zram-fraction={}", zf)?;
+                write!(f, "zram-fraction={zf}")?;
             }
             if self.max_zram_size_mb.is_some() {
                 f.write_str(" ")?;
@@ -203,7 +203,7 @@ struct OptMB(Option<u64>);
 impl fmt::Display for OptMB {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.0 {
-            Some(val) => write!(f, "{}MB", val),
+            Some(val) => write!(f, "{val}MB"),
             None => f.write_str("<none>"),
         }
     }
@@ -221,12 +221,12 @@ impl fmt::Display for Algorithms {
             [(first, firstparams), more @ ..] => {
                 f.write_str(first)?;
                 if !firstparams.is_empty() {
-                    write!(f, " ({})", firstparams)?;
+                    write!(f, " ({firstparams})")?;
                 }
                 for (algo, params) in more {
-                    write!(f, " then {}", algo)?;
+                    write!(f, " then {algo}")?;
                     if !params.is_empty() {
-                        write!(f, " ({})", params)?;
+                        write!(f, " ({params})")?;
                     }
                 }
             }
@@ -302,7 +302,7 @@ fn toplevel_line(
                 .code()
                 .unwrap_or_else(|| 128 + out.status.signal().unwrap());
             if exit != 0 {
-                warn!("{}: {} exited {}", k, val, exit);
+                warn!("{k}: {val} exited {exit}");
             }
 
             let expr = String::from_utf8(out.stdout)
@@ -416,15 +416,15 @@ fn parse_optional_size(val: &str) -> Result<Option<u64>> {
     } else {
         Some(
             val.parse()
-                .with_context(|| format!("Failed to parse optional size \"{}\"", val))?,
+                .with_context(|| format!("Failed to parse optional size \"{val}\""))?,
         )
     })
 }
 
 fn parse_swap_priority(val: &str) -> Result<i32> {
     let val = val
         .parse()
-        .with_context(|| format!("Failed to parse priority \"{}\"", val))?;
+        .with_context(|| format!("Failed to parse priority \"{val}\""))?;
 
     /* See --priority in swapon(8). */
     match val {
@@ -531,7 +531,7 @@ fn parse_line(dev: &mut Device, key: &str, value: &str) -> Result<()> {
             dev.zram_fraction = Some(
                 value
                     .parse()
-                    .with_context(|| format!("Failed to parse zram-fraction \"{}\"", value))
+                    .with_context(|| format!("Failed to parse zram-fraction \"{value}\""))
                     .and_then(|f| {
                         if f >= 0. {
                             Ok(f)
@@ -607,7 +607,7 @@ pub fn kernel_zram_option(root: &Path) -> Option<bool> {
             Some(false)
         }
         Err(e) => {
-            warn!("Failed to parse /proc/cmdline ({}), ignoring.", e);
+            warn!("Failed to parse /proc/cmdline ({e}), ignoring.");
             None
         }
     }

src/generator.rs

@@ -34,10 +34,7 @@ fn virtualization_container() -> Result<bool> {
     {
         Ok(child) => child,
         Err(e) => {
-            warn!(
-                "systemd-detect-virt call failed, assuming we're not in a container: {}",
-                e
-            );
+            warn!("systemd-detect-virt call failed, assuming we're not in a container: {e}");
             return Ok(false);
         }
     };
@@ -58,14 +55,12 @@ fn modprobe(modname: &str, required: bool) {
 
             log!(
                 level,
-                "modprobe \"{}\" cannot be spawned, ignoring: {}",
-                modname,
-                e
+                "modprobe \"{modname}\" cannot be spawned, ignoring: {e}"
             );
         }
         Ok(status) => {
             if !status.success() {
-                warn!("modprobe \"{}\" failed, ignoring: code {}", modname, status);
+                warn!("modprobe \"{modname}\" failed, ignoring: code {status}");
             }
         }
     };
@@ -101,10 +96,7 @@ pub fn run_generator(devices: &[Device], output_directory: &Path, fake_mode: boo
             })
             .fold(0, cmp::max);
 
-        if !Path::new("/dev")
-            .join(format!("zram{}", max_device))
-            .exists()
-        {
+        if !Path::new("/dev").join(format!("zram{max_device}")).exists() {
             while fs::read_to_string("/sys/class/zram-control/hot_add")
                 .context("Adding zram device")?
                 .trim_end()
@@ -128,13 +120,13 @@ pub fn run_generator(devices: &[Device], output_directory: &Path, fake_mode: boo
 
     if !compressors.is_empty() {
         let proc_crypto = fs::read_to_string("/proc/crypto").unwrap_or_else(|e| {
-            warn!("Failed to read /proc/crypto, proceeding as if empty: {}", e);
+            warn!("Failed to read /proc/crypto, proceeding as if empty: {e}");
             String::new()
         });
         let known = parse_known_compressors(&proc_crypto);
 
         for comp in compressors.difference(&known) {
-            modprobe(&format!("crypto-{}", comp), false);
+            modprobe(&format!("crypto-{comp}"), false);
         }
     }
 
@@ -257,7 +249,7 @@ Options={options}
 
     /* enablement symlink */
     let symlink_path = output_directory.join("swap.target.wants").join(&swap_name);
-    let target_path = format!("../{}", swap_name);
+    let target_path = format!("../{swap_name}");
     make_symlink(&target_path, &symlink_path)?;
 
     Ok(())
@@ -271,7 +263,7 @@ fn unit_name_from_path(path: &Path, suffix: &str) -> String {
 
     let trimmed = path.to_str().unwrap().trim_matches('/');
     if trimmed.is_empty() {
-        format!("-{}", suffix)
+        format!("-{suffix}")
     } else {
         let mut obuf = Vec::with_capacity(path.as_os_str().len() + suffix.len());
         let mut just_slash = false;
@@ -284,7 +276,7 @@ fn unit_name_from_path(path: &Path, suffix: &str) -> String {
                 b'/' => obuf.push(b'-'),
                 b'.' if i == 0 => write!(obuf, "\\x{:02x}", b'.').unwrap(),
                 b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b':' | b'_' | b'.' => obuf.push(b),
-                _ => write!(obuf, "\\x{:02x}", b).unwrap(),
+                _ => write!(obuf, "\\x{b:02x}").unwrap(),
             }
         }
         obuf.extend_from_slice(suffix.as_bytes());
@@ -335,7 +327,7 @@ Options={options}
     let symlink_path = output_directory
         .join("local-fs.target.wants")
         .join(mount_name);
-    let target_path = format!("../{}", mount_name);
+    let target_path = format!("../{mount_name}");
     make_symlink(&target_path, &symlink_path)?;
 
     Ok(())

src/setup.rs

@@ -47,18 +47,18 @@ pub fn run_device_setup(device: Option<Device>, device_name: &str) -> Result<()>
                 params.as_ref().map(|p| {
                     (
                         device_sysfs_path.join("algorithm_params"),
-                        format!("algo={} {}", algo, p),
+                        format!("algo={algo} {p}"),
                     )
                 }),
             )
         } else {
             (
                 device_sysfs_path.join("recomp_algorithm"),
-                &format!("algo={} priority={}", algo, prio),
+                &format!("algo={algo} priority={prio}"),
                 params.as_ref().map(|p| {
                     (
                         device_sysfs_path.join("recompress"),
-                        format!("{} priority={}", p, prio),
+                        format!("{p} priority={prio}"),
                     )
                 }),
             )
@@ -71,8 +71,7 @@ pub fn run_device_setup(device: Option<Device>, device_name: &str) -> Result<()>
                         Ok(_) => {}
                         Err(err) => {
                             warn!(
-                                "Warning: algorithm {:?} supplemental data {:?} not written: {}",
-                                algo, data, err,
+                                "Warning: algorithm {algo:?} supplemental data {data:?} not written: {err}",
                             );
                         }
                     }
@@ -143,9 +142,7 @@ pub fn run_device_setup(device: Option<Device>, device_name: &str) -> Result<()>
         Err(e) =>
             Err(e).with_context(|| {
                 format!(
-                    "{} call failed for /dev/{}",
-                    SYSTEMD_MAKEFS_COMMAND,
-                    device_name
+                    "{SYSTEMD_MAKEFS_COMMAND} call failed for /dev/{device_name}"
                 )
             }),
     }