renvar 0.1.0

Library to deserialize environment variables in to Rust datatypes
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

# Renvar

`renvar` is a library to deserialize environment variables into Rust data structures.

Huge thanks to [softprops](https://github.com/softprops) for [envy](https://github.com/softprops/envy), as this library is inspired by it
and borrows much of the code from there.

# Installation

Add it to your `Cargo.toml`

```toml
[dependencies]
renvar = "0.1"
```

# Usage

```rust
use renvar::{from_env, from_iter, from_str};
use serde::Deserialize;
use std::env;

let env_content = r#"
name=renvar
type=Library
dependencies=serde
"#;

#[derive(Debug, Deserialize, PartialEq, Eq)]
enum CrateType {
    Library,
    Binary,
}

#[derive(Debug, Deserialize, PartialEq, Eq)]
struct Renvar {
    name: String,
    #[serde(rename = "type")]
    typ: CrateType,
    dependencies: Vec<String>,
}

let actual = Renvar {
    name: "renvar".to_owned(),
    typ: CrateType::Library,
    dependencies: vec!["serde".to_owned()],
};

// we can read from strings

let value = from_str::<Renvar>(env_content).unwrap();

assert_eq!(value, actual);

// directly from the environment

let envs = vec![
    ("name".to_owned(), "renvar".to_owned()),
    ("type".to_owned(), "Library".to_owned()),
    ("dependencies".to_owned(), "serde".to_owned()),
];

for (key, value) in envs.clone().into_iter() {
    env::set_var(key, value);
}

let value = from_env::<Renvar>().unwrap();

assert_eq!(value, actual);

// or from iterables

let value = from_iter::<Renvar, _>(envs).unwrap();

assert_eq!(value, actual);
```

# Feature flags

Renvar has the following feature flags:

## prefixed

`prefixed` gives you the `prefixed` function, that accepts a prefix. The prefixes will be stripped away
before deserialization.

## postfixed

`postfix` is exactly the same as prefix, just with postfixes

# case_insensitive_prefixed

Case insensitive variant of `prefixed`

# case_insensitive_postfixed

Case insensitive variant of `postfixed`

## with_trimmer

Finally, the `with_trimmer` feature flag gives you `*_with_trimmer` variants for all of the above,
where you can strip extraneous characters off of the beginning and end of envrironment variables
by passing a closure.

## Supported datatypes

- `Strings` and `str`s
- `enums`
- `sequences`
- `Unit structs`

# Development

## Tests

If you have [just](https://github.com/casey/just), you run `just test`,
otherwise `cargo test --all-features`