Allow one or more format to be used

src/blocks/prelude.rs

@@ -4,7 +4,10 @@ pub(crate) use crate::REQWEST_CLIENT;
 pub(crate) use crate::REQWEST_CLIENT_IPV4;
 pub use crate::click::MouseButton;
 pub use crate::errors::*;
-pub use crate::formatting::{Values, config::Config as FormatConfig, value::Value};
+pub use crate::formatting::{
+    Values, config::Config as FormatConfig, config::MaybeMultiConfig as MaybeMultiFormatConfig,
+    value::Value,
+};
 pub use crate::util::{default, new_dbus_connection, new_system_dbus_connection};
 pub use crate::widget::{State, Widget};
 pub use crate::wrappers::{Seconds, ShellString};

src/blocks/time.rs

@@ -4,7 +4,7 @@
 //!
 //! Key        | Values | Default
 //! -----------|--------|--------
-//! `format`   | Format string. See [chrono docs](https://docs.rs/chrono/0.3.0/chrono/format/strftime/index.html#specifiers) for all options. | `" $icon $timestamp.datetime() "`
+//! `format`   | MultiFormat string. See [chrono docs](https://docs.rs/chrono/0.3.0/chrono/format/strftime/index.html#specifiers) for all options. | `[" $icon $timestamp.datetime() "]`
 //! `interval` | Update interval in seconds | `10`
 //! `timezone` | A timezone specifier (e.g. "Europe/Lisbon") | Local timezone
 //!
@@ -55,9 +55,10 @@ use chrono_tz::Tz;
 use super::prelude::*;
 
 #[derive(Deserialize, Debug, SmartDefault)]
-#[serde(deny_unknown_fields, default)]
+#[serde(default)]
 pub struct Config {
-    pub format: FormatConfig,
+    #[serde(flatten)]
+    pub format: MaybeMultiFormatConfig,
     #[default(10.into())]
     pub interval: Seconds,
     pub timezone: Option<Timezone>,
@@ -77,7 +78,7 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
         (MouseButton::Right, None, "prev_timezone"),
     ])?;
 
-    let format = config
+    let mut formats = config
         .format
         .with_default(" $icon $timestamp.datetime() ")?;
 
@@ -104,7 +105,7 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
     timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
 
     loop {
-        let mut widget = Widget::new().with_format(format.clone());
+        let mut widget = Widget::new().with_format(formats.get_format().clone());
         let now = Utc::now();
 
         widget.set_values(map! {
@@ -129,6 +130,12 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
                 "prev_timezone" => {
                     timezone = timezone_iter.nth(prev_step_length);
                 },
+                "next_format" => {
+                    formats.next_format();
+                },
+                "prev_format" => {
+                   formats.prev_format();
+                },
                 _ => (),
             }
         }

src/formatting.rs

@@ -162,6 +162,33 @@ pub enum FormatError {
     Other(#[from] Error),
 }
 
+#[derive(Debug, Clone)]
+pub struct MultiFormat {
+    // The length is always at least one, so we don't need to worry about
+    // dividing by zero when doing the modulo math to calculate the
+    // previous and next formats.
+    formats: Vec<Format>,
+    index: usize,
+}
+
+impl MultiFormat {
+    pub fn new(formats: Vec<Format>) -> Self {
+        Self { formats, index: 0 }
+    }
+
+    pub fn get_format(&self) -> &Format {
+        &self.formats[self.index]
+    }
+
+    pub fn next_format(&mut self) {
+        self.index = (self.index + 1) % self.formats.len();
+    }
+
+    pub fn prev_format(&mut self) {
+        self.index = (self.index + (self.formats.len() - 1)) % self.formats.len();
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Format {
     full: FormatTemplate,

src/formatting/config.rs

@@ -1,7 +1,8 @@
-use super::{Format, template::FormatTemplate};
+use super::{Format, MultiFormat, template::FormatTemplate};
 use crate::errors::*;
 use serde::de::{MapAccess, Visitor};
 use serde::{Deserialize, Deserializer, de};
+use smart_default::SmartDefault;
 use std::fmt;
 use std::str::FromStr;
 
@@ -83,6 +84,49 @@ impl Config {
     }
 }
 
+#[derive(Deserialize, Debug, Clone, SmartDefault)]
+#[serde(deny_unknown_fields, untagged)]
+pub enum MaybeMultiConfig {
+    #[default]
+    Split {
+        format: Option<Config>,
+        format_alt: Option<Config>,
+    },
+    Multiple {
+        format: Vec<Config>,
+    },
+}
+
+impl MaybeMultiConfig {
+    pub fn with_default(&self, default_full: &str) -> Result<MultiFormat> {
+        self.with_defaults(default_full, "")
+    }
+
+    pub fn with_defaults(&self, default_full: &str, default_short: &str) -> Result<MultiFormat> {
+        Ok(MultiFormat::new(match self {
+            MaybeMultiConfig::Multiple { format: configs } if configs.is_empty() => {
+                vec![Config::default().with_defaults(default_full, default_short)?]
+            }
+            MaybeMultiConfig::Multiple { format: configs } => configs
+                .iter()
+                .map(|config| config.with_defaults("", ""))
+                .collect::<Result<Vec<_>>>()?,
+            MaybeMultiConfig::Split { format, format_alt } => {
+                let mut formats = Vec::new();
+                if let Some(format) = format {
+                    formats.push(format.with_defaults("", "")?);
+                } else {
+                    formats.push(Config::default().with_defaults(default_full, default_short)?);
+                }
+                if let Some(format_alt) = format_alt {
+                    formats.push(format_alt.with_defaults("", "")?);
+                }
+                formats
+            }
+        }))
+    }
+}
+
 impl FromStr for Config {
     type Err = Error;