confine 0.1.4

An opinionated configuration macro built on top of config-rs
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

# confine-rs
[![Crates.io](https://img.shields.io/crates/v/confine.svg)](https://crates.io/crates/confine)

This crate provides both a macro and a builder API for loading configuration files.
I would recommend using the macro for most use cases, as it provides a more concise way of loading configuration files.
Using either one, you will be provided with a `try_load` function for your configuration struct.
This will instantiate your struct with the configuration values from the following sources in order of precedence:

1. `config/application.toml`
2. `config/application-{environment}.toml`
3. Environment variables

The environment is determined by the `CONFINE_ENV` environment variable, which _must_ be set in order to load the environment-specific configuration file.

You can configure most of these settings, but the general structure is always enforced.
Things you can configure include:
- The path to the configuration files (default: `config`)
- The prefix of the configuration files (default: `application`)
- The environment variable that determines the environment (default: `CONFINE_ENV`)
## Usage

### Default configuration
#### Macro
```rust
use confine::confine;

fn main() {
    let config = MyConfig::try_load().unwrap();
}

#[derive(Deserialize)]
#[confine]
struct MyConfig {
    pub my_int: i64,
    pub my_string: String,
    pub my_bool: bool,
}
```

#### Builder
```rust
use confine::ConfineConfigBuilder;
use serde::Deserialize;

fn main() {
    let config = ConfineConfigBuilder::default()
        .try_load::<MyConfig>()
        .unwrap();
}

#[derive(Deserialize)]
struct MyConfig {
    pub my_int: i64,
    pub my_string: String,
    pub my_bool: bool,
}
```

### Custom configuration
#### Macro
```rust
use confine::confine;

fn main() {
    let config = MyConfig::try_load().unwrap();
}

#[derive(Deserialize)]
#[confine(
    path = "my_config",
    prefix = "my_prefix",
    env_var = "MY_ENV"
)]
struct MyConfig {
    pub my_int: i64,
    pub my_string: String,
    pub my_bool: bool,
}
```

#### Builder
```rust
use confine::ConfineConfigBuilder;
use serde::Deserialize;

fn main() {
    let config = ConfineConfigBuilder::default()
        .path("my_config")
        .prefix("my_prefix")
        .env_var("MY_ENV")
        .try_load::<MyConfig>()
        .unwrap();
}

#[derive(Deserialize)]
struct MyConfig {
    pub my_int: i64,
    pub my_string: String,
    pub my_bool: bool,
}
```

## Motivation
I found myself writing the same boilerplate code for loading configuration files in Rust over and over again.
Also, while `config-rs` is a great library, it allows for a lot of flexibility in how _exactly_ you handle configuration.
Especially when working on multiple projects, I prefer to have a consistent way of storing and loading configuration files.
This crate aims to provide an easy-to-use macro for loading configuration files with sensible defaults.