envious allows you to deserialize your serde enabled structs from
environment variables.
See it in action:
```rust,no_run use serde::{Deserialize, Serialize};
enum StaircaseOrientation { Left, Right, }
struct Config { targettemp: f32, automatedoors: bool,
staircase_orientation: StaircaseOrientation,
}
let config: Config = envious::from_env(envious::Prefix::None).expect("Could not deserialize from env"); ```
With the following environment variables:
bash
EXPORT target_temp=25.0
EXPORT automate_doors=true
EXPORT staircase_orientation=Left
it will parse it from the environment and give you a Rust struct you can use in your application.
Note: The environment variables are case sensitive! This is due to how
serdeworks internally. If you want your structs to use SCREAMINGSNAKECASE, then be sure to use the#[serde(rename_all = "SCREAMING_SNAKE_CASE"]annotation on all concerned structs.
To use envious simply add it to your Cargo.toml with:
bash
cargo add envious
and deserialize from your environment with envious::from_env!
⚠️ Current Shortcomings
The mapping between environment variables and the serde model is as follows:
__ in their namesFor example, if you have the following struct:
```rust use serde::{Deserialize, Serialize};
struct Radiator { mintemp: f32, maxtemp: f32, }
struct Config {
target_temp: f32,
radiator: Option
You can deserialize Config with the following variables:
bash
export target_temp=21.0
export radiator__min_temp=15.0
export radiator__max_temp=30.0
Arrays are represented as anonymous structs, with the 'fields' being the individual elements.
A more complex example could look like this:
```rust use serde::{Deserialize, Serialize};
enum Material { Wood, Plastic, }
struct Door { width: f32, height: f32, material: Material, }
struct House {
age: u32,
entrance_doors: Vec
Now, to deserialize a House we can set the following variables:
bash
export age=120
export entrance_doors__0__width=100
export entrance_doors__0__height=100
export entrance_doors__0__material="Wood"
export entrance_doors__1__width=200
export entrance_doors__1__height=120
export entrance_doors__1__material="Plastic"
export entrance_doors__foo__width=400
export entrance_doors__foo__height=20
export entrance_doors__foo__material="Plastic"
As you can see, the individual 'keys' of the array do not matter! The same key refers to the same object though.
As you can see in the example above, the Material enum gets simply deserialized from the name of the variant. Be careful about upper/lower case Serde expects per-default that the case is exactly the same!
Per default serde uses external tagging for more complicated enum variants.
Tuple enums are currently only supported with a single value.
To see what this means, lets take this enum as an example:
```rust use serde::{Deserialize, Serialize};
enum Shape { Rectangle { width: f32, height: f32 }, Circle(f32), Nothing, }
struct Config { expected_shape: Shape, } ```
To deserialize Config here, we can use the following variables:
```bash export expectedshapeRectanglewidth=50.0 export expectedshapeRectangleheight=10.0
// OR
export expectedshape_Circle=15.0
// OR
export expected_shape=Nothing ```
Any of these sets of variables would give you the expected outcome.
Should you change the tagging of your struct, be sure to adapt the given variables.
envious is licensed under MIT or Apache 2.0, as you wish.
To contribute to envious you can: