Combine apt, pacman & dnf block to packages block

src/blocks.rs

@@ -45,11 +45,16 @@ use crate::{BoxedFuture, Request, RequestCmd};
 
 macro_rules! define_blocks {
     {
-        $( $(#[cfg(feature = $feat: literal)])? $block: ident $(,)? )*
+        $(
+            $(#[cfg(feature = $feat: literal)])?
+            $(#[deprecated($($dep_k: ident = $dep_v: literal),+)])?
+            $block: ident $(,)?
+        )*
     } => {
         $(
             $(#[cfg(feature = $feat)])?
             $(#[cfg_attr(docsrs, doc(cfg(feature = $feat)))])?
+            $(#[deprecated($($dep_k = $dep_v),+)])?
             pub mod $block;
         )*
 
@@ -58,6 +63,7 @@ macro_rules! define_blocks {
             $(
                 $(#[cfg(feature = $feat)])?
                 #[allow(non_camel_case_types)]
+                #[allow(deprecated)]
                 $block($block::Config),
             )*
             Err(&'static str, Error),
@@ -78,6 +84,7 @@ macro_rules! define_blocks {
                 match self {
                     $(
                         $(#[cfg(feature = $feat)])?
+                        #[allow(deprecated)]
                         Self::$block(config) => futures.push(async move {
                             while let Err(err) = $block::run(&config, &api).await {
                                 if api.set_error(err).is_err() {
@@ -114,6 +121,7 @@ macro_rules! define_blocks {
                 match block_name {
                     $(
                         $(#[cfg(feature = $feat)])?
+                        #[allow(deprecated)]
                         stringify!($block) => match $block::Config::deserialize(table) {
                             Ok(config) => Ok(BlockConfig::$block(config)),
                             Err(err) => Ok(BlockConfig::Err(stringify!($block), crate::errors::Error::new(err.to_string()))),
@@ -136,6 +144,10 @@ macro_rules! define_blocks {
 
 define_blocks!(
     amd_gpu,
+    #[deprecated(
+        since = "0.33.0",
+        note = "The block has been deprecated in favor of the the packages block"
+    )]
     apt,
     backlight,
     battery,
@@ -144,6 +156,10 @@ define_blocks!(
     custom,
     custom_dbus,
     disk_space,
+    #[deprecated(
+        since = "0.33.0",
+        note = "The block has been deprecated in favor of the the packages block"
+    )]
     dnf,
     docker,
     external_ip,
@@ -162,6 +178,11 @@ define_blocks!(
     #[cfg(feature = "notmuch")]
     notmuch,
     nvidia_gpu,
+    packages,
+    #[deprecated(
+        since = "0.33.0",
+        note = "The block has been deprecated in favor of the the packages block"
+    )]
     pacman,
     pomodoro,
     rofication,

src/blocks/apt.rs

@@ -48,15 +48,12 @@
 //!
 //! - `update`
 
-use std::env;
-use std::process::Stdio;
-
 use regex::Regex;
 
-use tokio::fs::{create_dir_all, File};
-use tokio::process::Command;
-
-use super::prelude::*;
+use super::{
+    packages::{apt::Apt, has_matching_update, Backend},
+    prelude::*,
+};
 
 #[derive(Deserialize, Debug, SmartDefault)]
 #[serde(deny_unknown_fields, default)]
@@ -100,45 +97,15 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
         .transpose()
         .error("invalid ignore updates regex")?;
 
-    let mut cache_dir = env::temp_dir();
-    cache_dir.push("i3rs-apt");
-    if !cache_dir.exists() {
-        create_dir_all(&cache_dir)
-            .await
-            .error("Failed to create temp dir")?;
-    }
-
-    let apt_config = format!(
-        "Dir::State \"{}\";\n
-         Dir::State::lists \"lists\";\n
-         Dir::Cache \"{}\";\n
-         Dir::Cache::srcpkgcache \"srcpkgcache.bin\";\n
-         Dir::Cache::pkgcache \"pkgcache.bin\";",
-        cache_dir.display(),
-        cache_dir.display(),
-    );
-
-    let mut config_file = cache_dir;
-    config_file.push("apt.conf");
-    let config_file = config_file.to_str().unwrap();
-
-    let mut file = File::create(&config_file)
-        .await
-        .error("Failed to create config file")?;
-    file.write_all(apt_config.as_bytes())
-        .await
-        .error("Failed to write to config file")?;
+    let backend = Apt::new(config.ignore_phased_updates).await?;
 
     loop {
         let mut widget = Widget::new();
-        let updates = get_updates_list(config_file).await?;
-        let count = get_update_count(
-            config_file,
-            config.ignore_phased_updates,
-            ignore_updates_regex.as_ref(),
-            &updates,
-        )
-        .await?;
+        let mut updates = backend.get_updates_list().await?;
+        if let Some(regex) = ignore_updates_regex.clone() {
+            updates.retain(|u| !regex.is_match(u));
+        }
+        let count = updates.len();
 
         widget.set_format(match count {
             0 => format_up_to_date.clone(),
@@ -177,73 +144,3 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
         }
     }
 }
-
-async fn get_updates_list(config_path: &str) -> Result<String> {
-    Command::new("apt")
-        .env("APT_CONFIG", config_path)
-        .args(["update"])
-        .stdout(Stdio::null())
-        .stdin(Stdio::null())
-        .spawn()
-        .error("Failed to run `apt update`")?
-        .wait()
-        .await
-        .error("Failed to run `apt update`")?;
-    let stdout = Command::new("apt")
-        .env("LANG", "C")
-        .env("APT_CONFIG", config_path)
-        .args(["list", "--upgradable"])
-        .output()
-        .await
-        .error("Problem running apt command")?
-        .stdout;
-    String::from_utf8(stdout).error("apt produced non-UTF8 output")
-}
-
-async fn get_update_count(
-    config_path: &str,
-    ignore_phased_updates: bool,
-    ignore_updates_regex: Option<&Regex>,
-    updates: &str,
-) -> Result<usize> {
-    let mut cnt = 0;
-
-    for update_line in updates
-        .lines()
-        .filter(|line| line.contains("[upgradable"))
-        .filter(|line| ignore_updates_regex.map_or(true, |re| !re.is_match(line)))
-    {
-        if !ignore_phased_updates || !is_phased_update(config_path, update_line).await? {
-            cnt += 1;
-        }
-    }
-
-    Ok(cnt)
-}
-
-fn has_matching_update(updates: &str, regex: &Regex) -> bool {
-    updates.lines().any(|line| regex.is_match(line))
-}
-
-async fn is_phased_update(config_path: &str, package_line: &str) -> Result<bool> {
-    let package_name_regex = regex!(r#"(.*)/.*"#);
-    let package_name = &package_name_regex
-        .captures(package_line)
-        .error("Couldn't find package name")?[1];
-
-    let output = String::from_utf8(
-        Command::new("apt-cache")
-            .args(["-c", config_path, "policy", package_name])
-            .output()
-            .await
-            .error("Problem running apt-cache command")?
-            .stdout,
-    )
-    .error("Problem capturing apt-cache command output")?;
-
-    let phased_regex = regex!(r".*\(phased (\d+)%\).*");
-    Ok(match phased_regex.captures(&output) {
-        Some(matches) => &matches[1] != "100",
-        None => false,
-    })
-}

src/blocks/dnf.rs

@@ -39,9 +39,12 @@
 //!
 //! - `update`
 
-use super::prelude::*;
 use regex::Regex;
-use tokio::process::Command;
+
+use super::{
+    packages::{dnf::Dnf, has_matching_update, Backend},
+    prelude::*,
+};
 
 #[derive(Deserialize, Debug, SmartDefault)]
 #[serde(deny_unknown_fields, default)]
@@ -77,11 +80,13 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
         .transpose()
         .error("invalid critical updates regex")?;
 
+    let backend = Dnf::new();
+
     loop {
         let mut widget = Widget::new();
 
-        let updates = get_updates_list().await?;
-        let count = get_update_count(&updates);
+        let updates = backend.get_updates_list().await?;
+        let count = updates.len();
 
         widget.set_format(match count {
             0 => format_up_to_date.clone(),
@@ -120,22 +125,3 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
         }
     }
 }
-
-async fn get_updates_list() -> Result<String> {
-    let stdout = Command::new("sh")
-        .env("LC_LANG", "C")
-        .args(["-c", "dnf check-update -q --skip-broken"])
-        .output()
-        .await
-        .error("Failed to run dnf check-update")?
-        .stdout;
-    String::from_utf8(stdout).error("dnf produced non-UTF8 output")
-}
-
-fn get_update_count(updates: &str) -> usize {
-    updates.lines().filter(|line| line.len() > 1).count()
-}
-
-fn has_matching_update(updates: &str, regex: &Regex) -> bool {
-    updates.lines().any(|line| regex.is_match(line))
-}