vne 0.0.1

Environment variables.
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

//! # vne
//!
//!> [!WARNING]
//!> This is just an proof of concept of a stupid idea I had. It is probably not ready for use.
//!
//!Environment variables.
//!
//!## Usage
//!
//!You can setup `vne` in your `main.rs` like the following:
//!
//!```rust
//!fn main() {
//!  // This will ensure all variables declared by a usage of `vne!` exist.
//!  ENV.validate().unwrap();
//!
//!  // The rest of your code
//!  let testing: String = vne::vne!("TESTING");
//!}
//!
//!// It is *really* important this is in `main.rs` and at the bottom of the file!
//!const ENV: vne::Environment = vne::build!();
//!```
//!
//!## Framework integration
//!
//!You can statically analyze the environment variables that exist within your project. This could be used by a framework to show warning at deploy time for example. You can read the `target/vne` file and parse it with in the following format:
//!
//!```text
//!{time}\n
//!# The following repeats
//!{crate_name}\t{bin_name}\t{env_1}\t{env_2}\n
//!```
//!
//!## Inspiration
//!
//!We make use of the pattern which I originally came across in [macro_state](https://github.com/sam0x17/macro_state).
#![cfg_attr(docsrs, feature(doc_cfg))]

use std::{path::PathBuf, sync::atomic::AtomicBool};

pub use vne_macros::{build, vne};

static HAS_VALIDATED: AtomicBool = AtomicBool::new(false);

pub struct Environment {
    envs: &'static [&'static str],
}

impl Environment {
    // TODO: Error handling
    pub fn load(self, path: impl Into<PathBuf>) -> Self {
        let path = path.into();

        // TODO: Handle `.env.example`, `.env.local`, etc
        // TODO: Allow `path` to be to directory or direct file

        if path.join(".env").exists() {
            let raw = std::fs::read_to_string(path.join(".env"))
                .expect("vne error: failed to read environment file");

            let envs = raw
                .lines()
                .map(|v| v.trim())
                .filter(|v| !v.is_empty())
                .filter(|v| !v.starts_with('#'))
                .map(|v| v.splitn(2, "="))
                .map(|mut v| (v.next().unwrap(), v.next().unwrap().trim_matches('"')));

            for (key, value) in envs {
                if std::env::var(key).is_err() {
                    std::env::set_var(key, value);
                }
            }
        } else {
            panic!("vne error: failed to find .env file")
        }

        self
    }

    // TODO: Proper error type
    pub fn validate(&self) -> Result<(), String> {
        for env in self.envs {
            if std::env::var(env).is_err() {
                return Err(format!("vne error: missing environment variable {env:?}"));
            }
        }

        HAS_VALIDATED.store(true, std::sync::atomic::Ordering::SeqCst);
        Ok(())
    }
}

#[doc(hidden)]
pub mod internal {
    use super::*;

    pub const fn construct_env(envs: &'static [&'static str]) -> Environment {
        Environment { envs }
    }

    pub fn from_env(key: &'static str) -> String {
        if !HAS_VALIDATED.load(std::sync::atomic::Ordering::SeqCst) {
            panic!("vne error: attempted to access environment variable before validation was run");
        }

        std::env::var(key).expect("vne error: unreachable failed to get env")
    }
}