feat(alpm-utils): Add orphan detection to alpm-utils

Adds is_orphan() function and AlpmExt trait with find_orphans() method
for detecting packages installed as dependencies that are no longer
required by any other package.

Signed-off-by: Josephine Pfeiffer <[email protected]>

Author: pfeifferj

alpm-utils/src/db.rs

@@ -1,8 +1,27 @@
-use alpm::{AlpmList, AlpmListMut, Db, Package, Result};
+use alpm::{Alpm, AlpmList, AlpmListMut, Db, Package, PackageReason, Result};
 
 use crate::AsTarg;
 
-/// Extention for AlpmList<Db>
+/// Check if a package is an orphan.
+pub fn is_orphan(pkg: &Package) -> bool {
+    pkg.reason() == PackageReason::Depend
+        && pkg.required_by().is_empty()
+        && pkg.optional_for().is_empty()
+}
+
+/// Extension trait for Alpm providing orphan detection.
+pub trait OrphanExt {
+    /// Find all orphan packages in the local database.
+    fn find_orphans(&self) -> impl Iterator<Item = &Package>;
+}
+
+impl OrphanExt for Alpm {
+    fn find_orphans(&self) -> impl Iterator<Item = &Package> {
+        self.localdb().pkgs().iter().filter(|pkg| is_orphan(pkg))
+    }
+}
+
+/// Extension trait for `AlpmList<Db>`.
 pub trait DbListExt<'a> {
     /// Similar to find_satisfier() but expects a Target instead of a &str.
     fn find_target_satisfier<T: AsTarg>(&self, target: T) -> Option<&'a Package>;
@@ -62,3 +81,55 @@ impl<'a> DbListExt<'a> for AlpmList<'_, &'a Db> {
         pkg.ok_or(alpm::Error::PkgNotFound)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_handle() -> Alpm {
+        Alpm::new("/", "../alpm/tests/db").unwrap()
+    }
+
+    #[test]
+    fn test_is_orphan_dependency_with_no_dependents() {
+        let handle = test_handle();
+        let localdb = handle.localdb();
+
+        // argon2 is installed as dependency (REASON=1) and has no required_by in test db
+        let pkg = localdb.pkg("argon2").unwrap();
+        assert_eq!(pkg.reason(), PackageReason::Depend);
+
+        // Whether it's an orphan depends on if anything requires it
+        let result = is_orphan(&pkg);
+        // The function should return true if no packages require or optionally depend on it
+        assert!(result == (pkg.required_by().is_empty() && pkg.optional_for().is_empty()));
+    }
+
+    #[test]
+    fn test_is_orphan_explicit_package() {
+        let handle = test_handle();
+        let localdb = handle.localdb();
+
+        // Find a package that's explicitly installed (if any in test db)
+        for pkg in localdb.pkgs().iter() {
+            if pkg.reason() == PackageReason::Explicit {
+                // Explicit packages should never be orphans
+                assert!(!is_orphan(&pkg));
+                return;
+            }
+        }
+    }
+
+    #[test]
+    fn test_find_orphans_iterator() {
+        let handle = test_handle();
+
+        // find_orphans should return an iterator
+        let orphans: Vec<_> = handle.find_orphans().collect();
+
+        // All returned packages should satisfy is_orphan
+        for pkg in &orphans {
+            assert!(is_orphan(pkg));
+        }
+    }
+}