use anyhow::{Context, Result};
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct DotenvEntry {
pub(crate) key: String,
pub(crate) value: String,
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub(crate) struct ParsedDotenv {
pub(crate) entries: Vec<DotenvEntry>,
pub(crate) warnings: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct DotenvLoad {
pub(crate) path: PathBuf,
pub(crate) applied: usize,
pub(crate) kept_from_environment: usize,
pub(crate) warnings: Vec<String>,
}
fn is_valid_key(key: &str) -> bool {
let mut chars = key.chars();
match chars.next() {
Some(first) if first.is_ascii_alphabetic() || first == '_' => {}
_ => return false,
}
chars.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '.')
}
fn is_trailing_comment_or_blank(rest: &str) -> bool {
let rest = rest.trim_start();
rest.is_empty() || rest.starts_with('#')
}
fn parse_value(raw: &str) -> std::result::Result<String, &'static str> {
let raw = raw.trim_start();
if let Some(body) = raw.strip_prefix('"') {
let mut value = String::new();
let mut chars = body.char_indices();
while let Some((index, c)) = chars.next() {
match c {
'"' => {
return if is_trailing_comment_or_blank(&body[index + 1..]) {
Ok(value)
} else {
Err("unexpected text after the closing double quote")
};
}
'\\' => match chars.next() {
Some((_, 'n')) => value.push('\n'),
Some((_, 't')) => value.push('\t'),
Some((_, 'r')) => value.push('\r'),
Some((_, '"')) => value.push('"'),
Some((_, '\\')) => value.push('\\'),
Some((_, other)) => {
value.push('\\');
value.push(other);
}
None => return Err("unterminated double-quoted value"),
},
other => value.push(other),
}
}
return Err("unterminated double-quoted value");
}
if let Some(body) = raw.strip_prefix('\'') {
return match body.find('\'') {
Some(end) if is_trailing_comment_or_blank(&body[end + 1..]) => {
Ok(body[..end].to_string())
}
Some(_) => Err("unexpected text after the closing single quote"),
None => Err("unterminated single-quoted value"),
};
}
let mut end = raw.len();
let bytes = raw.as_bytes();
for (index, byte) in bytes.iter().enumerate() {
if *byte == b'#' && (index == 0 || bytes[index - 1].is_ascii_whitespace()) {
end = index;
break;
}
}
Ok(raw[..end].trim_end().to_string())
}
pub(crate) fn parse_dotenv(content: &str) -> ParsedDotenv {
let mut parsed = ParsedDotenv::default();
let content = content.strip_prefix('\u{feff}').unwrap_or(content);
for (index, line) in content.lines().enumerate() {
let line_no = index + 1;
let trimmed = line.trim();
if trimmed.is_empty() || trimmed.starts_with('#') {
continue;
}
let assignment = trimmed
.strip_prefix("export")
.filter(|rest| rest.starts_with(char::is_whitespace))
.map(str::trim_start)
.unwrap_or(trimmed);
let Some((key, raw_value)) = assignment.split_once('=') else {
parsed
.warnings
.push(format!("line {line_no}: expected KEY=VALUE, skipped"));
continue;
};
let key = key.trim();
if !is_valid_key(key) {
parsed.warnings.push(format!(
"line {line_no}: `{key}` is not a valid variable name, skipped"
));
continue;
}
match parse_value(raw_value) {
Ok(value) => {
parsed.entries.retain(|entry| entry.key != key);
parsed.entries.push(DotenvEntry {
key: key.to_string(),
value,
});
}
Err(reason) => parsed
.warnings
.push(format!("line {line_no}: {reason} for `{key}`, skipped")),
}
}
parsed
}
pub(crate) fn entries_to_apply(
entries: &[DotenvEntry],
is_set: impl Fn(&str) -> bool,
) -> (Vec<&DotenvEntry>, usize) {
let mut apply = Vec::new();
let mut kept = 0usize;
for entry in entries {
if is_set(&entry.key) {
kept += 1;
} else {
apply.push(entry);
}
}
(apply, kept)
}
pub(crate) fn load_dotenv_file(path: &Path) -> Result<Option<DotenvLoad>> {
if !path.is_file() {
return Ok(None);
}
let content = std::fs::read_to_string(path)
.with_context(|| format!("Failed to read {}", path.display()))?;
let parsed = parse_dotenv(&content);
let (apply, kept) = entries_to_apply(&parsed.entries, |key| std::env::var_os(key).is_some());
for entry in &apply {
std::env::set_var(&entry.key, &entry.value);
}
Ok(Some(DotenvLoad {
path: path.to_path_buf(),
applied: apply.len(),
kept_from_environment: kept,
warnings: parsed.warnings,
}))
}
pub(crate) fn load_project_dotenv() {
let path = Path::new(".env");
match load_dotenv_file(path) {
Ok(Some(load)) => {
for warning in &load.warnings {
eprintln!("warning: {}: {warning}", load.path.display());
}
let kept = if load.kept_from_environment > 0 {
format!(
"; {} already set in the environment and left unchanged",
load.kept_from_environment
)
} else {
String::new()
};
eprintln!(
"Loaded {} variable(s) from {}{kept}",
load.applied,
load.path.display()
);
}
Ok(None) => {}
Err(err) => eprintln!("warning: {err:#}; checking the process environment only"),
}
}
#[cfg(test)]
mod tests {
use super::{entries_to_apply, load_dotenv_file, parse_dotenv, DotenvEntry};
fn pairs(content: &str) -> Vec<(String, String)> {
parse_dotenv(content)
.entries
.into_iter()
.map(|entry| (entry.key, entry.value))
.collect()
}
fn pair(key: &str, value: &str) -> (String, String) {
(key.to_string(), value.to_string())
}
#[test]
fn plain_assignments_comments_and_blank_lines() {
let parsed = pairs("# header\n\nKRAB_ENVIRONMENT=dev\n KRAB_PORT = 3000 \n# end\n");
assert_eq!(
parsed,
vec![pair("KRAB_ENVIRONMENT", "dev"), pair("KRAB_PORT", "3000")]
);
}
#[test]
fn an_export_prefix_is_accepted() {
assert_eq!(
pairs("export KRAB_AUTH_MODE=static\nexport\tKRAB_HOST=0.0.0.0\n"),
vec![
pair("KRAB_AUTH_MODE", "static"),
pair("KRAB_HOST", "0.0.0.0")
]
);
assert_eq!(pairs("exported=1\n"), vec![pair("exported", "1")]);
}
#[test]
fn double_quoted_values_honour_escapes_and_keep_hashes() {
assert_eq!(
pairs(r#"A="two words # not a comment" # a comment"#),
vec![pair("A", "two words # not a comment")]
);
assert_eq!(
pairs(r#"B="line\nbreak \"quoted\" back\\slash""#),
vec![pair("B", "line\nbreak \"quoted\" back\\slash")]
);
assert_eq!(
pairs(r#"C="C:\data\krab""#),
vec![pair("C", r"C:\data\krab")]
);
}
#[test]
fn single_quoted_values_are_literal() {
assert_eq!(
pairs(r#"A='no \n escapes # here' # comment"#),
vec![pair("A", r"no \n escapes # here")]
);
}
#[test]
fn values_are_never_interpolated() {
assert_eq!(
pairs("A=${HOME}/x\nB=\"$USER\"\n"),
vec![pair("A", "${HOME}/x"), pair("B", "$USER")]
);
}
#[test]
fn an_unquoted_hash_starts_a_comment_only_after_whitespace() {
assert_eq!(
pairs("URL=https://host/#frag\nID=abc#123\nX=value # note\nEMPTY=\n"),
vec![
pair("URL", "https://host/#frag"),
pair("ID", "abc#123"),
pair("X", "value"),
pair("EMPTY", ""),
]
);
}
#[test]
fn a_later_duplicate_replaces_an_earlier_one() {
assert_eq!(
pairs("A=1\nB=2\nA=3\n"),
vec![pair("B", "2"), pair("A", "3")]
);
}
#[test]
fn crlf_line_endings_and_a_bom_are_tolerated() {
assert_eq!(
pairs("\u{feff}A=1\r\nB=\"2\"\r\n"),
vec![pair("A", "1"), pair("B", "2")]
);
}
#[test]
fn malformed_lines_become_warnings_without_losing_the_rest() {
let parsed = parse_dotenv(
"GOOD=1\nnot an assignment\n1BAD=x\nOPEN=\"unterminated\nTAIL='x' y\nALSO_GOOD=2\n",
);
assert_eq!(
parsed
.entries
.iter()
.map(|e| e.key.as_str())
.collect::<Vec<_>>(),
vec!["GOOD", "ALSO_GOOD"]
);
assert_eq!(parsed.warnings.len(), 4, "{:?}", parsed.warnings);
assert!(
parsed.warnings[0].starts_with("line 2:"),
"{:?}",
parsed.warnings
);
assert!(
parsed.warnings[1].contains("`1BAD`"),
"{:?}",
parsed.warnings
);
assert!(
parsed.warnings[2].contains("unterminated"),
"{:?}",
parsed.warnings
);
assert!(
parsed.warnings[3].starts_with("line 5:"),
"{:?}",
parsed.warnings
);
}
#[test]
fn variables_already_set_are_not_overridden() {
let entries = vec![
DotenvEntry {
key: "KRAB_AUTH_MODE".to_string(),
value: "static".to_string(),
},
DotenvEntry {
key: "KRAB_ENVIRONMENT".to_string(),
value: "dev".to_string(),
},
];
let (apply, kept) = entries_to_apply(&entries, |key| key == "KRAB_AUTH_MODE");
assert_eq!(kept, 1);
assert_eq!(
apply.iter().map(|e| e.key.as_str()).collect::<Vec<_>>(),
vec!["KRAB_ENVIRONMENT"]
);
}
#[test]
#[serial_test::serial]
fn loading_a_file_fills_gaps_but_never_overrides_the_process() {
const SET: &str = "KRAB_CLI_DOTENV_TEST_ALREADY_SET";
const UNSET: &str = "KRAB_CLI_DOTENV_TEST_UNSET";
std::env::set_var(SET, "from-process");
std::env::remove_var(UNSET);
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join(".env");
std::fs::write(&path, format!("{SET}=from-file\n{UNSET}=from-file\n")).expect("write");
let load = load_dotenv_file(&path)
.expect("load succeeds")
.expect("file exists");
let set_after = std::env::var(SET);
let unset_after = std::env::var(UNSET);
std::env::remove_var(SET);
std::env::remove_var(UNSET);
assert_eq!(load.applied, 1);
assert_eq!(load.kept_from_environment, 1);
assert_eq!(set_after.as_deref(), Ok("from-process"));
assert_eq!(unset_after.as_deref(), Ok("from-file"));
}
#[test]
fn a_missing_file_is_not_an_error() {
let dir = tempfile::tempdir().expect("tempdir");
assert_eq!(
load_dotenv_file(&dir.path().join(".env")).expect("no error"),
None
);
}
}