envmnt

Environment variables utility functions.

Overview

This library has many helper functions to access/modify/check environment variables.

Usage

Simply include the library and invoke the various utility functions.

Get/Set/Remove environment variables

```rust use envmnt::{ExpandOptions, ExpansionType};

fn main() { if !envmnt::exists("MYENVVAR") { envmnt::set("MYENVVAR", "SOME VALUE"); }

let mut value = envmnt::get_or("MY_ENV_VAR", "DEFAULT_VALUE");
println!("Env Value: {}", &value);

value = envmnt::get_or_panic("MY_ENV_VAR");
println!("Env Value: {}", &value);

let pre_value = envmnt::get_set("MY_ENV_VAR", "SOME NEW VALUE");

let value = envmnt::get_or("MY_ENV_VAR", "DEFAULT_VALUE");
println!("New Env Value: {}", &value);
println!("Previous Env Value: {:?}", &pre_value);

let var_was_set = envmnt::set_optional("MY_ENV_VAR", &Some("OPTIONAL VALUE"));
println!("Env Was Modified: {}", var_was_set);

let all_vars = envmnt::vars(); // returned as Vec<(String, String)>

for (key, value) in all_vars {
    println!("{}: {}", key, value);
}

envmnt::set("MY_ENV_VAR2", "SOME VALUE2");

let value = envmnt::get_any(&vec!["MY_ENV_VAR1", "MY_ENV_VAR2"], "default");
println!("MY_ENV_VAR1 exists: {}", envmnt::exists("MY_ENV_VAR1"));
println!("MY_ENV_VAR2 exists: {}", envmnt::exists("MY_ENV_VAR2"));
println!("Found value: {}", value);

let mut options = ExpandOptions::new();
options.expansion_type = Some(ExpansionType::Unix);
let mut value = envmnt::expand("Env: MY_ENV value is: ${MY_ENV}", Some(options));
println!("Expanded: {}", &value);
options.expansion_type = Some(ExpansionType::UnixBracketsWithDefaults);
value = envmnt::expand(
    "Env: MY_ENV_NOT_FOUND value is: ${MY_ENV_NOT_FOUND:default value}",
    Some(options),
);
println!("Expanded: {}", &value);

} ```

Get/Set boolean environment variables and other comparisons

```rust fn main() { envmnt::setbool("FLAGVAR", true); let mut flagvalue = envmnt::isor("FLAGVAR", false); println!("Bool Flag: {}", &flagvalue);

flag_value = envmnt::is("FLAG_VAR");
assert!(flag_value);

envmnt::set_bool("FLAG_VAR", true);
assert!(envmnt::is_equal("FLAG_VAR", "true"));

envmnt::set("MY_ENV_VAR", "SOME VALUE");
let same = envmnt::is_equal("MY_ENV_VAR", "SOME VALUE");
println!("Value Is Same: {}", &same);
let mut contains = envmnt::contains("MY_ENV_VAR", "_ENV_");
println!("Value Contained: {}", &contains);
contains = envmnt::contains_ignore_case("MY_ENV_VAR", "_env_");
println!("Value Contained (case insensitive): {}", &contains);

} ```

Get/Set numeric environment variables

```rust fn main() { // all numeric data types: u8/i8/u16/i16/u32/i32/u64/i64/u128/i128/f32/f64/isize/usize // are supported by specific set/get functions. // getparse can support parsing various data types beyond the simple numeric getters. envmnt::setu8("U8TESTENV", 50); let mut valueu8 = envmnt::getu8("U8TESTENV", 5); asserteq!(valueu8, 50); valueu8 = envmnt::getparseor("U8TESTENV", 5).unwrap(); asserteq!(value_u8, 50);

envmnt::set_isize("ISIZE_TEST_ENV", -50);
let mut value_isize = envmnt::get_isize("ISIZE_TEST_ENV", 5);
assert_eq!(value_isize, -50);
value_isize = envmnt::get_parse("ISIZE_TEST_ENV").unwrap();
assert_eq!(value_isize, -50);

// increment/decrement values
value_isize = envmnt::increment("U8_TEST_ENV");
assert_eq!(value_isize, 51);
value_u8 = envmnt::get_u8("U8_TEST_ENV", 5);
assert_eq!(value_u8, 51);
value_isize = envmnt::decrement("U8_TEST_ENV");
assert_eq!(value_isize, 50);
value_u8 = envmnt::get_u8("U8_TEST_ENV", 5);
assert_eq!(value_u8, 50);

} ```

Get/Set list environment variables

```rust fn main() { envmnt::setlist( "LISTTESTENV", &vec!["1".tostring(), "2".tostring(), "3".tostring()], );

let mut values = envmnt::get_list("LIST_TEST_ENV").unwrap();
println!("List Values: {:?}", values);

let mut same = envmnt::is_equal("LIST_TEST_ENV", "1;2;3");
println!("Same: {}", same);

let mut options = envmnt::ListOptions::new();
options.separator = Some(",".to_string());
envmnt::set_list_with_options(
    "LIST_TEST_ENV",
    &vec!["1".to_string(), "2".to_string(), "3".to_string()],
    &options,
);

values = envmnt::get_list_with_options("LIST_TEST_ENV", &options).unwrap();
println!("List Values: {:?}", values);

same = envmnt::is_equal("LIST_TEST_ENV", "1,2,3");
println!("Same: {}", same);

} ```

Bulk Operations

```rust use indexmap::IndexMap;

fn main() { let mut env: IndexMap = IndexMap::new(); env.insert("ENVVAR1".tostring(), "MY VALUE".tostring()); env.insert("ENVVAR2".tostring(), "MY VALUE2".tostring());

envmnt::set_all(&env);

let value = envmnt::get_or_panic("ENV_VAR1");
println!("Value Is: {}", &value);

let mut found = envmnt::is_any_exists(&vec!["ENV_VAR1", "ENV_VAR2"]);

println!("Any Found: {}", &found);

found = envmnt::is_all_exists(&vec!["ENV_VAR1", "ENV_VAR2"]);

println!("All Found: {}", &found);

envmnt::remove_all(&vec!["ENV_VAR1", "ENV_VAR2"]);

found = envmnt::is_any_exists(&vec!["ENV_VAR1", "ENV_VAR2"]);

println!("Any Found: {}", &found);

env = IndexMap::new();
env.insert("ENV_VAR1".to_string(), "MY VALUE".to_string());
env.insert("ENV_VAR2".to_string(), "MY VALUE2".to_string());

let eval_env = |value: String| {
    let mut buffer = String::from("VALUE-");
    buffer.push_str(&value);
    buffer
};

envmnt::evaluate_and_set_all(&env, eval_env);

let value = envmnt::get_or_panic("ENV_VAR1");
println!("Value Is: {}", &value);

} ```

File Operations

```rust fn main() { let mut output = envmnt::loadfile("./src/test/var.env"); assert!(output.isok());

let eval_env = |value: String| {
    let mut buffer = String::from("PREFIX-");
    buffer.push_str(&value);
    buffer
};

output = envmnt::evaluate_and_load_file("./src/test/var.env", eval_env);
assert!(output.is_ok());

} ```

Installation

In order to use this library, just add it as a dependency:

ini [dependencies] envmnt = "^0.9.1"

API Documentation

See full docs at: API Docs

Contributing

See contributing guide

Release History

See Changelog

License

Developed by Sagie Gur-Ari and licensed under the Apache 2 open source license.