treewide: format with new formatter rules

Author: NotAShelf

src/check.rs

@@ -1,8 +1,13 @@
-use std::cmp::Ordering;
-use std::env;
-use std::sync::Mutex;
-
-use color_eyre::{eyre, Result};
+use std::{
+    cmp::Ordering,
+    env,
+    sync::Mutex,
+};
+
+use color_eyre::{
+    eyre,
+    Result,
+};
 use semver::Version;
 
 use crate::util;
@@ -56,7 +61,7 @@ pub fn check_nix_version() -> Result<()> {
                 version,
                 min_version
             ))
-        }
+        },
         _ => Ok(()),
     }
 }
@@ -85,19 +90,16 @@ pub fn check_nix_features() -> Result<()> {
         Ok(enabled_features) => {
             let features_vec: Vec<_> = enabled_features.into_iter().collect();
             tracing::debug!("Enabled Nix features: {}", features_vec.join(", "));
-        }
+        },
         Err(e) => {
             tracing::warn!("Failed to get enabled Nix features: {}", e);
-        }
+        },
     }
 
     let missing_features = util::get_missing_experimental_features(&required_features)?;
 
     if !missing_features.is_empty() {
-        tracing::warn!(
-            "Missing required Nix features: {}",
-            missing_features.join(", ")
-        );
+        tracing::warn!("Missing required Nix features: {}", missing_features.join(", "));
         return Err(eyre::eyre!(
             "Missing required experimental features. Please enable: {}",
             missing_features.join(", ")
@@ -112,7 +114,8 @@ pub fn check_nix_features() -> Result<()> {
 ///
 /// # Returns
 ///
-/// * `Result<bool>` - True if a warning should be shown about the FLAKE variable, false otherwise
+/// * `Result<bool>` - True if a warning should be shown about the FLAKE
+///   variable, false otherwise
 pub fn setup_environment() -> Result<bool> {
     let mut do_warn = false;
 
@@ -135,9 +138,9 @@ pub fn setup_environment() -> Result<bool> {
     Ok(do_warn)
 }
 
-/// Consolidate all necessary checks for Nix functionality into a single function. This
-/// will be executed in the main function, but can be executed before critical commands
-/// to double-check if necessary.
+/// Consolidate all necessary checks for Nix functionality into a single
+/// function. This will be executed in the main function, but can be executed
+/// before critical commands to double-check if necessary.
 ///
 /// # Returns
 ///
@@ -153,8 +156,8 @@ pub fn verify_nix_environment() -> Result<()> {
 }
 
 // Environment variables are global state, so tests need to be run sequentially.
-// Using a mutex to ensure that env var manipulation in one test doesn't affect others.
-// Alternatively, run tests with `cargo test -- --test-threads=1`
+// Using a mutex to ensure that env var manipulation in one test doesn't affect
+// others. Alternatively, run tests with `cargo test -- --test-threads=1`
 #[allow(dead_code)] // suppress 'false' positives
 static ENV_LOCK: Mutex<()> = Mutex::new(());
 

src/clean.rs

@@ -1,30 +1,54 @@
 use std::{
-    collections::{BTreeMap, HashMap},
+    collections::{
+        BTreeMap,
+        HashMap,
+    },
     fmt,
-    path::{Path, PathBuf},
+    path::{
+        Path,
+        PathBuf,
+    },
     time::SystemTime,
 };
 
-use color_eyre::eyre::{bail, eyre, Context, ContextCompat};
-use nix::errno::Errno;
+use color_eyre::eyre::{
+    bail,
+    eyre,
+    Context,
+    ContextCompat,
+};
 use nix::{
+    errno::Errno,
     fcntl::AtFlags,
-    unistd::{faccessat, AccessFlags},
+    unistd::{
+        faccessat,
+        AccessFlags,
+    },
 };
 use regex::Regex;
-use tracing::{debug, info, instrument, span, warn, Level};
+use tracing::{
+    debug,
+    info,
+    instrument,
+    span,
+    warn,
+    Level,
+};
 use uzers::os::unix::UserExt;
 
-use crate::{commands::Command, *};
+use crate::{
+    commands::Command,
+    Result, interface,
+};
 
 // Nix impl:
 // https://github.com/NixOS/nix/blob/master/src/nix-collect-garbage/nix-collect-garbage.cc
 
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 struct Generation {
-    number: u32,
+    number:        u32,
     last_modified: SystemTime,
-    path: PathBuf,
+    path:          PathBuf,
 }
 
 type ToBeRemoved = bool;
@@ -42,12 +66,12 @@ impl interface::CleanMode {
         // What profiles to clean depending on the call mode
         let uid = nix::unistd::Uid::effective();
         let args = match self {
-            interface::CleanMode::Profile(args) => {
+            Self::Profile(args) => {
                 profiles.push(args.profile.clone());
                 is_profile_clean = true;
                 &args.common
-            }
-            interface::CleanMode::All(args) => {
+            },
+            Self::All(args) => {
                 if !uid.is_root() {
                     crate::self_elevate();
                 }
@@ -57,22 +81,20 @@ impl interface::CleanMode {
                     profiles.extend(profiles_in_dir(path));
                 }
 
-                // Most unix systems start regular users at uid 1000+, but macos is special at 501+
-                // https://en.wikipedia.org/wiki/User_identifier
+                // Most unix systems start regular users at uid 1000+, but macos is special at
+                // 501+ https://en.wikipedia.org/wiki/User_identifier
                 let uid_min = if cfg!(target_os = "macos") { 501 } else { 1000 };
                 let uid_max = uid_min + 100;
                 debug!("Scanning XDG profiles for users 0, ${uid_min}-${uid_max}");
                 for user in unsafe { uzers::all_users() } {
                     if user.uid() >= uid_min && user.uid() < uid_max || user.uid() == 0 {
                         debug!(?user, "Adding XDG profiles for user");
-                        profiles.extend(profiles_in_dir(
-                            user.home_dir().join(".local/state/nix/profiles"),
-                        ));
+                        profiles.extend(profiles_in_dir(user.home_dir().join(".local/state/nix/profiles")));
                     }
                 }
                 args
-            }
-            interface::CleanMode::User(args) => {
+            },
+            Self::User(args) => {
                 if uid.is_root() {
                     bail!("nh clean user: don't run me as root!");
                 }
@@ -84,16 +106,13 @@ impl interface::CleanMode {
                     PathBuf::from("/nix/var/nix/profiles/per-user").join(user.name),
                 ));
                 args
-            }
+            },
         };
 
         // Use mutation to raise errors as they come
         let mut profiles_tagged = ProfilesTagged::new();
         for p in profiles {
-            profiles_tagged.insert(
-                p.clone(),
-                cleanable_generations(&p, args.keep, args.keep_since)?,
-            );
+            profiles_tagged.insert(p.clone(), cleanable_generations(&p, args.keep, args.keep_since)?);
         }
 
         // Query gcroots
@@ -114,10 +133,7 @@ impl interface::CleanMode {
                 let _entered = span.enter();
                 debug!(?src);
 
-                if !regexes
-                    .iter()
-                    .any(|next| next.is_match(&dst.to_string_lossy()))
-                {
+                if !regexes.iter().any(|next| next.is_match(&dst.to_string_lossy())) {
                     debug!("dst doesn't match any gcroot regex, skipping");
                     continue;
                 };
@@ -129,12 +145,14 @@ impl interface::CleanMode {
                     AccessFlags::F_OK | AccessFlags::W_OK,
                     AtFlags::AT_SYMLINK_NOFOLLOW,
                 ) {
-                    Ok(_) => true,
-                    Err(errno) => match errno {
-                        Errno::EACCES | Errno::ENOENT => false,
-                        _ => {
-                            bail!(eyre!("Checking access for gcroot {:?}, unknown error", dst)
-                                .wrap_err(errno))
+                    Ok(()) => true,
+                    Err(errno) => {
+                        match errno {
+                            Errno::EACCES | Errno::ENOENT => false,
+                            _ => {
+                                bail!(eyre!("Checking access for gcroot {:?}, unknown error", dst)
+                                    .wrap_err(errno))
+                            },
                         }
                     },
                 } {
@@ -147,13 +165,13 @@ impl interface::CleanMode {
                     match dur {
                         Err(err) => {
                             warn!(?err, ?now, "Failed to compare time!");
-                        }
+                        },
                         Ok(val) if val <= args.keep_since.into() => {
                             gcroots_tagged.insert(dst, false);
-                        }
+                        },
                         Ok(_) => {
                             gcroots_tagged.insert(dst, true);
-                        }
+                        },
                     }
                 } else {
                     debug!("dst doesn't exist or is not writable, skipping");
@@ -175,9 +193,7 @@ impl interface::CleanMode {
         if !gcroots_tagged.is_empty() {
             println!(
                 "{}",
-                "gcroots (matching the following regex patterns)"
-                    .blue()
-                    .bold()
+                "gcroots (matching the following regex patterns)".blue().bold()
             );
             for re in regexes {
                 println!("- {}  {}", "RE".purple(), re);
@@ -191,7 +207,7 @@ impl interface::CleanMode {
             }
             println!();
         }
-        for (profile, generations_tagged) in profiles_tagged.iter() {
+        for (profile, generations_tagged) in &profiles_tagged {
             println!("{}", profile.to_string_lossy().blue().bold());
             for (gen, tbr) in generations_tagged.iter().rev() {
                 if *tbr {
@@ -218,7 +234,7 @@ impl interface::CleanMode {
                 }
             }
 
-            for (_, generations_tagged) in profiles_tagged.iter() {
+            for generations_tagged in profiles_tagged.values() {
                 for (gen, tbr) in generations_tagged.iter().rev() {
                     if *tbr {
                         remove_path_nofail(&gen.path);
@@ -252,27 +268,24 @@ fn profiles_in_dir<P: AsRef<Path> + fmt::Debug>(dir: P) -> Vec<PathBuf> {
                         let path = e.path();
 
                         if let Ok(dst) = path.read_link() {
-                            let name = dst
-                                .file_name()
-                                .expect("Failed to get filename")
-                                .to_string_lossy();
+                            let name = dst.file_name().expect("Failed to get filename").to_string_lossy();
 
                             let generation_regex = Regex::new(r"^(.*)-(\d+)-link$").unwrap();
 
                             if generation_regex.captures(&name).is_some() {
                                 res.push(path);
                             }
                         }
-                    }
+                    },
                     Err(error) => {
                         warn!(?dir, ?error, "Failed to read folder element");
-                    }
+                    },
                 }
             }
-        }
+        },
         Err(error) => {
             warn!(?dir, ?error, "Failed to read profiles directory");
-        }
+        },
     }
 
     res
@@ -324,15 +337,15 @@ fn cleanable_generations(
     }
 
     let now = SystemTime::now();
-    for (gen, tbr) in result.iter_mut() {
+    for (gen, tbr) in &mut result {
         match now.duration_since(gen.last_modified) {
             Err(err) => {
                 warn!(?err, ?now, ?gen, "Failed to compare time!");
-            }
+            },
             Ok(val) if val <= keep_since.into() => {
                 *tbr = false;
-            }
-            Ok(_) => {}
+            },
+            Ok(_) => {},
         }
     }