diode-base 0.1.0

Basic services for the diode library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::collections::BTreeMap;
use std::path::Path;

use diode::{Extract, StdError};
use serde::{Deserialize, Serialize, de::DeserializeOwned};

#[derive(Default, Serialize, Deserialize)]
pub struct Config {
    #[serde(flatten)]
    pub(crate) configs: BTreeMap<String, serde_json::Value>,
}

pub trait ConfigSection: DeserializeOwned {
    fn key() -> &'static str;
}

impl Config {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn get<T>(&self, name: impl AsRef<str>) -> Result<T, StdError>
    where
        T: DeserializeOwned,
    {
        Ok(serde_json::from_value(
            self.configs
                .get(name.as_ref())
                .cloned()
                .unwrap_or(serde_json::Value::Null),
        )?)
    }

    pub fn set<T>(&mut self, name: impl Into<String>, value: T) -> Result<(), StdError>
    where
        T: Serialize,
    {
        self.configs
            .insert(name.into(), serde_json::to_value(value)?);
        Ok(())
    }

    pub fn with<T>(mut self, name: impl Into<String>, value: T) -> Self
    where
        T: Serialize,
    {
        self.configs
            .insert(name.into(), serde_json::to_value(value).unwrap());
        self
    }

    pub fn merge_from(&mut self, other: Self) -> Result<(), StdError> {
        for (key, value) in other.configs {
            let entry = self.configs.entry(key);
            merge_json_from(entry.or_insert(serde_json::Value::Null), value)?;
        }
        Ok(())
    }

    pub fn parse<T>(text: T) -> Result<Self, StdError>
    where
        T: AsRef<str>,
    {
        Ok(serde_json::from_str(text.as_ref())?)
    }

    pub async fn parse_file(path: impl AsRef<Path>) -> Result<Self, StdError> {
        let text = tokio::fs::read_to_string(path).await?;
        Self::parse(text)
    }

    /// Check if the config is empty
    pub fn is_empty(&self) -> bool {
        self.configs.is_empty()
    }

    /// Get the number of config entries
    pub fn len(&self) -> usize {
        self.configs.len()
    }
}

impl<T> Extract<T> for Config
where
    T: ConfigSection,
{
    fn extract(app: &diode::AppBuilder) -> Result<T, diode::AppError> {
        Ok(app
            .get_component_ref::<Config>()
            .unwrap()
            .get::<T>(T::key())
            .unwrap())
    }
}

fn merge_json_from(lhs: &mut serde_json::Value, rhs: serde_json::Value) -> Result<(), StdError> {
    match lhs {
        serde_json::Value::Object(l) => match rhs {
            serde_json::Value::Object(r) => {
                for (key, value) in r {
                    let entry = l.entry(key);
                    merge_json_from(entry.or_insert(serde_json::Value::Null), value)?;
                }
            }
            _ => *lhs = rhs,
        },
        serde_json::Value::Array(l) => match rhs {
            serde_json::Value::Array(r) => {
                l.extend(r);
            }
            _ => *lhs = rhs,
        },
        _ => *lhs = rhs,
    }
    Ok(())
}