Struct tomlenv::Environments

pub struct Environments<S, T>where
    S: Ord,{ /* private fields */ }

Hold environment specific data as a map from your environment hierarchy key to data struct containg the config for that particular environment.

Example

// Your environment specific data struct
// *NOTE*: This must implement `Deserialize` and `Serialize`
#[derive(Debug, Deserialize, Getters, Serialize)]
struct RuntimeEnv {
  #[get]
  name: String,
  #[get]
  key: Option<String>,
}

// Your environment specific configuration
let toml = r#"[envs.prod]
name = "Production"
key = "abcd-123-efg-45"

[envs.stage]
name = "Stage"

[envs.test]
name = "Test"

[envs.dev]
name = "Development"

[envs.local]
name = "Local"
"#;

// Deserialize the TOML config into your environment structs
let mut cursor = Cursor::new(toml);
let envs: Environments<Environment, RuntimeEnv> = Environments::from_reader(&mut cursor)?;

// Test that all the environments are present
env::set_var("env", "prod");
let mut current = envs.current()?;
assert_eq!(current.name(), "Production");
assert_eq!(current.key(), &Some("abcd-123-efg-45".to_string()));

env::set_var("env", "stage");
current = envs.current()?;
assert_eq!(current.name(), "Stage");
assert_eq!(current.key(), &None);

env::set_var("env", "test");
current = envs.current()?;
assert_eq!(current.name(), "Test");
assert_eq!(current.key(), &None);

env::set_var("env", "dev");
current = envs.current()?;
assert_eq!(current.name(), "Development");
assert_eq!(current.key(), &None);

env::set_var("env", "local");
current = envs.current()?;
assert_eq!(current.name(), "Local");
assert_eq!(current.key(), &None);

Implementations

impl<S, T> Environments<S, T>where
    T: DeserializeOwned + Serialize,
    S: DeserializeOwned + Serialize + Ord + PartialOrd + TryFrom<String>,
    Error: From<<S as TryFrom<String>>::Error>,

pub fn from_path(path: &Path) -> Result<Self, Error>

Load the environments from a path.

pub fn from_reader<R>(reader: &mut R) -> Result<Self, Error>where
    R: Read,

Load the environments from a reader.

pub fn current(&self) -> Result<&T, Error>

Get the current environment

pub fn current_from(&self, var: &'static str) -> Result<&T, Error>

Get the current environment from the given variable

Trait Implementations

impl<S: Debug, T: Debug> Debug for Environments<S, T>where
    S: Ord,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, S, T> Deserialize<'de> for Environments<S, T>where
    S: Ord,
    S: Deserialize<'de>,
    T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S, T> Serialize for Environments<S, T>where
    S: Ord,
    S: Serialize,
    T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, S, T> TryFrom<&'a ArgMatches<'a>> for Environments<S, T>where
    T: DeserializeOwned + Serialize,
    S: DeserializeOwned + Serialize + Ord + PartialOrd + TryFrom<String>,
    Error: From<<S as TryFrom<String>>::Error>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(matches: &'a ArgMatches<'a>) -> Result<Self, Error>

Performs the conversion.