envoke 0.3.0

A simple and ergonomic way to load environment variables into struct fields.
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

use std::error::Error as StdError;

use thiserror::Error;

#[doc(hidden)]
pub type Result<T> = std::result::Result<T, Error>;

#[doc(hidden)]
pub type BoxError = Box<dyn StdError + Send + Sync + 'static>;

#[derive(Debug, Error, strum::EnumIs)]
pub enum ParseError {
    #[error("key-value pair has no key")]
    MissingKey,

    #[error("key-value pair has no value")]
    MissingValue,

    #[error("found equalsign with no key or value around it")]
    UnexpectedEqualsign,

    #[error("key `{key}` is of unexpected type")]
    UnexpectedKeyType { key: String },

    #[error("value `{value}` is of unexpected type")]
    UnexpectedValueType { value: String },

    #[error("parsing failed for `{field}`: {err}")]
    Failed {
        field: String,
        #[source]
        err: BoxError,
    },
}

#[derive(Debug, Error, strum::EnumIs)]
pub enum RetrieveError {
    #[error("none of the environment variables ({keys}) was found")]
    NotFound { keys: String },

    #[error("environment variable `{key}` contains invalid Unicode")]
    InvalidUnicode { key: String },

    #[error("fatal error occurred")]
    Fatal,
}

#[derive(Debug, Error)]
pub enum EnumError {
    #[error("enum not found")]
    NotFound,
}

#[derive(Debug, Error)]
pub enum ValidationError {
    #[error("validation failed for `{field}`: {err}")]
    Failed {
        field: String,
        #[source]
        err: BoxError,
    },
}

#[derive(Debug, Error, strum::EnumIs)]
pub enum Error {
    #[error("Retrieve error occurred: {0}")]
    RetrieveError(#[from] RetrieveError),

    #[error("Parse error occurred: {0}")]
    ParseError(#[from] ParseError),

    #[error("Validation error occurred: {0}")]
    ValidationError(#[from] ValidationError),

    #[error("Enum error occurred: {0}")]
    EnumError(#[from] EnumError),

    #[error("Failed to convert field `{field}` to expected type `{ty}`")]
    ConvertError { field: String, ty: String },
}