Struct 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>,

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

Load the environments from a path.

Errors

pub fn from_reader<R>(reader: &mut R) -> Result<Self>

where R: Read,

Load the environments from a reader.

Errors

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

Get the current environment

Errors

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

Get the current environment from the given variable

Errors

Trait Implementations

impl<S, T: Clone> Clone for Environments<S, T>

where S: Ord + Clone,

fn clone(&self) -> Environments<S, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

where S: Ord + Debug,

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 + 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 + 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>,

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.