Rework upgrades

src/upgrade.rs

@@ -9,7 +9,7 @@ use std::collections::{HashMap, HashSet};
 use alpm::{AlpmList, Db};
 use alpm_utils::DbListExt;
 use anyhow::Result;
-use aur_depends::{AurUpdates, PkgbuildUpdates, Resolver};
+use aur_depends::{Resolver, Updates};
 use futures::try_join;
 use tr::tr;
 
@@ -114,33 +114,43 @@ fn print_upgrade(
     );
 }
 
-async fn get_aur_only_upgrades<'a, 'b>(
+async fn get_resolver_upgrades<'a, 'b>(
     config: &Config,
     resolver: &mut Resolver<'a, 'b, RaurHandle>,
     print: bool,
-) -> Result<AurUpdates<'a>> {
+) -> Result<Updates<'a>> {
-    if config.mode.aur() {
+    if print {
-        if print {
+        if config.mode.pkgbuild() {
             let c = config.color;
             println!(
                 "{} {}",
                 c.action.paint("::"),
-                c.bold.paint(tr!("Looking for AUR upgrades..."))
+                c.bold.paint(tr!("Looking for PKGBUILD upgrades..."))
             );
+
+            if config.mode.aur() {
+                let c = config.color;
+                println!(
+                    "{} {}",
+                    c.action.paint("::"),
+                    c.bold.paint(tr!("Looking for AUR upgrades..."))
+                );
+            }
         }
 
-        let updates = match config.repos {
+        let dbs = match config.repos {
-            LocalRepos::None => resolver.aur_updates().await?,
+            LocalRepos::None => None,
             _ => {
                 let (_, dbs) = repo::repo_aur_dbs(config);
-                let dbs = dbs.iter().map(|db| db.name()).collect::<Vec<_>>();
+                let dbs = Some(dbs.into_iter().map(|db| db.name()).collect::<Vec<_>>());
-                resolver.local_aur_updates(&dbs).await?
+                dbs
             }
         };
+        let updates = resolver.updates(dbs.as_deref()).await?;
 
         Ok(updates)
     } else {
-        Ok(AurUpdates::default())
+        Ok(Updates::default())
     }
 }
 
@@ -165,52 +175,21 @@ pub async fn net_upgrades<'res, 'conf>(
     config: &'conf Config,
     resolver: &mut Resolver<'res, '_, RaurHandle>,
     print: bool,
-) -> Result<(AurUpdates<'res>, Vec<String>)> {
+) -> Result<(Updates<'res>, Vec<String>)> {
     try_join!(
-        get_aur_only_upgrades(config, resolver, print),
+        get_resolver_upgrades(config, resolver, print),
         get_devel_upgrades(config, print)
     )
 }
 
-fn pkgbuild_upgrades<'a>(
-    config: &Config,
-    resolver: &mut Resolver<'a, '_, RaurHandle>,
-    print: bool,
-) -> Result<PkgbuildUpdates<'a>> {
-    if config.mode.pkgbuild() {
-        if print {
-            let c = config.color;
-            println!(
-                "{} {}",
-                c.action.paint("::"),
-                c.bold.paint(tr!("Looking for PKGBUILD upgrades..."))
-            );
-        }
-
-        let updates = match config.repos {
-            LocalRepos::None => resolver.pkgbuild_updates()?,
-            _ => {
-                let (_, dbs) = repo::repo_aur_dbs(config);
-                let dbs = dbs.iter().map(|db| db.name()).collect::<Vec<_>>();
-                resolver.local_pkgbuild_updates(&dbs)?
-            }
-        };
-
-        Ok(updates)
-    } else {
-        Ok(PkgbuildUpdates::default())
-    }
-}
-
 pub async fn get_upgrades<'a, 'b>(
     config: &Config,
     resolver: &mut Resolver<'a, 'b, RaurHandle>,
 ) -> Result<Upgrades> {
-    let (aur_upgrades, devel_upgrades) = net_upgrades(config, resolver, true).await?;
+    let (upgrades, devel_upgrades) = net_upgrades(config, resolver, true).await?;
     let (syncdbs, aurdbs) = repo::repo_aur_dbs(config);
-    let pkgbuild_updates = pkgbuild_upgrades(config, resolver, true)?;
 
-    for pkg in aur_upgrades.ignored {
+    for pkg in upgrades.ignored_aur {
         eprintln!(
             "{} {}",
             config.color.warning.paint(tr!("warning:")),
@@ -223,7 +202,7 @@ pub async fn get_upgrades<'a, 'b>(
         );
     }
 
-    for pkg in pkgbuild_updates.ignored {
+    for pkg in upgrades.ignored_pkgbuild {
         eprintln!(
             "{} {}",
             config.color.warning.paint(tr!("warning:")),
@@ -236,7 +215,8 @@ pub async fn get_upgrades<'a, 'b>(
         );
     }
 
-    let mut aur_upgrades = aur_upgrades.updates;
+    let mut aur_upgrades = upgrades.aur_updates;
+    let pkgbuild_upgrades = upgrades.pkgbuild_updates;
     let mut devel_upgrades =
         filter_devel_updates(config, resolver.get_cache_mut(), &devel_upgrades).await?;
 
@@ -248,6 +228,7 @@ pub async fn get_upgrades<'a, 'b>(
 
     devel_upgrades.sort();
     devel_upgrades.dedup();
+    // TODO better devel pkgbuild
     aur_upgrades.retain(|u| !devel_upgrades.iter().any(|t| t.pkg == u.remote.name));
 
     let mut repo_skip = Vec::new();
@@ -267,7 +248,7 @@ pub async fn get_upgrades<'a, 'b>(
     if devel_upgrades.is_empty()
         && aur_upgrades.is_empty()
         && repo_upgrades.is_empty()
-        && pkgbuild_updates.updates.is_empty()
+        && pkgbuild_upgrades.is_empty()
     {
         return Ok(Upgrades::default());
     }
@@ -278,8 +259,7 @@ pub async fn get_upgrades<'a, 'b>(
             .map(|p| p.remote.name.clone())
             .collect::<Vec<_>>();
 
-        let mut pkgbuild_updates = pkgbuild_updates
+        let mut pkgbuild_updates = pkgbuild_upgrades
-            .updates
             .iter()
             .map(|u| (u.repo.clone(), u.local.name().to_string()))
             .collect::<Vec<_>>();
@@ -308,10 +288,8 @@ pub async fn get_upgrades<'a, 'b>(
     let db = config.alpm.localdb();
     let n_max = repo_upgrades.len() + aur_upgrades.len() + devel_upgrades.len();
     let n_max = n_max.to_string().len();
-    let mut index = repo_upgrades.len()
+    let mut index =
-        + aur_upgrades.len()
+        repo_upgrades.len() + aur_upgrades.len() + devel_upgrades.len() + pkgbuild_upgrades.len();
-        + devel_upgrades.len()
-        + pkgbuild_updates.updates.len();
 
     let db_pkg_max = repo_upgrades
         .iter()
@@ -327,8 +305,7 @@ pub async fn get_upgrades<'a, 'b>(
                 .map(|u| db_len(&u.pkg, "devel", &aurdbs)),
         )
         .chain(
-            pkgbuild_updates
+            pkgbuild_upgrades
-                .updates
                 .iter()
                 .map(|u| db_len(u.local.name(), &u.repo, &aurdbs)),
         )
@@ -345,12 +322,7 @@ pub async fn get_upgrades<'a, 'b>(
                 .filter_map(|p| db.pkg(p.pkg.as_str()).ok())
                 .map(|p| p.version().len()),
         )
-        .chain(
+        .chain(pkgbuild_upgrades.iter().map(|p| p.local.version().len()))
-            pkgbuild_updates
-                .updates
-                .iter()
-                .map(|p| p.local.version().len()),
-        )
         .max()
         .unwrap_or(0);
 
@@ -412,7 +384,7 @@ pub async fn get_upgrades<'a, 'b>(
         index -= 1;
     }
 
-    for pkg in pkgbuild_updates.updates.iter().rev().rev() {
+    for pkg in pkgbuild_upgrades.iter().rev().rev() {
         let remote = aurdbs
             .pkg(pkg.local.name())
             .map(|p| format!("{}-{}", p.db().unwrap().name(), pkg.repo));
@@ -434,10 +406,8 @@ pub async fn get_upgrades<'a, 'b>(
     let input = input(config, &tr!("Packages to exclude (eg: 1 2 3, 1-3):"));
     let input = input.trim();
     let number_menu = NumberMenu::new(input);
-    let mut index = repo_upgrades.len()
+    let mut index =
-        + aur_upgrades.len()
+        repo_upgrades.len() + aur_upgrades.len() + devel_upgrades.len() + pkgbuild_upgrades.len();
-        + devel_upgrades.len()
-        + pkgbuild_updates.updates.len();
 
     for pkg in repo_upgrades.iter().rev().rev() {
         let remote = syncdbs.pkg(pkg.name()).unwrap();
@@ -483,7 +453,7 @@ pub async fn get_upgrades<'a, 'b>(
         index -= 1;
     }
 
-    for pkg in pkgbuild_updates.updates.iter().rev().rev() {
+    for pkg in pkgbuild_upgrades.iter().rev().rev() {
         let remote = aurdbs
             .pkg(pkg.local.name())
             .map(|p| p.db().unwrap().name())

tests/common/mod.rs

@@ -35,8 +35,6 @@ async fn run(run_args: &[&str], repo: bool) -> Result<(TempDir, i32)> {
         .status()?;
     assert!(status.success());
 
-
-
     if repo {
         let status = Command::new("cp")
             .arg("-r")