refactor backend module

src/backend/mod.rs

@@ -1,117 +1,19 @@
+mod backend_trait;
+mod iter;
 mod macros;
 mod pacman;
 mod rust;
 mod todo_per_backend;
+mod types;
 
-use std::collections::HashSet;
-use std::os::unix::process::CommandExt;
-use std::process::Command;
-
-use anyhow::{Context, Result};
-
-use crate::{Group, Package};
-use pacdef_macro::Register;
-
+pub(crate) use backend_trait::Backend;
+pub(crate) use iter::BackendIter;
 pub(crate) use todo_per_backend::ToDoPerBackend;
 
-pub(in crate::backend) type Switches = &'static [&'static str];
-pub(in crate::backend) type Text = &'static str;
+use pacdef_macro::Register;
 
 #[derive(Debug, Register)]
 pub(crate) enum Backends {
     Pacman,
     Rust,
 }
-
-#[derive(Debug)]
-pub(crate) struct BackendIter {
-    next: Option<Backends>,
-}
-
-impl Iterator for BackendIter {
-    type Item = Box<dyn Backend>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match &self.next {
-            None => None,
-            Some(b) => {
-                let result = b.get_backend();
-                self.next = b.next();
-                Some(result)
-            }
-        }
-    }
-}
-
-pub(crate) trait Backend {
-    fn get_binary(&self) -> Text;
-    fn get_section(&self) -> Text;
-    fn get_switches_install(&self) -> Switches;
-    fn get_switches_remove(&self) -> Switches;
-    fn get_managed_packages(&self) -> &HashSet<Package>;
-    fn load(&mut self, groups: &HashSet<Group>);
-
-    /// Get all packages that are installed in the system.
-    fn get_all_installed_packages(&self) -> Result<HashSet<Package>>;
-
-    /// Get all packages that were installed in the system explicitly.
-    fn get_explicitly_installed_packages(&self) -> Result<HashSet<Package>>;
-
-    /// Install the specified packages.
-    fn install_packages(&self, packages: &[Package]) {
-        if packages.is_empty() {
-            return;
-        }
-
-        let mut cmd = Command::new(self.get_binary());
-        cmd.args(self.get_switches_install());
-        for p in packages {
-            cmd.arg(format!("{p}"));
-        }
-        cmd.exec();
-    }
-
-    /// Remove the specified packages.
-    fn remove_packages(&self, packages: Vec<Package>) {
-        let mut cmd = Command::new(self.get_binary());
-        cmd.args(self.get_switches_remove());
-        for p in packages {
-            cmd.arg(format!("{p}"));
-        }
-        cmd.exec();
-    }
-
-    /// extract packages from its own section as read from group files
-    fn extract_packages_from_group_file_content(&self, content: &str) -> HashSet<Package> {
-        content
-            .lines()
-            .skip_while(|line| !line.starts_with(&format!("[{}]", self.get_section())))
-            .skip(1)
-            .filter(|line| !line.starts_with('['))
-            .fuse()
-            .filter_map(Package::try_from)
-            .collect()
-    }
-
-    fn get_missing_packages_sorted(&self) -> Result<Vec<Package>> {
-        let installed = self
-            .get_all_installed_packages()
-            .context("could not get installed packages")?;
-        let managed = self.get_managed_packages();
-        let mut diff: Vec<_> = managed.difference(&installed).cloned().collect();
-        diff.sort_unstable();
-        Ok(diff)
-    }
-
-    fn add_packages(&mut self, packages: HashSet<Package>);
-
-    fn get_unmanaged_packages_sorted(&self) -> Result<Vec<Package>> {
-        let installed = self
-            .get_explicitly_installed_packages()
-            .context("could not get explicitly installed packages")?;
-        let required = self.get_managed_packages();
-        let mut diff: Vec<_> = installed.difference(required).cloned().collect();
-        diff.sort_unstable();
-        Ok(diff)
-    }
-}