envbind 0.1.0

Typed environment binding primitives for Rust services.
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

//! Environment readers used by binders and settings objects.

use std::collections::BTreeMap;
use std::env;
use std::fmt::{self, Debug, Formatter};

use crate::error::EnvironmentError;

/// Return raw environment values by name.
pub trait Environment {
    /// Return the raw string value for a name when present.
    fn get(&self, name: &str) -> Result<Option<String>, EnvironmentError>;
}

/// Read values from the process environment.
#[derive(Debug, Default, Clone, Copy)]
pub struct ProcessEnvironment;

impl Environment for ProcessEnvironment {
    fn get(&self, name: &str) -> Result<Option<String>, EnvironmentError> {
        match env::var(name) {
            Ok(value) => Ok(Some(value)),
            Err(env::VarError::NotPresent) => Ok(None),
            Err(env::VarError::NotUnicode(_)) => Err(EnvironmentError::not_unicode()),
        }
    }
}

/// Read values from an in-memory map.
#[derive(Default, Clone, PartialEq, Eq)]
pub struct MapEnvironment {
    values: BTreeMap<String, String>,
}

impl Debug for MapEnvironment {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("MapEnvironment")
            .field("len", &self.values.len())
            .finish()
    }
}

impl MapEnvironment {
    /// Build an empty in-memory environment.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Build an in-memory environment from key-value pairs.
    #[must_use]
    pub fn from_pairs<I, K, V>(pairs: I) -> Self
    where
        I: IntoIterator<Item = (K, V)>,
        K: Into<String>,
        V: Into<String>,
    {
        let values = pairs
            .into_iter()
            .map(|(name, value)| (name.into(), value.into()))
            .collect::<BTreeMap<String, String>>();
        Self { values }
    }

    /// Insert or replace one key-value pair.
    pub fn insert(&mut self, name: impl Into<String>, value: impl Into<String>) {
        self.values.insert(name.into(), value.into());
    }
}

impl Environment for MapEnvironment {
    fn get(&self, name: &str) -> Result<Option<String>, EnvironmentError> {
        Ok(self.values.get(name).cloned())
    }
}