wrath 0.1.0

A structured approach to accessing environment variables
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Parsing environment variable values into structured data

use std::{
    convert::{From as FromTrait, Infallible},
    default::Default as DefaultTrait,
    ffi::OsString,
    str::FromStr as FromStrTrait,
};

use crate::error;

/// Parse via the [`FromStr`](FromStrTrait) trait
#[derive(Debug, Default)]
pub struct FromStr<T>(pub T);

/// "Parse" via the [`From`](FromTrait) trait
#[derive(Debug, Default)]
pub struct From<T>(pub T);

/// "Parse" via the [`OsString::into_string`][0] method
///
/// [0]: std::ffi::OsString::into_string
#[derive(Debug, Default)]
pub struct IntoString(pub String);

/// Parse or get a default value via the [`Default`](DefaultTrait) trait
#[derive(Debug, Default)]
pub struct Default<T>(pub T);

/// Parse an environment variable value into structured data
///
/// This trait is an abstraction over other parsing strategies, such as
/// [`FromStr`](FromStrTrait), and its interface is more specialized for dealing
/// with environment variables.
pub trait Parser
where
    Self: Sized,
{
    /// Type system indication of whether being unset is an error
    type ErrorUnset: error::Unset;

    /// The error that can occur while trying to parse the target type
    type ErrorParse;

    /// Parse an [`OsString`] into structured data
    ///
    /// # Errors
    ///
    /// In general, this function may fail if `input` is [`None`] or if parsing
    /// failed. However, some parsers, or combinations thereof, lack one or both
    /// of these failure modes, which is also valid.
    fn parse(
        input: Option<OsString>,
    ) -> Result<Self, error::Value<Self::ErrorUnset, Self::ErrorParse>>;
}

impl<T> Parser for Option<T>
where
    T: Parser,
{
    type ErrorParse = T::ErrorParse;
    type ErrorUnset = Infallible;

    fn parse(
        input: Option<OsString>,
    ) -> Result<Self, error::Value<Self::ErrorUnset, Self::ErrorParse>> {
        match T::parse(input) {
            Ok(x) => Ok(Some(x)),
            Err(e) => match e {
                error::Value::Unset(_) => Ok(None),
                error::Value::Parse(e) => Err(error::Value::Parse(e)),
            },
        }
    }
}

impl<T> Parser for FromStr<T>
where
    T: FromStrTrait,
{
    type ErrorParse = error::FromStr<T::Err>;
    type ErrorUnset = ();

    fn parse(
        input: Option<OsString>,
    ) -> Result<Self, error::Value<Self::ErrorUnset, Self::ErrorParse>> {
        let input = input.ok_or(error::Value::Unset(()))?;

        let Some(str) = input.to_str() else {
            return Err(error::Value::Parse(error::FromStr::Convert(input)));
        };

        T::from_str(str)
            .map(Self)
            .map_err(|e| error::Value::Parse(error::FromStr::Parse(e)))
    }
}

impl Parser for IntoString {
    type ErrorParse = OsString;
    type ErrorUnset = ();

    fn parse(
        input: Option<OsString>,
    ) -> Result<Self, error::Value<Self::ErrorUnset, Self::ErrorParse>> {
        input
            .ok_or(error::Value::Unset(()))?
            .into_string()
            .map(Self)
            .map_err(error::Value::Parse)
    }
}

impl<T> Parser for From<T>
where
    T: FromTrait<OsString>,
{
    type ErrorParse = Infallible;
    type ErrorUnset = ();

    fn parse(
        input: Option<OsString>,
    ) -> Result<Self, error::Value<Self::ErrorUnset, Self::ErrorParse>> {
        let input = input.ok_or(error::Value::Unset(()))?;

        Ok(Self(T::from(input)))
    }
}

impl<T> Parser for Default<T>
where
    T: Parser + DefaultTrait,
{
    type ErrorParse = T::ErrorParse;
    type ErrorUnset = Infallible;

    fn parse(
        input: Option<OsString>,
    ) -> Result<Self, error::Value<Self::ErrorUnset, Self::ErrorParse>> {
        match T::parse(input) {
            Ok(x) => Ok(Self(x)),
            Err(e) => match e {
                error::Value::Unset(_) => Ok(Self(T::default())),
                error::Value::Parse(e) => Err(error::Value::Parse(e)),
            },
        }
    }
}