confroid 0.0.4

The n+1-st config reader for your environment-based configs.
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
117

//! Reading enum-valued configuration.
//!
//! An enum is just a scalar: implement `FromStr` for it and derive
//! `confroid::ConfigValue`. Run it with, for example:
//!
//! ```sh
//! LOG_LEVEL=debug MODE=cluster cargo run -p confroid --example enum_config
//! ```

use std::fmt;
use std::str::FromStr;

#[derive(Debug)]
struct ParseEnumError(String);

impl fmt::Display for ParseEnumError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.0)
    }
}

impl std::error::Error for ParseEnumError {}

/// How chatty the logs are.
#[derive(confroid::ConfigValue, Debug, Clone, Copy, PartialEq, Eq)]
enum LogLevel {
    Error,
    Warn,
    Info,
    Debug,
    Trace,
}

impl FromStr for LogLevel {
    type Err = ParseEnumError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "error" => Ok(Self::Error),
            "warn" | "warning" => Ok(Self::Warn),
            "info" => Ok(Self::Info),
            "debug" => Ok(Self::Debug),
            "trace" => Ok(Self::Trace),
            other => Err(ParseEnumError(format!(
                "unknown log level `{other}` (expected error|warn|info|debug|trace)"
            ))),
        }
    }
}

impl fmt::Display for LogLevel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(match self {
            Self::Error => "error",
            Self::Warn => "warn",
            Self::Info => "info",
            Self::Debug => "debug",
            Self::Trace => "trace",
        })
    }
}

/// Which deployment mode to run in.
#[derive(confroid::ConfigValue, Debug, Clone, Copy, PartialEq, Eq)]
enum Mode {
    Standalone,
    Cluster,
}

impl FromStr for Mode {
    type Err = ParseEnumError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "standalone" => Ok(Self::Standalone),
            "cluster" => Ok(Self::Cluster),
            other => Err(ParseEnumError(format!(
                "unknown mode `{other}` (expected standalone|cluster)"
            ))),
        }
    }
}

impl fmt::Display for Mode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(match self {
            Self::Standalone => "standalone",
            Self::Cluster => "cluster",
        })
    }
}

#[derive(confroid::Config, Debug)]
#[allow(dead_code)] // fields are read via Debug in `main`
struct Config {
    /// Logging verbosity.
    #[confroid(default = LogLevel::Info, example = "debug")]
    log_level: LogLevel,
    /// Deployment mode.
    #[confroid(default = Mode::Standalone)]
    mode: Mode,
}

fn main() {
    // Read from the process environment (falling back to the defaults).
    match confroid::from_env::<Config>() {
        Ok(config) => println!("from environment: {config:?}"),
        Err(err) => eprintln!("config error: {err}"),
    }

    // A self-contained demonstration using explicit values:
    let config: Config =
        confroid::from_pairs([("LOG_LEVEL", "debug"), ("MODE", "cluster")]).expect("valid config");
    println!("explicit:        {config:?}");

    let defaults: Config =
        confroid::from_pairs(Vec::<(&str, &str)>::new()).expect("defaults are total");
    println!("all defaults:    {defaults:?}");
}