manaconf 0.2.1

a layered configuration 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

use std::env::{VarError, var};

use crate::helpers::join;
use crate::{Source, Key, Value};

/// A config value source that fetches values from environment variables
///
/// The source can be supplied with a prefix for environment variables
/// by using `with_prefix`.
///
/// Environment variable names, are thus then constructed as
/// `PREFIX_COMPONENT_COMPONENT_COMPONENT`
///
/// If there is no prefix then it's just `COMPONENT_COMPONENT_COMPONENT`
///
/// i.e. If the source has a prefix of `MYCONFIG` and you requested a value
/// with the key `database::connection_string`. The environment variable
/// that is looked up would be `MYCONFIG_DATABASE_CONNECTION_STRING`
///
/// It is worth noting, however, that this scheme may cause conflicts as
/// the key `database::connection_string` and `database::connection::string`
/// would result in the same environment variable `DATABASE_CONNECTION_STRING`.
pub struct EnvVarSource {
    prefix: Option<String>,
}

impl EnvVarSource {
    /// Creates an environment variable source
    pub fn new() -> Self {
        Self { prefix: None }
    }

    /// Creates an environment source with a given prefix to the environment
    /// variables name.
    pub fn with_prefix<T: Into<String>>(prefix: T) -> Self {
        Self::_with_prefix(prefix.into())
    }

    fn _with_prefix(mut prefix: String) -> Self {
        if !prefix.ends_with('_') {
            prefix.push('_');
        }

        Self {
            prefix: Some(prefix),
        }
    }
}

impl Source for EnvVarSource {
    type Error = VarError;

    fn get_value(&self, key: &Key) -> Result<Option<Value>, Self::Error> {
        let key_with_env_seperator = join(key.components(), "_");

        let mut env_key = self.prefix.clone().unwrap_or_default();
        env_key.push_str(&key_with_env_seperator);

        match var(env_key.to_uppercase()) {
            Ok(v) => Ok(Some(Value::String(v))),
            Err(std::env::VarError::NotPresent) => Ok(None),
            Err(e) => Err(e),
        }
    }
}