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

use std::{env, fmt};

use serde::{Deserialize, Serialize};

/// Current Env
#[derive(Deserialize, Serialize)]
pub enum Env {
    /// Development
    Dev,
    /// Production
    Prod,
    /// Test
    Test,
}

impl Default for Env {
    fn default() -> Env {
        Env::Dev
    }
}

impl fmt::Debug for Env {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(match *self {
            Self::Dev => Self::DEV,
            Self::Prod => Self::PROD,
            Self::Test => Self::TEST,
        })
    }
}

impl Env {
    /// Viz environment name
    pub const NAME: &'static str = "VIZ_ENV";
    /// Development mode
    pub const DEV: &'static str = "development";
    /// Production mode
    pub const PROD: &'static str = "production";
    /// Test mode
    pub const TEST: &'static str = "test";

    /// Gets current mode
    pub fn get() -> Env {
        env::var(Self::NAME).map(From::from).unwrap_or_default()
    }
}

impl From<String> for Env {
    fn from(mut s: String) -> Env {
        s = s.trim().to_lowercase();

        if Self::DEV.starts_with(&s) {
            return Env::Dev;
        }

        if Self::PROD.starts_with(&s) {
            return Env::Prod;
        }

        if Self::TEST == s {
            return Env::Test;
        }

        Env::Dev
    }
}

impl ToString for Env {
    fn to_string(&self) -> String {
        match *self {
            Self::Dev => Self::DEV.split_at(3),
            Self::Prod => Self::PROD.split_at(4),
            Self::Test => Self::TEST.split_at(4),
        }
        .0
        .to_string()
    }
}