241 lines
6.3 KiB
Rust
241 lines
6.3 KiB
Rust
use crate::envstr::*;
|
|
use crate::error::*;
|
|
use crate::utils::*;
|
|
use std::env;
|
|
|
|
/// Same as get_env but returns Option enum instead Result
|
|
///
|
|
/// Example
|
|
/// -------
|
|
///
|
|
/// ```rust
|
|
/// # extern crate itconfig;
|
|
/// # use itconfig::maybe_get_env;
|
|
/// use std::env;
|
|
///
|
|
/// fn main () {
|
|
/// env::set_var("HOST", "https://example.com");
|
|
///
|
|
/// let host: Option<&'static str> = maybe_get_env("HOST");
|
|
/// let not_existence_host: Option<&'static str> = maybe_get_env("NOT_EXISTENCE_HOST");
|
|
///
|
|
/// assert_eq!(host, Some("https://example.com"));
|
|
/// assert_eq!(not_existence_host, None);
|
|
/// }
|
|
/// ```
|
|
///
|
|
pub fn maybe_get_env<T>(env_name: &str) -> Option<T>
|
|
where
|
|
T: FromEnvString,
|
|
{
|
|
get_env(env_name).ok()
|
|
}
|
|
|
|
/// This function is similar as `get_env`, but it unwraps result with panic on error.
|
|
///
|
|
/// Panics
|
|
/// ------
|
|
/// Application will panic if environment variable is missing or cannot parse variable to
|
|
/// expected type
|
|
///
|
|
pub fn get_env_or_panic<T>(env_name: &str) -> T
|
|
where
|
|
T: FromEnvString,
|
|
{
|
|
get_env(env_name).unwrap_or_else(make_panic)
|
|
}
|
|
|
|
/// Try to read environment variable and parse to expected type. You may to put to argument
|
|
/// any type with `FromEnvString` trait.
|
|
///
|
|
/// Example
|
|
/// -------
|
|
///
|
|
/// ```rust
|
|
/// # extern crate itconfig;
|
|
/// # use itconfig::get_env;
|
|
/// use std::env;
|
|
///
|
|
/// fn main () {
|
|
/// env::set_var("DEBUG", "true");
|
|
///
|
|
/// let result: bool = get_env("DEBUG").unwrap();
|
|
///
|
|
/// assert_eq!(result, true);
|
|
/// }
|
|
/// ```
|
|
///
|
|
pub fn get_env<T>(env_name: &str) -> Result<T, EnvError>
|
|
where
|
|
T: FromEnvString,
|
|
{
|
|
get_env_or(env_name, |_| {
|
|
Err(EnvError::MissingVariable(env_name.to_string()))
|
|
})
|
|
}
|
|
|
|
/// This function is similar as `get_env_or_panic`, but you can pass default value for
|
|
/// environment variable with `ToEnvString` trait.
|
|
///
|
|
/// Panics
|
|
/// ------
|
|
/// Application will panic if cannot parse variable to expected type
|
|
///
|
|
/// Example
|
|
/// -------
|
|
///
|
|
/// ```rust
|
|
/// # extern crate itconfig;
|
|
/// # use itconfig::get_env_or_default;
|
|
/// use std::env;
|
|
///
|
|
/// fn main () {
|
|
/// let result: bool = get_env_or_default("TESTING", "true");
|
|
/// assert_eq!(result, true);
|
|
/// }
|
|
/// ```
|
|
///
|
|
pub fn get_env_or_default<T, D>(env_name: &str, default: D) -> T
|
|
where
|
|
T: FromEnvString,
|
|
D: ToEnvString,
|
|
{
|
|
get_env_or(env_name, |_| Ok(default.to_env_string())).unwrap_or_else(make_panic)
|
|
}
|
|
|
|
/// This function is similar as `get_env_or_default`, but the default value will be set to environment
|
|
/// variable, if env variable is missed.
|
|
///
|
|
/// Panics
|
|
/// ------
|
|
/// Application will panic if cannot parse variable to expected type
|
|
///
|
|
/// Example
|
|
/// -------
|
|
///
|
|
/// ```rust
|
|
/// # extern crate itconfig;
|
|
/// # use itconfig::get_env_or_set_default;
|
|
/// use std::env;
|
|
///
|
|
/// fn main () {
|
|
/// let result: bool = get_env_or_set_default("TESTING", "true");
|
|
/// assert_eq!(result, true);
|
|
///
|
|
/// let var = env::var("TESTING").unwrap();
|
|
/// assert_eq!(var, "true");
|
|
/// }
|
|
/// ```
|
|
///
|
|
pub fn get_env_or_set_default<T, D>(env_name: &str, default: D) -> T
|
|
where
|
|
T: FromEnvString,
|
|
D: ToEnvString,
|
|
{
|
|
get_env_or(env_name, |_| {
|
|
let val = default.to_env_string();
|
|
env::set_var(env_name, val.as_str());
|
|
Ok(val)
|
|
})
|
|
.unwrap_or_else(make_panic)
|
|
}
|
|
|
|
/// This function returns env variable as `EnvString` structure. You can pass callback for custom
|
|
/// default expression. Callback should return `EnvString` value or `EnvError`
|
|
pub fn get_env_or<T, F>(env_name: &str, cb: F) -> Result<T, EnvError>
|
|
where
|
|
T: FromEnvString,
|
|
F: FnOnce(env::VarError) -> Result<EnvString, EnvError>,
|
|
{
|
|
env::var(env_name)
|
|
.map(|s| s.to_env_string())
|
|
.or_else(cb)
|
|
.and_then(|env_str| parse_env_variable(env_name, env_str))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
#[should_panic(expected = "Environment variable \"TEST_CASE_1\" is missing")]
|
|
fn get_missing_env() {
|
|
get_env_or_panic::<String>("TEST_CASE_1");
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic(expected = "Failed to parse environment variable \"TEST_CASE_2\"")]
|
|
fn get_env_with_invalid_value() {
|
|
let env_name = "TEST_CASE_2";
|
|
env::set_var(&env_name, "30r");
|
|
get_env_or_panic::<u32>(env_name);
|
|
}
|
|
|
|
#[test]
|
|
fn get_result_of_missing_env() {
|
|
let env_name = String::from("TEST_CASE_3");
|
|
let env_val = get_env::<String>(&env_name);
|
|
assert_eq!(env_val, Err(EnvError::MissingVariable(env_name)))
|
|
}
|
|
|
|
#[test]
|
|
fn get_result_of_env_with_invalid_value() {
|
|
let env_name = String::from("TEST_CASE_4");
|
|
env::set_var(&env_name, "30r");
|
|
let env_val = get_env::<u32>(&env_name);
|
|
assert_eq!(env_val, Err(EnvError::FailedToParse(env_name)))
|
|
}
|
|
|
|
#[test]
|
|
fn get_result_of_env_successfully() {
|
|
env::set_var("TEST_CASE_5", "30");
|
|
let env_var = get_env("TEST_CASE_5");
|
|
assert_eq!(env_var, Ok(30));
|
|
}
|
|
|
|
#[test]
|
|
fn get_missing_env_with_default_value() {
|
|
let flag: bool = get_env_or_default("TEST_CASE_6", "true");
|
|
assert!(flag);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic(expected = "Failed to parse environment variable \"TEST_CASE_7\"")]
|
|
fn get_invalid_env_with_default_value() {
|
|
env::set_var("TEST_CASE_7", "30r");
|
|
get_env_or_default::<u32, _>("TEST_CASE_7", 30);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic(expected = "Failed to parse environment variable \"TEST_CASE_8\"")]
|
|
fn get_env_with_invalid_default_value() {
|
|
get_env_or_default::<u32, _>("TEST_CASE_8", "30r");
|
|
}
|
|
|
|
#[test]
|
|
fn get_env_with_default_successfully() {
|
|
env::set_var("TEST_CASE_9", "10");
|
|
let env_val: u32 = get_env_or_default("TEST_CASE_9", 30);
|
|
assert_eq!(env_val, 10)
|
|
}
|
|
|
|
#[test]
|
|
fn get_missing_env_with_set_default_value() {
|
|
let flag: bool = get_env_or_set_default("TEST_CASE_10", "true");
|
|
assert!(flag);
|
|
|
|
let env_var = env::var("TEST_CASE_10");
|
|
assert_eq!(env_var, Ok(String::from("true")))
|
|
}
|
|
|
|
#[test]
|
|
fn get_optional_env() {
|
|
env::set_var("TEST_CASE_11", "something");
|
|
let something: Option<&'static str> = maybe_get_env("TEST_CASE_11");
|
|
assert_eq!(something, Some("something"));
|
|
|
|
let nothing: Option<&'static str> = maybe_get_env("TEST_CASE_11_NONE");
|
|
assert_eq!(nothing, None);
|
|
}
|
|
}
|