Refactor ALPM functions to be their own module

src/internal/alpm.rs

@@ -1,9 +1,10 @@
 use std::{
     fmt::{Display, Formatter},
     path::Path,
+    path::PathBuf,
 };
 
-use alpm::Alpm;
+use alpm::SigLevel;
 use alpm_utils::alpm_with_conf;
 use pacmanconf::Config;
 
@@ -34,12 +35,52 @@ impl From<pacmanconf::Error> for Error {
     }
 }
 
-#[tracing::instrument(level = "trace")]
+pub enum PackageFrom {
-pub fn get_handler() -> Result<Alpm, Error> {
+    #[allow(dead_code)]
-    let config = Config::from_file(Path::new("/etc/pacman.conf"))?;
+    LocalDb(String),
-    let alpm = alpm_with_conf(&config)?;
 
-    tracing::debug!("Initialized alpm handler");
+    #[allow(dead_code)]
+    SyncDb(String),
 
-    Ok(alpm)
+    File(PathBuf),
+}
+
+pub struct Alpm(alpm::Alpm);
+
+impl Alpm {
+    #[tracing::instrument(level = "trace")]
+    pub fn new() -> Result<Self, Error> {
+        let config = Config::from_file(Path::new("/etc/pacman.conf"))?;
+        let alpm = alpm_with_conf(&config)?;
+        tracing::debug!("Initialized alpm handler");
+        Ok(Self(alpm))
+    }
+
+    pub fn load(&self, pkg: PackageFrom) -> Result<alpm::Pkg, Error> {
+        match pkg {
+            PackageFrom::LocalDb(name) => {
+                let db = self.0.localdb();
+                let package = db.pkg(name)?;
+                Ok(*package)
+            }
+            PackageFrom::SyncDb(name) => {
+                let package = self
+                    .0
+                    .syncdbs()
+                    .find_satisfier(name)
+                    .ok_or(Error::Alpm(alpm::Error::PkgNotFound))?;
+                Ok(*package)
+            }
+            PackageFrom::File(path) => {
+                let package = self
+                    .0
+                    .pkg_load(path.to_str().unwrap(), true, SigLevel::NONE)?;
+                Ok(*package)
+            }
+        }
+    }
+
+    pub fn handler(&self) -> &alpm::Alpm {
+        &self.0
+    }
 }

src/operations/aur_install/common.rs

@@ -4,7 +4,6 @@ use std::{
     sync::Arc,
 };
 
-use alpm::SigLevel;
 use aur_rpc::PackageInfo;
 use crossterm::style::Stylize;
 use futures::future;
@@ -24,6 +23,7 @@ use crate::{
         pager::PagerBuilder,
     },
     internal::{
+        alpm::{Alpm, PackageFrom},
         error::{AppError, AppResult},
         utils::{get_cache_dir, wrap_text},
     },
@@ -205,25 +205,21 @@ async fn build_package(
     tracing::debug!("Archives: {archives:?}");
 
     let mut pkgs_produced: HashMap<String, PathBuf> = HashMap::new();
-    let alpm = crate::internal::alpm::get_handler()?;
+    let alpm = Alpm::new()?;
 
     for ar in archives {
-        let pkg = alpm
+        let pkg = alpm.load(PackageFrom::File(ar.clone()))?;
-            .pkg_load(ar.to_str().unwrap(), true, SigLevel::NONE)
-            .map_err(|e| AppError::Other(e.to_string()))?;
         let name = pkg.name().to_owned();
         pkgs_produced.insert(name, ar);
     }
     tracing::debug!("Produced packages: {pkgs_produced:#?}");
 
-    let pkg_to_install = pkgs_produced
+    let pkg_to_install = pkgs_produced.get(pkg_name).ok_or_else(|| {
-        .get(&ctx.package.metadata.name)
+        AppError::Other(format!(
-        .ok_or_else(|| {
+            "Could not find package {} in produced packages",
-            AppError::Other(format!(
+            pkg_name.clone()
-                "Could not find package {} in produced packages",
+        ))
-                pkg_name.clone()
+    })?;
-            ))
-        })?;
 
     pb.finish_with_message(format!("{}: {}", pkg_name.clone().bold(), "Built!".green()));
     ctx.step = BuildStep::Install(PackageArchives(vec![pkg_to_install.to_path_buf()]));

src/operations/search.rs

@@ -2,7 +2,7 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 use std::str::FromStr;
 
-use crate::internal::alpm::get_handler;
+use crate::internal::alpm::Alpm;
 use crate::internal::error::SilentUnwrap;
 use crate::internal::exit_code::AppExitCode;
 use crate::internal::rpc::rpcsearch;
@@ -131,7 +131,9 @@ pub async fn aur_search(
     by_field: Option<SearchBy>,
     options: Options,
 ) -> Vec<PackageSearchResult> {
-    let alpm = get_handler().unwrap();
+    let alpm = Alpm::new().unwrap();
+    let alpm = alpm.handler();
+
     let local = alpm.localdb();
     let packages = rpcsearch(query.to_string(), by_field.map(SearchBy::into))
         .await
@@ -167,7 +169,9 @@ pub async fn aur_search(
 
 #[tracing::instrument(level = "trace")]
 pub async fn repo_search(query: &str, options: Options) -> Vec<PackageSearchResult> {
-    let alpm = get_handler().unwrap();
+    let alpm = Alpm::new().unwrap();
+    let alpm = alpm.handler();
+
     let local = alpm.localdb();
     let dbs = alpm.syncdbs();