serfig 0.1.0

Layered configuration system built upon serde
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

use std::fmt::Debug;
use std::marker::PhantomData;

use anyhow::Result;
use log::debug;
use serde::de::DeserializeOwned;
use serde::Serialize;
use serde_bridge::{IntoValue, Value};

use crate::collectors::collector::IntoCollector;
use crate::Collector;

/// load config from env.
///
/// # Examples
///
/// ```
/// use serde::Deserialize;
/// use serde::Serialize;
/// use serfig::Builder;
/// use serfig::collectors::from_env;
///
/// #[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
/// #[serde(default)]
/// struct TestConfig {
///     a: String,
///     b: String,
///     c: i64,
/// }
///
/// fn main() -> anyhow::Result<()> {
///     let builder = Builder::default()
///         .collect(from_env());
///     let t: TestConfig = builder.build()?;
///
///     println!("{:?}", t);
///     Ok(())
/// }
/// ```
pub fn from_env<V>() -> Environment<V>
where
    V: DeserializeOwned + Serialize + Debug,
{
    Environment {
        phantom: PhantomData::default(),
    }
}

/// Collector that can load config from env.
///
/// Created by [`from_env`].
#[derive(Debug)]
pub struct Environment<V: DeserializeOwned + Serialize + Debug> {
    phantom: PhantomData<V>,
}

impl<V> Collector<V> for Environment<V>
where
    V: DeserializeOwned + Serialize + Debug,
{
    fn collect(&mut self) -> Result<Value> {
        let v: V = serde_env::from_env()?;
        debug!("value parsed from env: {:?}", v);
        Ok(v.into_value()?)
    }
}

impl<V> IntoCollector<V> for Environment<V>
where
    V: DeserializeOwned + Serialize + Debug + 'static,
{
    fn into_collector(self) -> Box<dyn Collector<V>> {
        Box::new(self)
    }
}

#[cfg(test)]
mod tests {
    use log::debug;
    use serde::{Deserialize, Serialize};
    use serde_bridge::FromValue;

    use super::*;

    #[derive(Debug, Serialize, Deserialize, PartialEq)]
    struct TestStruct {
        #[serde(rename = "serfig_test_str")]
        test_str: String,
    }

    #[test]
    fn test_env() {
        let _ = env_logger::try_init();

        temp_env::with_vars(vec![("serfig_test_str", Some("test_str"))], || {
            let mut c: Environment<TestStruct> = from_env();

            let v = c.collect().expect("must success");

            debug!("value: {:?}", v);
            let t = TestStruct::from_value(v).expect("must success");

            assert_eq!(
                t,
                TestStruct {
                    test_str: "test_str".to_string()
                }
            )
        })
    }
}