Skip to main content

alfred_workflow_rs/
automatic_cache.rs

1use serde::ser::SerializeMap;
2use serde::{Deserialize, Serialize};
3
4use crate::{Error, Result};
5
6/// Alfred Script Filter automatic cache metadata.
7#[derive(Clone, Debug, Eq, PartialEq)]
8pub struct AutomaticCache {
9    seconds: u64,
10    loose_reload: Option<bool>,
11}
12
13impl Serialize for AutomaticCache {
14    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15    where
16        S: serde::Serializer,
17    {
18        let mut map =
19            serializer.serialize_map(Some(1 + usize::from(self.loose_reload.is_some())))?;
20        map.serialize_entry("seconds", &self.seconds)?;
21        if let Some(loose_reload) = self.loose_reload {
22            map.serialize_entry("loosereload", &loose_reload)?;
23        }
24        map.end()
25    }
26}
27
28impl AutomaticCache {
29    /// Minimum accepted cache duration in seconds.
30    pub const MIN_SECONDS: u64 = 5;
31    /// Maximum accepted cache duration in seconds.
32    pub const MAX_SECONDS: u64 = 86_400;
33
34    /// Creates automatic cache metadata with the given duration.
35    pub fn try_new(seconds: u64) -> Result<Self> {
36        Self::try_with_loose_reload(seconds, None)
37    }
38
39    /// Creates automatic cache metadata with an optional `loosereload` flag.
40    pub fn try_with_loose_reload(seconds: u64, loose_reload: Option<bool>) -> Result<Self> {
41        if !(Self::MIN_SECONDS..=Self::MAX_SECONDS).contains(&seconds) {
42            return Err(Error::InvalidAutomaticCacheSeconds {
43                seconds,
44                min: Self::MIN_SECONDS,
45                max: Self::MAX_SECONDS,
46            });
47        }
48
49        Ok(Self {
50            seconds,
51            loose_reload,
52        })
53    }
54
55    /// Returns the cache duration in seconds.
56    pub fn seconds(&self) -> u64 {
57        self.seconds
58    }
59
60    /// Returns the optional Alfred `loosereload` flag.
61    pub fn loose_reload(&self) -> Option<bool> {
62        self.loose_reload
63    }
64}
65
66impl<'de> Deserialize<'de> for AutomaticCache {
67    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
68    where
69        D: serde::Deserializer<'de>,
70    {
71        #[derive(Deserialize)]
72        struct Wire {
73            seconds: u64,
74            #[serde(rename = "loosereload", default)]
75            loose_reload: Option<bool>,
76        }
77
78        let wire = Wire::deserialize(deserializer)?;
79        Self::try_with_loose_reload(wire.seconds, wire.loose_reload)
80            .map_err(serde::de::Error::custom)
81    }
82}