what a mess, stash!

Author: J-ZhengLi

rim_common/src/types/configuration.rs

@@ -4,21 +4,13 @@
 use crate::setter;
 use crate::{dirs::rim_config_dir, types::TomlParser};
 use anyhow::Result;
-use chrono::{NaiveDateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
-use std::{collections::HashMap, fmt::Display, time::Duration};
 
-/// Default update check timeout is 1440 minutes (1 day)
-const DEFAULT_UPDATE_CHECK_TIMEOUT_IN_MINUTES: u64 = 1440;
-/// Default update check timeout in duration
-pub const DEFAULT_UPDATE_CHECK_DURATION: Duration =
-    Duration::from_secs(60 * DEFAULT_UPDATE_CHECK_TIMEOUT_IN_MINUTES);
-
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq)]
 pub struct Configuration {
     pub language: Option<Language>,
-    pub update: UpdateCheckerOpt,
+    pub update: UpdateConfig,
 }
 
 impl TomlParser for Configuration {
@@ -30,15 +22,6 @@ impl Configuration {
         Self::default()
     }
 
-    /// Mark a version as skipped.
-    ///
-    /// This function can be chained.
-    pub fn skip_update<T: Into<String>>(mut self, target: UpdateTarget, version: T) -> Self {
-        let conf = self.update.conf_mut(target);
-        conf.skip = Some(version.into());
-        self
-    }
-
     /// Try loading from [`rim_config_dir`], return `None` if it doesn't exists yet.
     pub fn try_load_from_config_dir() -> Option<Self> {
         Self::load_from_dir(rim_config_dir()).ok()
@@ -57,11 +40,19 @@ impl Configuration {
         self.write_to_dir(rim_config_dir())
     }
 
-    pub fn update_skipped<T: AsRef<str>>(&self, target: UpdateTarget, version: T) -> bool {
-        self.update.is_skipped(target, version)
-    }
-
-    setter!(set_language(self.language, Option<Language>));
+    setter!(set_language(self.language, val: Language) { Some(val) });
+    setter!(set_manager_update_channel(
+        self.update.manager_update_channel,
+        UpdateChannel
+    ));
+    setter!(set_auto_check_manager_updates(
+        self.update.auto_check_manager_updates,
+        bool
+    ));
+    setter!(set_auto_check_toolkit_updates(
+        self.update.auto_check_toolkit_updates,
+        bool
+    ));
 }
 
 #[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq, Clone, Copy)]
@@ -107,186 +98,118 @@ impl FromStr for Language {
     }
 }
 
-// If we ever need to support more things for update checker,
-// just add one in this enum, without breaking compatibility.
-#[derive(Clone, Copy, Debug, Deserialize, Serialize, Hash, PartialEq, Eq)]
-#[serde(rename_all = "kebab-case")]
-pub enum UpdateTarget {
-    Manager,
-    Toolkit,
+/// App update channel.
+#[derive(Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum UpdateChannel {
+    #[default]
+    Stable,
+    Beta,
 }
 
-// The display implementation must return the same result as
-// serde's serialization, which means it should be in 'kebab-case' as well.
-impl Display for UpdateTarget {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(match self {
-            Self::Manager => "manager",
-            Self::Toolkit => "toolkit",
-        })
-    }
+/// Representing the configuration for update checker.
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct UpdateConfig {
+    /// Channel of manager (app) updates to check, i.e. "stable", "beta"
+    #[serde(default)]
+    pub manager_update_channel: UpdateChannel,
+    /// Automatically checking for manager (app) updates.
+    #[serde(default = "bool_true")]
+    pub auto_check_manager_updates: bool,
+    /// Automatically checking for toolkit updates.
+    #[serde(default = "bool_true")]
+    pub auto_check_toolkit_updates: bool,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct UpdateConf {
-    /// The datetime when the last update check happened,
-    /// defaulting to [`UNIX_EPOCH`](NaiveDateTime::UNIX_EPOCH)
-    last_run: NaiveDateTime,
-    /// Timeout (in minutes) until next update check
-    timeout: Option<u64>,
-    /// The specific version to disable auto check.
-    ///
-    /// If there's a newer version available, it will still
-    skip: Option<String>,
+// Return `true` for the serde default arg.
+// really? there's no better way?
+fn bool_true() -> bool {
+    true
 }
 
-impl Default for UpdateConf {
+impl Default for UpdateConfig {
     fn default() -> Self {
         Self {
-            last_run: NaiveDateTime::default(),
-            timeout: Some(DEFAULT_UPDATE_CHECK_TIMEOUT_IN_MINUTES),
-            skip: None,
+            manager_update_channel: UpdateChannel::default(),
+            auto_check_manager_updates: true,
+            auto_check_toolkit_updates: true,
         }
     }
 }
 
-impl UpdateConf {
-    /// Get the timeout in duration until next update check.
-    ///
-    /// Default is 1 day.
-    fn timeout(&self) -> Duration {
-        self.timeout
-            .map(|timeout_in_minutes| Duration::from_secs(timeout_in_minutes * 60))
-            .unwrap_or(DEFAULT_UPDATE_CHECK_DURATION)
-    }
-}
-
-/// Representing the configuration for update checker.
-///
-/// Containing information about what version to skip (by the user),
-/// how often should we check for next update,
-/// and when was the last check happened.
-///
-/// # Configuration example
-///
-/// ```toml
-/// [update.manager]
-/// last-run = "2024-01-01 10:30:05" # when was the last update check
-/// timeout = 1440  # how long (in minutes) until we need to check for update since `last-run`,
-/// skip = "0.5.0" # the version the user choose to skip
-/// ```
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct UpdateCheckerOpt(HashMap<UpdateTarget, UpdateConf>);
-
-impl UpdateCheckerOpt {
+impl UpdateConfig {
     pub fn new() -> Self {
         Self::default()
     }
 
-    fn conf_mut(&mut self, target: UpdateTarget) -> &mut UpdateConf {
-        self.0.entry(target).or_default()
-    }
-
-    /// Return `true` if the given `version` is marked as skipped before.
-    fn is_skipped<T: AsRef<str>>(&self, target: UpdateTarget, version: T) -> bool {
-        let Some(skipped) = self.0.get(&target).and_then(|conf| conf.skip.as_deref()) else {
-            return false;
-        };
-        version.as_ref() == skipped
-    }
-
-    /// Change a target's update checkout timeout to a specific number in minutes.
-    ///
-    /// This function can be chained.
-    pub fn remind_later(mut self, target: UpdateTarget, minutes: u64) -> Self {
-        let conf = self.conf_mut(target);
-        if let Some(t) = conf.timeout.as_mut() {
-            *t += minutes
-        } else {
-            conf.timeout = Some(minutes);
-        }
-        self
-    }
-
-    /// Update the `last-run` value for given target.
-    pub fn mark_checked(&mut self, target: UpdateTarget) -> &mut Self {
-        let conf = self.conf_mut(target);
-        conf.last_run = Utc::now().naive_utc();
-        self
-    }
-
-    /// Return how much time (in duration) until the next update check.
-    ///
-    /// - If the update hasn't be checked yet, we should check now,
-    ///   thus returning [`Duration::ZERO`].
-    /// - If the update has been checked, but right now is not the time for the
-    ///   next check, the remaining time will be returned.
-    /// - If the update has been checked, and it's already past the time for the next
-    ///   update check, then [`Duration::ZERO`] will be returned.
-    pub fn duration_until_next_run(&self, target: UpdateTarget) -> Duration {
-        let Some(conf) = self.0.get(&target) else {
-            // return the full default duration
-            return Duration::ZERO;
-        };
-        let timeout = conf.timeout();
-        let next_check_date = conf.last_run + timeout;
-        let now = Utc::now().naive_utc();
-        if next_check_date > now {
-            let time_delta_in_secs = (next_check_date - now).num_seconds();
-            // safe to unwrap, we are converting a known positive i64 to u64
-            Duration::from_secs(time_delta_in_secs.try_into().unwrap())
-        } else {
-            Duration::ZERO
-        }
-    }
+    setter!(manager_update_channel(
+        self.manager_update_channel,
+        UpdateChannel
+    ));
+    setter!(auto_check_manager_updates(
+        self.auto_check_manager_updates,
+        bool
+    ));
+    setter!(auto_check_toolkit_updates(
+        self.auto_check_toolkit_updates,
+        bool
+    ));
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
-    fn skip_update() {
+    fn backward_compatible() {
         let input = r#"
 [update]
 manager = { skip = "0.1.0", last-run = "1970-01-01T00:00:00" }
 toolkit = { skip = "1.0.0", last-run = "1970-01-01T00:00:00" }"#;
         let expected = Configuration::from_str(input).unwrap();
-        assert!(expected.update_skipped(UpdateTarget::Manager, "0.1.0"));
-        assert!(expected.update_skipped(UpdateTarget::Toolkit, "1.0.0"));
+        assert_eq!(expected, Configuration::default());
     }
 
     #[test]
-    fn skip_update_programmatically() {
-        let vs = Configuration::new()
-            .skip_update(UpdateTarget::Manager, "0.1.0")
-            .skip_update(UpdateTarget::Toolkit, "1.0.0");
-        assert!(vs.update_skipped(UpdateTarget::Manager, "0.1.0"));
-        assert!(vs.update_skipped(UpdateTarget::Toolkit, "1.0.0"));
+    fn default_serialization() {
+        let conf = Configuration::new();
+
+        assert_eq!(
+            conf.to_toml().unwrap(),
+            r#"[update]
+manager-update-channel = "stable"
+auto-check-manager-updates = true
+auto-check-toolkit-updates = true
+"#
+        );
     }
 
     #[test]
-    fn remind_update_later() {
-        let input = r#"
-[update]
-manager = { last-run = "1970-01-01T00:00:00" }"#;
+    fn configured_serialization() {
+        let conf = Configuration::new()
+            .set_language(Language::CN)
+            .set_manager_update_channel(UpdateChannel::Beta)
+            .set_auto_check_manager_updates(false)
+            .set_auto_check_toolkit_updates(false);
+
+        let expected = conf.to_toml().unwrap();
+        assert_eq!(
+            expected,
+            r#"
+language = "CN"
 
-        let mut expected = Configuration::from_str(input).unwrap().update;
-        let manager = UpdateTarget::Manager;
-        assert_eq!(expected.conf_mut(manager).timeout, None);
-        expected = expected.remind_later(manager, 60);
-        assert_eq!(expected.conf_mut(manager).timeout, Some(60));
-        expected = expected.remind_later(manager, 60);
-        assert_eq!(expected.conf_mut(manager).timeout, Some(120));
+[update]
+manager-update-channel = "beta"
+auto-check-manager-updates = false
+auto-check-toolkit-updates = false
+"#
+        );
     }
 
     #[test]
     fn lang_config() {
-        let input = r#"language = "CN"
-
-[update]
-"#;
+        let input = "language = \"CN\"\nupdate]";
 
         let expected = Configuration::from_str(input).unwrap();
         assert_eq!(expected.language, Some(Language::CN));

rim_common/src/utils/download.rs

@@ -3,27 +3,25 @@ use std::path::Path;
 use std::time::Duration;
 
 use anyhow::{anyhow, bail, Context, Result};
-use indicatif::ProgressBar;
 use reqwest::{header, Client};
 use tokio::fs;
 use tokio::io::AsyncWriteExt;
 use url::Url;
 
-use super::progress_bar::{CliProgress, Style};
 use crate::types::Proxy as CrateProxy;
+use crate::utils::ProgressHandler;
 use crate::{build_config, setter};
 
 fn default_proxy() -> reqwest::Proxy {
     reqwest::Proxy::custom(|url| env_proxy::for_url(url).to_url())
         .no_proxy(reqwest::NoProxy::from_env())
 }
 
-#[derive(Debug)]
-pub struct DownloadOpt<T: Sized> {
+pub struct DownloadOpt<T: ProgressHandler> {
     /// The verbose name of the file to download.
     pub name: String,
-    /// Download progress handler, aka a progress bar.
-    pub handler: CliProgress<T>,
+    /// Download progress handler.
+    pub handler: T,
     /// Option to skip SSL certificate verification when downloading.
     pub insecure: bool,
     /// Proxy configurations for download.
@@ -32,9 +30,8 @@ pub struct DownloadOpt<T: Sized> {
     resume: bool,
 }
 
-impl DownloadOpt<ProgressBar> {
-    pub fn new<S: ToString>(name: S, no_progress_bar: bool) -> Self {
-        let handler = CliProgress::new(no_progress_bar);
+impl<T: ProgressHandler> DownloadOpt<T> {
+    pub fn new<S: ToString>(name: S, handler: T) -> Self {
         Self {
             name: name.to_string(),
             handler,
@@ -131,6 +128,8 @@ impl DownloadOpt<ProgressBar> {
             .content_length()
             .ok_or_else(|| anyhow!("unable to get file length of '{url}'"))?;
 
+        self.handler.set_progress(format!("downloading '{}'", &self.name), 0);
+
         let maybe_indicator = (self.handler.start)(
             format!("downloading '{}'", &self.name),
             Style::Bytes(total_size),