amethyst: add check dependencies support

amethyst should now be able to install dependencies that are required
for the `check()` function to work

Cargo.lock

@@ -163,9 +163,9 @@ dependencies = [
 
 [[package]]
 name = "aur-rpc"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3633aa4f720c5d4470c4705d2f2e0a6eaa06b39693d4a306e4add8e0b5fbea38"
+checksum = "d4bff752f0d9ae9ae38359e5891243f0b5f3dda635b39c944df33d621d892b51"
 dependencies = [
  "reqwest",
  "serde",

Cargo.toml

@@ -37,7 +37,7 @@ serde = { version = "1.0.144", default-features = false, features = [ "derive",
 native-tls = { version = "0.2.10", default-features = false }
 libc = { version = "0.2.132", default-features = false }
 async-recursion = "1.0.0"
-aur-rpc = "0.2.0"
+aur-rpc = "0.2.1"
 futures = "0.3.23"
 tracing = "0.1.36"
 tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }

i18n/en/Amethyst.ftl

@@ -64,6 +64,8 @@ repo-dependencies = Repo dependencies
 aur-dependencies = AUR dependencies
 repo-make-dependencies = Repo make dependencies
 aur-make-dependencies = AUR make dependencies
+repo-check-dependencies = Repo check dependencies
+aur-check-dependencies = AUR check dependencies
 version = version
 votes = votes
 capital-installed = Installed

src/internal/dependencies.rs

@@ -12,6 +12,7 @@ use lazy_regex::regex;
 pub struct DependencyInformation {
     pub depends: DependencyCollection,
     pub make_depends: DependencyCollection,
+    pub check_depends: DependencyCollection,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -56,15 +57,54 @@ impl DependencyInformation {
     /// Resolves all dependency information for a given package
     #[tracing::instrument(level = "trace")]
     pub async fn for_package(package: &PackageInfo) -> AppResult<Self> {
+        let check_depends = Self::resolve_check_depends(package).await?;
         let make_depends = Self::resolve_make_depends(package).await?;
         let depends = Self::resolve_depends(package).await?;
 
         Ok(Self {
             depends,
             make_depends,
+            check_depends,
         })
     }
 
+    /// Resolves all check dependencies for a package
+    #[tracing::instrument(level = "trace")]
+    async fn resolve_check_depends(package: &PackageInfo) -> AppResult<DependencyCollection> {
+        let mut pkgs_to_resolve: HashSet<String> = package
+            .check_depends
+            .iter()
+            .filter_map(|d| Self::map_dep_to_name(d))
+            .collect();
+
+        Self::filter_fulfilled_dependencies(&mut pkgs_to_resolve).await?;
+        let mut already_searched = HashSet::new();
+        already_searched.insert(package.metadata.name.to_owned());
+        let mut dependencies = DependencyCollection::default();
+
+        while !pkgs_to_resolve.is_empty() {
+            already_searched.extend(pkgs_to_resolve.iter().cloned());
+            Self::extend_by_repo_packages(&mut pkgs_to_resolve, &mut dependencies).await?;
+
+            let mut aur_packages = aur_rpc::info(&pkgs_to_resolve).await.map_err(|_| {
+                AppError::MissingDependencies(pkgs_to_resolve.iter().cloned().collect())
+            })?;
+            aur_packages.iter().for_each(|p| {
+                pkgs_to_resolve.remove(&p.metadata.name);
+            });
+            let not_found = std::mem::take(&mut pkgs_to_resolve);
+
+            dependencies
+                .not_found
+                .append(&mut not_found.into_iter().collect());
+            pkgs_to_resolve = Self::get_filtered_check_depends(&aur_packages, &already_searched);
+            Self::filter_fulfilled_dependencies(&mut pkgs_to_resolve).await?;
+            dependencies.aur.append(&mut aur_packages);
+        }
+
+        Ok(dependencies)
+    }
+
     /// Resolves all make dependencies for a package
     #[tracing::instrument(level = "trace")]
     async fn resolve_make_depends(package: &PackageInfo) -> AppResult<DependencyCollection> {
@@ -152,6 +192,21 @@ impl DependencyInformation {
         Ok(())
     }
 
+    fn get_filtered_check_depends(
+        aur_packages: &[PackageInfo],
+        searched: &HashSet<String>,
+    ) -> HashSet<String> {
+        aur_packages
+            .iter()
+            .flat_map(|p| {
+                p.check_depends
+                    .iter()
+                    .filter_map(|d| Self::map_dep_to_name(d))
+            })
+            .filter(|d| !searched.contains(d))
+            .collect()
+    }
+
     fn get_filtered_make_depends(
         aur_packages: &[PackageInfo],
         searched: &HashSet<String>,
@@ -232,20 +287,43 @@ impl DependencyInformation {
     }
 
     pub fn all_aur_depends(&self) -> Vec<&PackageInfo> {
-        self.make_depends
+        let make_deps: Vec<&PackageInfo> = self
+            .make_depends
             .aur
             .iter()
             .chain(self.depends.aur.iter())
-            .collect()
+            .collect();
+        let check_deps: Vec<&PackageInfo> = self
+            .check_depends
+            .aur
+            .iter()
+            .chain(self.depends.aur.iter())
+            .collect();
+        let mut combined_vec: Vec<&PackageInfo> = Vec::new();
+        combined_vec.extend(&make_deps);
+        combined_vec.extend(&check_deps);
+        combined_vec
     }
 
     pub fn all_repo_depends(&self) -> Vec<&str> {
-        self.make_depends
+        let make_deps: Vec<&str> = self
+            .make_depends
             .repo
             .iter()
             .chain(self.depends.repo.iter())
             .map(String::as_str)
-            .collect()
+            .collect();
+        let check_deps: Vec<&str> = self
+            .check_depends
+            .repo
+            .iter()
+            .chain(self.depends.repo.iter())
+            .map(String::as_str)
+            .collect();
+        let mut combined_vec: Vec<&str> = Vec::new();
+        combined_vec.extend(&make_deps);
+        combined_vec.extend(&check_deps);
+        combined_vec
     }
 }
 

src/logging/output.rs

@@ -11,29 +11,48 @@ use crate::{
 use super::get_logger;
 
 pub async fn print_dependency_list(dependencies: &[DependencyInformation]) -> bool {
-    let (mut deps_repo, mut makedeps_repo, deps_aur, makedeps_aur) = dependencies
+    let (
+        mut deps_repo,
+        mut makedeps_repo,
+        mut checkdeps_repo,
+        deps_aur,
+        makedeps_aur,
+        checkdeps_aur,
+    ) = dependencies
         .iter()
         .map(|d| {
             (
                 d.depends.repo.iter().collect(),
                 d.make_depends.repo.iter().collect(),
+                d.check_depends.repo.iter().collect(),
                 d.depends.aur.iter().collect(),
                 d.make_depends.aur.iter().collect(),
+                d.check_depends.aur.iter().collect(),
             )
         })
         .fold(
-            (Vec::new(), Vec::new(), Vec::new(), Vec::new()),
+            (
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+            ),
             |mut acc, mut deps| {
                 acc.0.append(&mut deps.0);
                 acc.1.append(&mut deps.1);
                 acc.2.append(&mut deps.2);
                 acc.3.append(&mut deps.3);
+                acc.4.append(&mut deps.4);
+                acc.5.append(&mut deps.5);
 
                 acc
             },
         );
     deps_repo.dedup();
     makedeps_repo.dedup();
+    checkdeps_repo.dedup();
 
     let mut empty = true;
     if !deps_repo.is_empty() {
@@ -63,6 +82,20 @@ pub async fn print_dependency_list(dependencies: &[DependencyInformation]) -> bo
         get_logger().print_newline();
     }
 
+    if !checkdeps_repo.is_empty() {
+        tracing::info!("{}", fl!("repo-check-dependencies"));
+        get_logger().print_list(&checkdeps_repo, "  ", 2);
+        empty = false;
+        get_logger().print_newline();
+    }
+
+    if !checkdeps_aur.is_empty() {
+        tracing::info!("{}", fl!("aur-check-dependencies"));
+        print_aur_package_list(&checkdeps_aur).await;
+        empty = false;
+        get_logger().print_newline();
+    }
+
     empty
 }