Fix installation of make-depends uninstalls depends too

src/interact/macros.rs

@@ -19,3 +19,22 @@ macro_rules! multi_select {
         $crate::interact::Interact::interact($crate::interact::AmeMultiSelect::new(format!($($arg)+)).items($items))
     }
 }
+
+#[macro_export]
+/// Returns a singular or plural expression depending on the given len
+macro_rules! numeric {
+    ($len:expr, $sin:literal[$plu:literal]) => {
+        if $len == 1 {
+            format!("{} {}", $len, $sin)
+        } else {
+            format!("{} {}{}", $len, $sin, $plu)
+        }
+    };
+    ($len:expr, $sin:literal or $plu:literal) => {
+        if $len == 1 {
+            format!("{} {}", $len, $sin)
+        } else {
+            format!("{} {}", $len, plu)
+        }
+    };
+}

src/internal/dependencies.rs

@@ -209,54 +209,41 @@ impl DependencyInformation {
         Ok(repo_deps)
     }
 
-    pub fn make_depends(&self) -> Vec<&str> {
-        let mut make_depends = Vec::new();
-        let mut aur_depends = self
-            .make_depends
+    pub fn make_depends(&self) -> HashSet<&str> {
+        let depends = self.depends();
+        self.make_depends
             .aur
             .iter()
             .map(|p| p.metadata.name.as_str())
-            .collect::<Vec<_>>();
-        let mut repo_depends = self
-            .make_depends
-            .repo
-            .iter()
-            .map(String::as_str)
-            .collect::<Vec<_>>();
-        make_depends.append(&mut aur_depends);
-        make_depends.append(&mut repo_depends);
+            .chain(self.make_depends.repo.iter().map(String::as_str))
+            .filter(|d| !depends.contains(d))
+            .collect()
+    }
 
-        make_depends
+    pub fn depends(&self) -> HashSet<&str> {
+        self.depends
+            .aur
+            .iter()
+            .map(|d| d.metadata.name.as_str())
+            .chain(self.depends.repo.iter().map(String::as_str))
+            .collect()
     }
 
     pub fn all_aur_depends(&self) -> Vec<&PackageInfo> {
-        let mut depends = Vec::new();
-        let mut aur_depends = self.make_depends.aur.iter().collect::<Vec<_>>();
-        let mut aur_make_depends = self.depends.aur.iter().collect::<Vec<_>>();
-        depends.append(&mut aur_depends);
-        depends.append(&mut aur_make_depends);
-
-        depends
+        self.make_depends
+            .aur
+            .iter()
+            .chain(self.depends.aur.iter())
+            .collect()
     }
 
     pub fn all_repo_depends(&self) -> Vec<&str> {
-        let mut depends = Vec::new();
-        let mut repo_depends = self
-            .make_depends
-            .repo
-            .iter()
-            .map(String::as_str)
-            .collect::<Vec<_>>();
-        let mut repo_make_depends = self
-            .depends
+        self.make_depends
             .repo
             .iter()
+            .chain(self.depends.repo.iter())
             .map(String::as_str)
-            .collect::<Vec<_>>();
-        depends.append(&mut repo_depends);
-        depends.append(&mut repo_make_depends);
-
-        depends
+            .collect()
     }
 }
 

src/operations/aur_install.rs

@@ -23,7 +23,7 @@ use crate::internal::utils::{get_cache_dir, wrap_text};
 use crate::logging::get_logger;
 use crate::logging::output::{print_aur_package_list, print_dependency_list};
 use crate::logging::piped_stdio::StdioReader;
-use crate::{cancelled, crash, multi_select, prompt, Options};
+use crate::{cancelled, crash, multi_select, numeric, prompt, Options};
 
 #[derive(Debug)]
 pub struct BuildContext {
@@ -186,8 +186,8 @@ pub async fn aur_install(packages: Vec<String>, options: Options) {
 
     if !aur_dependencies.is_empty() {
         tracing::info!(
-            "Installing {} dependencies from the aur",
-            aur_dependencies.len()
+            "Installing {} from the aur",
+            numeric!(aur_dependencies.len(), "package"["s"])
         );
         let batches = create_dependency_batches(aur_dependencies);
         tracing::debug!("aur install batches: {batches:?}");
@@ -197,7 +197,7 @@ pub async fn aur_install(packages: Vec<String>, options: Options) {
         }
     }
 
-    tracing::info!("Installing {} packages", contexts.len());
+    tracing::info!("Installing {}", numeric!(contexts.len(), "package"["s"]));
 
     if let Err(e) = build_and_install(
         contexts,
@@ -276,8 +276,8 @@ async fn build_and_install(
         }
     }
 
-    tracing::info!("Built {} packages", ctxs.len());
-    tracing::info!("Installing packages...");
+    tracing::info!("Built {}", numeric!(ctxs.len(), "package"["s"]));
+    tracing::info!("Installing packages");
 
     install_packages(ctxs, install_opts).await?;