Add support for environment substitution within config files

Cargo.toml

@@ -131,6 +131,7 @@ convert-case = ["convert_case"]
 preserve_order = ["indexmap", "toml?/preserve_order", "serde_json?/preserve_order", "ron?/indexmap"]
 async = ["async-trait"]
 toml = ["dep:toml"]
+substitute_env = []
 
 [dependencies]
 serde_core = "1.0.228"

src/file/format/corn.rs

@@ -1,6 +1,7 @@
 use crate::value::{Value, ValueKind};
 use crate::{format, Map};
 use std::error::Error;
+use crate::nested_env_vars::ExpandEnvVars;
 
 pub(crate) fn parse(
     uri: Option<&String>,
@@ -12,7 +13,7 @@ pub(crate) fn parse(
 
 fn from_corn_value(uri: Option<&String>, value: &corn::Value<'_>) -> Value {
     match value {
-        corn::Value::String(value) => Value::new(uri, ValueKind::String(value.to_string())),
+        corn::Value::String(value) => Value::new(uri, ValueKind::String(value.expand_env_vars())),
         corn::Value::Integer(value) => Value::new(uri, ValueKind::I64(*value)),
         corn::Value::Float(value) => Value::new(uri, ValueKind::Float(*value)),
         corn::Value::Boolean(value) => Value::new(uri, ValueKind::Boolean(*value)),

src/file/format/ini.rs

@@ -3,6 +3,7 @@ use std::error::Error;
 use ini::Ini;
 
 use crate::map::Map;
+use crate::nested_env_vars::ExpandEnvVars;
 use crate::value::{Value, ValueKind};
 
 pub(crate) fn parse(
@@ -18,7 +19,7 @@ pub(crate) fn parse(
                 for (k, v) in prop.iter() {
                     sec_map.insert(
                         k.to_owned(),
-                        Value::new(uri, ValueKind::String(v.to_owned())),
+                        Value::new(uri, ValueKind::String(v.expand_env_vars())),
                     );
                 }
                 map.insert(sec.to_owned(), Value::new(uri, ValueKind::Table(sec_map)));
@@ -27,7 +28,7 @@ pub(crate) fn parse(
                 for (k, v) in prop.iter() {
                     map.insert(
                         k.to_owned(),
-                        Value::new(uri, ValueKind::String(v.to_owned())),
+                        Value::new(uri, ValueKind::String(v.expand_env_vars())),
                     );
                 }
             }

src/file/format/json.rs

@@ -2,6 +2,7 @@ use std::error::Error;
 
 use crate::format;
 use crate::map::Map;
+use crate::nested_env_vars::ExpandEnvVars;
 use crate::value::{Value, ValueKind};
 
 pub(crate) fn parse(
@@ -15,7 +16,7 @@ pub(crate) fn parse(
 
 fn from_json_value(uri: Option<&String>, value: &serde_json::Value) -> Value {
     match *value {
-        serde_json::Value::String(ref value) => Value::new(uri, ValueKind::String(value.clone())),
+        serde_json::Value::String(ref value) => Value::new(uri, ValueKind::String(value.expand_env_vars())),
 
         serde_json::Value::Number(ref value) => {
             if let Some(value) = value.as_i64() {

src/file/format/json5.rs

@@ -2,6 +2,7 @@ use std::error::Error;
 
 use crate::format;
 use crate::map::Map;
+use crate::nested_env_vars::ExpandEnvVars;
 use crate::value::{Value, ValueKind};
 
 #[derive(Debug)]
@@ -43,7 +44,7 @@ pub(crate) fn parse(
 fn from_json5_value(uri: Option<&String>, value: Val) -> Value {
     let vk = match value {
         Val::Null => ValueKind::Nil,
-        Val::String(v) => ValueKind::String(v),
+        Val::String(v) => ValueKind::String(v.expand_env_vars()),
         Val::Integer(v) => ValueKind::I64(v),
         Val::Float(v) => ValueKind::Float(v),
         Val::Boolean(v) => ValueKind::Boolean(v),

src/file/format/ron.rs

@@ -2,6 +2,7 @@ use std::error::Error;
 
 use crate::format;
 use crate::map::Map;
+use crate::nested_env_vars::ExpandEnvVars;
 use crate::value::{Value, ValueKind};
 
 pub(crate) fn parse(
@@ -33,7 +34,7 @@ fn from_ron_value(
 
         ron::Value::Char(value) => ValueKind::String(value.to_string()),
 
-        ron::Value::String(value) => ValueKind::String(value),
+        ron::Value::String(value) => ValueKind::String(value.expand_env_vars()),
 
         ron::Value::Seq(values) => {
             let array = values

src/file/format/toml.rs

@@ -1,6 +1,7 @@
 use std::error::Error;
 
 use crate::map::Map;
+use crate::nested_env_vars::ExpandEnvVars;
 use crate::value::Value;
 
 pub(crate) fn parse(
@@ -24,7 +25,7 @@ fn from_toml_table(uri: Option<&String>, table: toml::Table) -> Map<String, Valu
 
 fn from_toml_value(uri: Option<&String>, value: toml::Value) -> Value {
     match value {
-        toml::Value::String(value) => Value::new(uri, value),
+        toml::Value::String(value) => Value::new(uri, value.expand_env_vars()),
         toml::Value::Float(value) => Value::new(uri, value),
         toml::Value::Integer(value) => Value::new(uri, value),
         toml::Value::Boolean(value) => Value::new(uri, value),

src/file/format/yaml.rs

@@ -6,6 +6,7 @@ use yaml_rust2 as yaml;
 
 use crate::format;
 use crate::map::Map;
+use crate::nested_env_vars::ExpandEnvVars;
 use crate::value::{Value, ValueKind};
 
 pub(crate) fn parse(
@@ -31,7 +32,7 @@ fn from_yaml_value(
     value: &yaml::Yaml,
 ) -> Result<Value, Box<dyn Error + Send + Sync>> {
     match *value {
-        yaml::Yaml::String(ref value) => Ok(Value::new(uri, ValueKind::String(value.clone()))),
+        yaml::Yaml::String(ref value) => Ok(Value::new(uri, ValueKind::String(value.expand_env_vars()))),
         yaml::Yaml::Real(ref value) => {
             // TODO: Figure out in what cases this can panic?
             value

src/lib.rs

@@ -43,6 +43,8 @@ mod ser;
 mod source;
 mod value;
 
+mod nested_env_vars;
+
 // Re-export
 #[cfg(feature = "convert-case")]
 pub use convert_case::Case;

src/nested_env_vars.rs

@@ -0,0 +1,246 @@
+
+pub(crate) trait ExpandEnvVars {
+    fn expand_env_vars(&self) -> String;
+}
+
+#[cfg(not(feature = "substitute_env"))]
+impl ExpandEnvVars for str {
+    fn expand_env_vars(&self) -> String {
+        self.to_string()
+    }
+}
+
+#[cfg(feature = "substitute_env")]
+impl ExpandEnvVars for str {
+    fn expand_env_vars(&self) -> String {
+        let mut result = String::with_capacity(self.len());
+        let mut chars = self.chars().peekable();
+
+        while let Some(ch) = chars.next() {
+            if ch == '$' && chars.peek() == Some(&'{') {
+                chars.next(); // consume '{'
+
+                // Find the closing '}'
+                let mut var_expr = String::new();
+                let mut found_closing = false;
+
+                while let Some(ch) = chars.next() {
+                    if ch == '}' {
+                        found_closing = true;
+                        break;
+                    }
+                    var_expr.push(ch);
+                }
+
+                if found_closing {
+                    // Check for default value syntax: VAR:-default
+                    if let Some(colon_pos) = var_expr.find(":-") {
+                        let var_name = &var_expr[..colon_pos];
+                        let default_value = &var_expr[colon_pos + 2..];
+
+                        match std::env::var(var_name) {
+                            Ok(value) if !value.is_empty() => result.push_str(&value),
+                            _ => result.push_str(default_value),
+                        }
+                    } else {
+                        // Simple variable reference: VAR
+                        match std::env::var(&var_expr) {
+                            Ok(value) => result.push_str(&value),
+                            Err(_) => {
+                                // Variable not found, leave the original syntax
+                                result.push_str("${");
+                                result.push_str(&var_expr);
+                                result.push('}');
+                            }
+                        }
+                    }
+                } else {
+                    // No closing '}' found, treat as literal text
+                    result.push('$');
+                    result.push('{');
+                    result.push_str(&var_expr);
+                }
+            } else {
+                result.push(ch);
+            }
+        }
+
+        result
+    }
+}
+
+#[cfg(all(test, feature = "substitute_env"))]
+mod tests {
+    use super::*;
+    use temp_env;
+
+    #[test]
+    fn test_no_env_vars() {
+        let input = "hello world";
+        assert_eq!(input.expand_env_vars(), "hello world");
+    }
+
+    #[test]
+    fn test_simple_env_var_exists() {
+        temp_env::with_vars([("TEST_VAR", Some("test_value"))], || {
+            let input = "prefix ${TEST_VAR} suffix";
+            assert_eq!(input.expand_env_vars(), "prefix test_value suffix");
+        });
+    }
+
+    #[test]
+    fn test_simple_env_var_not_exists() {
+        temp_env::with_vars([("NONEXISTENT_VAR", None::<&str>)], || {
+            let input = "prefix ${NONEXISTENT_VAR} suffix";
+            assert_eq!(input.expand_env_vars(), "prefix ${NONEXISTENT_VAR} suffix");
+        });
+    }
+
+    #[test]
+    fn test_nonexistent_with_default() {
+        temp_env::with_vars([("NONEXISTENT_VAR", None::<&str>)], || {
+            let input = "prefix ${NONEXISTENT_VAR:-43.7224985} suffix";
+            assert_eq!(input.expand_env_vars(), "prefix 43.7224985 suffix");
+        });
+    }
+
+    #[test]
+    fn test_env_var_with_default_var_exists() {
+        temp_env::with_vars([("TEST_VAR", Some("actual_value"))], || {
+            let input = "prefix ${TEST_VAR:-default_value} suffix";
+            assert_eq!(input.expand_env_vars(), "prefix actual_value suffix");
+        });
+    }
+
+    #[test]
+    fn test_env_var_with_default_var_not_exists() {
+        temp_env::with_vars([("NONEXISTENT_VAR", None::<&str>)], || {
+            let input = "prefix ${NONEXISTENT_VAR:-default_value} suffix";
+            assert_eq!(input.expand_env_vars(), "prefix default_value suffix");
+        });
+    }
+
+    #[test]
+    fn test_env_var_with_default_var_empty() {
+        temp_env::with_vars([("EMPTY_VAR", Some(""))], || {
+            let input = "prefix ${EMPTY_VAR:-default_value} suffix";
+            assert_eq!(input.expand_env_vars(), "prefix default_value suffix");
+        });
+    }
+
+    #[test]
+    fn test_multiple_env_vars() {
+        temp_env::with_vars([("VAR1", Some("value1")), ("VAR2", Some("value2"))], || {
+            let input = "${VAR1} and ${VAR2}";
+            assert_eq!(input.expand_env_vars(), "value1 and value2");
+        });
+    }
+
+    #[test]
+    fn test_multiple_env_vars_mixed_existence() {
+        temp_env::with_vars(
+            [("EXISTS", Some("found")), ("MISSING", None::<&str>)],
+            || {
+                let input = "${EXISTS} and ${MISSING}";
+                assert_eq!(input.expand_env_vars(), "found and ${MISSING}");
+            },
+        );
+    }
+
+    #[test]
+    fn test_multiple_env_vars_with_defaults() {
+        temp_env::with_vars([("VAR1", Some("actual1")), ("VAR2", None::<&str>)], || {
+            let input = "${VAR1:-default1} and ${VAR2:-default2}";
+            assert_eq!(input.expand_env_vars(), "actual1 and default2");
+        });
+    }
+
+    // ... existing code ...
+
+    #[test]
+    fn test_variable_name_with_underscores() {
+        temp_env::with_vars([("TEST_VAR_123", Some("underscore_value"))], || {
+            let input = "${TEST_VAR_123}";
+            assert_eq!(input.expand_env_vars(), "underscore_value");
+        });
+    }
+
+    #[test]
+    fn test_consecutive_variables() {
+        temp_env::with_vars([("A", Some("a")), ("B", Some("b"))], || {
+            let input = "${A}${B}";
+            assert_eq!(input.expand_env_vars(), "ab");
+        });
+    }
+
+    #[test]
+    fn test_variable_at_start_and_end() {
+        temp_env::with_vars([("START", Some("beginning")), ("END", Some("end"))], || {
+            let input = "${START} middle ${END}";
+            assert_eq!(input.expand_env_vars(), "beginning middle end");
+        });
+    }
+
+    #[test]
+    fn test_only_variable() {
+        temp_env::with_vars([("ONLY_VAR", Some("only"))], || {
+            let input = "${ONLY_VAR}";
+            assert_eq!(input.expand_env_vars(), "only");
+        });
+    }
+
+    #[test]
+    fn test_complex_scenario() {
+        temp_env::with_vars(
+            [
+                ("HOME", Some("/home/user")),
+                ("USER", Some("testuser")),
+                ("EDITOR", None::<&str>),
+            ],
+            || {
+                let input =
+                    "User: ${USER}, Home: ${HOME}, Editor: ${EDITOR:-vim}, Config: ${HOME}/.config";
+                assert_eq!(
+                    input.expand_env_vars(),
+                    "User: testuser, Home: /home/user, Editor: vim, Config: /home/user/.config"
+                );
+            },
+        );
+    }
+
+    // ... existing code ...
+
+    #[test]
+    fn test_colon_without_dash() {
+        temp_env::with_vars([("TEST_VAR", Some("value"))], || {
+            // This should not be treated as default syntax since it's missing the dash
+            let input = "${TEST_VAR:not_default}";
+            assert_eq!(input.expand_env_vars(), "${TEST_VAR:not_default}");
+        });
+    }
+
+    #[test]
+    fn test_multiple_colon_dash_in_default() {
+        temp_env::with_vars([("MISSING", None::<&str>)], || {
+            // Only the first :- should be treated as default syntax
+            let input = "${MISSING:-default:-with:-colons}";
+            assert_eq!(input.expand_env_vars(), "default:-with:-colons");
+        });
+    }
+
+    #[test]
+    fn test_env_var_with_numeric_value() {
+        temp_env::with_vars([("PORT", Some("8080"))], || {
+            let input = "Server running on port ${PORT}";
+            assert_eq!(input.expand_env_vars(), "Server running on port 8080");
+        });
+    }
+
+    #[test]
+    fn test_boolean_like_env_var() {
+        temp_env::with_vars([("DEBUG", Some("true"))], || {
+            let input = "Debug mode: ${DEBUG:-false}";
+            assert_eq!(input.expand_env_vars(), "Debug mode: true");
+        });
+    }
+}