envigil 0.2.0

Keep vigil over your environment — load, parse, and validate env vars with zero dependencies.
Documentation
//! Minimal `.env` file parser.
//!
//! Supports:
//! - `KEY=VALUE` lines
//! - `#` comments and blank lines
//! - Single and double quotes around values
//! - `export KEY=VALUE` prefix
//!
//! Does **not** modify `std::env`. Values are stored in memory and
//! used as fallback when a variable is absent from the real
//! environment.

/// Parse the content of a `.env` file into key-value pairs.
///
/// # Examples
///
/// ```
/// use envigil::dotenv::parse;
///
/// let content = r#"
///     # Database
///     DATABASE_URL=postgres://localhost/db
///     PORT="8080"
///     export NAME='envigil'
///
///     EMPTY=
/// "#;
///
/// let entries = parse(content);
/// assert_eq!(entries.len(), 4);
/// assert_eq!(entries[0], ("DATABASE_URL".to_owned(), "postgres://localhost/db".to_owned()));
/// assert_eq!(entries[1], ("PORT".to_owned(), "8080".to_owned()));
/// assert_eq!(entries[2], ("NAME".to_owned(), "envigil".to_owned()));
/// assert_eq!(entries[3], ("EMPTY".to_owned(), String::new()));
/// ```
pub fn parse(content: &str) -> Vec<(String, String)> {
    let mut entries = Vec::new();

    for line in content.lines() {
        let line = line.trim();

        // Skip blanks and comments.
        if line.is_empty() || line.starts_with('#') {
            continue;
        }

        // Strip optional `export ` prefix.
        let line = line.strip_prefix("export ").unwrap_or(line).trim();

        // Split on first '='.
        let Some((key, value)) = line.split_once('=') else {
            continue;
        };

        let key = key.trim().to_owned();
        if key.is_empty() {
            continue;
        }

        let value = unquote(value.trim());
        entries.push((key, value));
    }

    entries
}

/// Strip surrounding single or double quotes.
fn unquote(raw: &str) -> String {
    if raw.len() >= 2 {
        let bytes = raw.as_bytes();
        let first = bytes[0];
        let last = bytes[bytes.len() - 1];

        if (first == b'"' && last == b'"') || (first == b'\'' && last == b'\'') {
            return raw[1..raw.len() - 1].to_owned();
        }
    }

    raw.to_owned()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn basic_key_value() {
        let entries = parse("FOO=bar");
        assert_eq!(entries, vec![("FOO".to_owned(), "bar".to_owned())]);
    }

    #[test]
    fn skips_comments_and_blanks() {
        let content = "# comment\n\n  \nKEY=val\n# another";
        let entries = parse(content);
        assert_eq!(entries.len(), 1);
        assert_eq!(entries[0].0, "KEY");
    }

    #[test]
    fn double_quotes_stripped() {
        let entries = parse(r#"KEY="hello world""#);
        assert_eq!(entries[0].1, "hello world");
    }

    #[test]
    fn single_quotes_stripped() {
        let entries = parse("KEY='hello world'");
        assert_eq!(entries[0].1, "hello world");
    }

    #[test]
    fn no_quotes_untouched() {
        let entries = parse("KEY=hello");
        assert_eq!(entries[0].1, "hello");
    }

    #[test]
    fn empty_value() {
        let entries = parse("KEY=");
        assert_eq!(entries[0].1, "");
    }

    #[test]
    fn export_prefix_stripped() {
        let entries = parse("export KEY=val");
        assert_eq!(entries[0].0, "KEY");
        assert_eq!(entries[0].1, "val");
    }

    #[test]
    fn value_with_equals() {
        let entries = parse("DSN=postgres://user:pass@host/db?opt=1");
        assert_eq!(entries[0].1, "postgres://user:pass@host/db?opt=1");
    }

    #[test]
    fn whitespace_trimmed() {
        let entries = parse("  KEY  =  val  ");
        assert_eq!(entries[0].0, "KEY");
        assert_eq!(entries[0].1, "val");
    }

    #[test]
    fn no_equals_skipped() {
        let entries = parse("INVALID LINE");
        assert!(entries.is_empty());
    }

    #[test]
    fn empty_key_skipped() {
        let entries = parse("=value");
        assert!(entries.is_empty());
    }

    #[test]
    fn multiple_entries() {
        let content = "A=1\nB=2\nC=3";
        let entries = parse(content);
        assert_eq!(entries.len(), 3);
    }

    #[test]
    fn quoted_empty() {
        let entries = parse(r#"KEY="""#);
        assert_eq!(entries[0].1, "");
    }

    #[test]
    fn mismatched_quotes_kept() {
        let entries = parse(r#"KEY="hello'"#);
        assert_eq!(entries[0].1, r#""hello'"#,);
    }
}