ajour_core/config/
addons.rs

1use super::Flavor;
2use crate::repository::{GlobalReleaseChannel, ReleaseChannel};
3use de::de_ignored;
4use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6
7/// Struct for addons specific settings.
8#[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Eq)]
9pub struct Addons {
10    #[serde(default)]
11    pub global_release_channel: GlobalReleaseChannel,
12
13    #[serde(default, deserialize_with = "de_ignored")]
14    pub ignored: HashMap<Flavor, Vec<String>>,
15
16    #[serde(default)]
17    pub release_channels: HashMap<Flavor, HashMap<String, ReleaseChannel>>,
18
19    #[serde(default)]
20    pub delete_saved_variables: bool,
21}
22
23impl Default for Addons {
24    fn default() -> Self {
25        Addons {
26            global_release_channel: GlobalReleaseChannel::Stable,
27            ignored: HashMap::new(),
28            release_channels: HashMap::new(),
29            delete_saved_variables: Default::default(),
30        }
31    }
32}
33
34mod de {
35    use crate::config::Flavor;
36    use serde::{
37        de::{self, MapAccess, SeqAccess, Visitor},
38        Deserialize, Deserializer,
39    };
40    use std::collections::HashMap;
41    use std::fmt;
42
43    pub(crate) fn de_ignored<'de, D>(
44        deserializer: D,
45    ) -> Result<HashMap<Flavor, Vec<String>>, D::Error>
46    where
47        D: Deserializer<'de>,
48    {
49        struct DeIgnored;
50
51        impl<'de> Visitor<'de> for DeIgnored {
52            type Value = HashMap<Flavor, Vec<String>>;
53
54            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
55                formatter.write_str("Vec<String> or HashMap<Flavor, Vec<String>>")
56            }
57
58            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
59            where
60                A: SeqAccess<'de>,
61            {
62                let mut map = HashMap::new();
63                let mut ignored = vec![];
64
65                while let Ok(Some(value)) = seq.next_element::<String>() {
66                    ignored.push(value);
67                }
68
69                map.insert(Flavor::Retail, ignored.clone());
70                map.insert(Flavor::Classic, ignored);
71
72                Ok(map)
73            }
74
75            fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
76            where
77                A: MapAccess<'de>,
78            {
79                Deserialize::deserialize(de::value::MapAccessDeserializer::new(map))
80            }
81        }
82
83        deserializer.deserialize_any(DeIgnored)
84    }
85}