dotenvs 0.2.2

A correct dotenv library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::parse::*;
use std::collections::HashMap;

/// Parsed dotenv content
pub struct Dotenv {
    buf: String,
}

fn normalize_input(buf: String) -> String {
    // Strip UTF-8 BOM (\u{FEFF}) if present — the parser does not expect it
    let buf = if let Some(stripped) = buf.strip_prefix('\u{FEFF}') {
        stripped.to_string()
    } else {
        buf
    };

    // Normalise line endings per spec: \r\n → \n, then standalone \r → \n
    buf.replace("\r\n", "\n").replace('\r', "\n")
}

impl Dotenv {
    pub(crate) fn new(buf: String) -> Self {
        Self {
            buf: normalize_input(buf),
        }
    }

    /// Return an iterator over the dotenv entries.
    pub fn iter(&self) -> Iter<'_> {
        Iter::new(&self.buf)
    }

    /// Load the dotenv into the current process's environment variables.
    ///
    /// Existing variables are **not** overwritten.
    pub fn load(self) {
        self.set_vars(false)
    }

    /// Load the dotenv into the current process's environment variables,
    /// **overwriting** any existing values.
    pub fn load_override(self) {
        self.set_vars(true)
    }

    fn set_vars(self, override_env: bool) {
        for (key, value) in self.iter() {
            if override_env || std::env::var(key).is_err() {
                std::env::set_var(key, value);
            }
        }
    }
}

/// An iterator over the entries in a dotenv file.
///
/// Yields `(&str, String)` pairs. Variable substitutions are resolved
/// lazily against both the process environment and previously-yielded
/// entries within the same file.
pub struct Iter<'a> {
    resolved: HashMap<&'a str, String>,
    input: &'a str,
}

impl<'a> Iter<'a> {
    pub(crate) fn new(input: &'a str) -> Self {
        Self {
            resolved: HashMap::new(),
            input,
        }
    }

    /// Resolve a variable name to a non-empty value.
    ///
    /// Checks the process environment first, then previously-resolved
    /// entries from this file.
    fn resolve_var(&self, name: &'a str) -> Option<String> {
        std::env::var(name)
            .ok()
            .or_else(|| self.resolved.get(name).cloned())
            .filter(|it| !it.is_empty())
    }

    fn resolve(&self, value: Value<'a>) -> String {
        match value {
            Value::Lit(text) => text.to_string(),
            Value::Sub(name, fallback) => self
                .resolve_var(name)
                .or_else(|| fallback.map(|it| self.resolve(*it)))
                .unwrap_or_default(),
            Value::List(list) => list.into_iter().map(|it| self.resolve(it)).collect(),
        }
    }
}

impl<'a> Iterator for Iter<'a> {
    type Item = (&'a str, String);

    fn next(&mut self) -> Option<Self::Item> {
        while !self.input.is_empty() {
            match parse(&mut self.input) {
                Ok(Some((key, value))) => {
                    let resolved = self.resolve(value);
                    self.resolved.insert(key, resolved.clone());
                    return Some((key, resolved));
                }
                Ok(None) => {
                    // comment or blank line, continue
                }
                Err(_) => {
                    // parse error
                    break;
                }
            }
        }

        None
    }
}