env-settings-derive 0.1.15

initialize rust structs using environment variables (like `pydantic`'s `BaseSettings`)
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

use crate::utils::attributes::inner::EnvSettingsInnerParams;

use syn::{
    Attribute, Data, Error, Fields, GenericArgument, Ident, PathArguments, PathSegment, Result,
    Type, TypePath, punctuated, token,
};

/// A non parsable field
pub(crate) struct NonParsableField {
    /// The name of the field
    pub(crate) name: Ident,

    /// The type of the field
    pub(crate) type_: Type,
}

/// A parsable field
pub(crate) struct ParsableField {
    /// The name of the field
    pub(crate) name: Ident,

    /// The name label of the field
    pub(crate) name_label: String,

    /// The type of the field
    pub(crate) type_: Type,

    /// The type label of the field
    pub(crate) type_label: String,

    /// The default value of the field
    pub(crate) default: Option<String>,

    /// The type specified in the option
    pub(crate) optional_type: Option<Type>,

    /// The environment variable name
    pub(crate) variable: Option<String>,
}

/// The field info needed to the `EnvSettings` derive
pub(crate) enum EnvSettingsField {
    /// A non parsable field
    NonParsable(Box<NonParsableField>),

    //// A parsable field
    Parsable(Box<ParsableField>),
}

impl EnvSettingsField {
    fn get_field(type_: &Type, name: &Ident, attrs: &[Attribute]) -> Result<Self> {
        let params = EnvSettingsInnerParams::parse_attributes(attrs)?;
        let non_parsable_field = NonParsableField {
            name: name.to_owned(),
            type_: type_.to_owned(),
        };
        let non_parsable_field = EnvSettingsField::NonParsable(Box::new(non_parsable_field));
        let field = if params.skip {
            non_parsable_field
        } else {
            match &type_ {
                Type::Path(type_path) => {
                    Self::get_field_from_type_path(type_, type_path, name, params)?
                }
                _ => non_parsable_field,
            }
        };
        Ok(field)
    }

    fn get_field_from_type_path(
        type_: &Type,
        type_path: &TypePath,
        name: &Ident,
        params: EnvSettingsInnerParams,
    ) -> Result<Self> {
        let mut segments = type_path.path.segments.to_owned();
        let optional_type = Self::get_optional_type(&segments);
        if let Some(Type::Path(optional_type_path)) = &optional_type {
            optional_type_path.path.segments.clone_into(&mut segments);
        }
        let type_label = segments
            .into_iter()
            .map(|segment| segment.ident.to_string())
            .collect::<Vec<String>>()
            .join("::");

        let parsable_field = ParsableField {
            name: name.to_owned(),
            name_label: name.to_string(),
            type_: type_.to_owned(),
            type_label,
            default: params.default,
            optional_type,
            variable: params.variable,
        };
        let parsable_field = EnvSettingsField::Parsable(Box::new(parsable_field));
        Ok(parsable_field)
    }

    fn get_optional_type(
        segments: &punctuated::Punctuated<PathSegment, token::PathSep>,
    ) -> Option<Type> {
        if segments[0].ident == "Option"
            && let PathArguments::AngleBracketed(arguments) = &segments[0].arguments
            && let GenericArgument::Type(optional_type) = &arguments.args[0]
        {
            Some(optional_type.to_owned())
        } else {
            None
        }
    }

    /// Parse the fields of the input
    pub(crate) fn parse_fields(data: &Data) -> Result<Vec<Self>> {
        match data {
            Data::Struct(_struct) => {
                if let Fields::Named(names_fields) = &_struct.fields {
                    let mut fields = Vec::new();
                    for field in &names_fields.named {
                        if let Some(field_name) = &field.ident {
                            let field = Self::get_field(&field.ty, field_name, &field.attrs)?;
                            fields.push(field);
                        }
                    }
                    Ok(fields)
                } else {
                    Err(Error::new(
                        _struct.struct_token.span,
                        "struct fields must be named",
                    ))
                }
            }
            Data::Enum(_enum) => Err(Error::new(_enum.enum_token.span, "enum not supported")),
            Data::Union(_union) => Err(Error::new(_union.union_token.span, "union not supported")),
        }
    }
}