Expose parse errors via Dotenv::iter.

src/dotenv.rs

@@ -59,28 +59,32 @@ impl<'a> Iter<'a> {
             Value::List(list) => Some(list.into_iter().flat_map(|it| self.resolve(it)).collect()),
         }
     }
+
+    pub fn try_next(&mut self) -> crate::Result<Option<(&'a str, String)>> {
+        while !self.input.is_empty() {
+            match parse(self.input) {
+                Ok((rest, maybe)) => {
+                    self.input = rest; // set next input
+
+                    if let Some((key, value)) = maybe {
+                        if let Some(value) = self.resolve(value) {
+                            self.resolved.insert(key, value.clone());
+                            return Ok(Some((key, value)));
+                        }
+                    }
+                }
+                Err(err) => return Err(crate::Error::Parse(format!("{err}"))),
+            }
+        }
+        Ok(None)
+    }
 }
 
 impl<'a> Iterator for Iter<'a> {
     type Item = (&'a str, String);
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Ok((rest, maybe)) = parse(self.input) {
-            self.input = rest; // set next input
-
-            if let Some((key, value)) = maybe {
-                if let Some(value) = self.resolve(value) {
-                    self.resolved.insert(key, value.clone());
-                    return Some((key, value));
-                }
-            }
-
-            if rest.is_empty() {
-                break;
-            }
-        }
-
-        None
+        self.try_next().unwrap_or_default()
     }
 }
 

src/errors.rs

@@ -1,13 +1,15 @@
 use std::env;
 use std::error;
 use std::fmt;
+use std::fmt::Display;
 use std::io;
 
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum Error {
     Io(io::Error),
     Env(env::VarError),
+    Parse(String),
 }
 
 impl Error {
@@ -29,6 +31,7 @@ impl fmt::Display for Error {
         match self {
             Error::Io(err) => err.fmt(fmt),
             Error::Env(err) => err.fmt(fmt),
+            Error::Parse(err) => err.fmt(fmt),
         }
     }
 }
@@ -38,6 +41,7 @@ impl error::Error for Error {
         match self {
             Error::Io(err) => Some(err),
             Error::Env(err) => Some(err),
+            Error::Parse(_) => None,
         }
     }
 }
@@ -53,3 +57,9 @@ impl From<env::VarError> for Error {
         Error::Env(err)
     }
 }
+
+impl<I: Display> From<nom::error::Error<I>> for Error {
+    fn from(err: nom::error::Error<I>) -> Self {
+        Error::Parse(format!("{err}"))
+    }
+}

tests/fixtures/sample-basic.env

@@ -24,7 +24,6 @@ DOUBLE_AND_SINGLE_QUOTES_INSIDE_BACKTICKS=`double "quotes" and single 'quotes' w
 EXPAND_NEWLINES="expand\nnew\nlines"
 DONT_EXPAND_UNQUOTED=dontexpand\nnewlines
 DONT_EXPAND_SQUOTED='dontexpand\nnewlines'
-DONT_EXPAND_SQUOTED='dontexpand\nnewlines'
 # COMMENTS=work
 INLINE_COMMENTS=inline comments # work #very #well
 INLINE_COMMENTS_SINGLE_QUOTES='inline comments outside of #singlequotes' # work

tests/test-dotenv-try-next.rs

@@ -0,0 +1,19 @@
+mod fixtures;
+use fixtures::*;
+
+#[test]
+fn test_propagate_env_parse_errors() -> anyhow::Result<()> {
+    let (_t, mut exps) = with_basic_dotenv()?;
+
+    // This is an example of how a consumer that cares about invalid `.env` files can handle them using the
+    // `Iter::try_next` API (see: https://github.com/arniu/dotenvs-rs/issues/4)
+    let env = dotenv::from_filename(".env")?;
+    let mut iter = env.iter();
+    while let Some((key, value)) = iter.try_next()? {
+        let expected = exps.remove(key).unwrap();
+        assert_eq!(expected, value, "check {}", key);
+    }
+    assert!(exps.is_empty());
+
+    Ok(())
+}

tests/test-sample-bad.rs

@@ -0,0 +1,44 @@
+use dotenv::Error;
+use std::collections::HashMap;
+use std::iter::{IntoIterator, Iterator};
+
+const BAD_ENV: &str = r#"
+A=foo bar
+B="notenough
+C='toomany''
+D=valid
+export NOT_SET
+E=valid
+"#;
+
+#[test]
+fn test_bad_env() -> anyhow::Result<()> {
+    let env = dotenv::from_read(BAD_ENV.as_bytes())?;
+
+    assert_eq!(
+        vec![
+            ("A", "foo bar".into()),
+            ("B", "\"notenough".into()),
+            ("C", "toomany".into())
+        ]
+        .into_iter()
+        .collect::<HashMap<_, _>>(),
+        env.iter().collect::<HashMap<_, _>>()
+    );
+
+    let mut iter = env.iter();
+    assert_eq!(Some(("A", "foo bar".into())), iter.try_next()?);
+    assert_eq!(Some(("B", "\"notenough".into())), iter.try_next()?);
+    assert_eq!(Some(("C", "toomany".into())), iter.try_next()?);
+
+    // TODO: Use assert_matches! when it stabilizes: https://github.com/rust-lang/rust/issues/82775
+    match iter.try_next().unwrap_err() {
+        Error::Parse(err) => assert_eq!(
+            "Parsing Error: Error { input: \"'\\nD=valid\\nexport NOT_SET\\nE=valid\\n\", code: Tag }",
+            err
+        ),
+        err => panic!("Unexpected error variant: {err:?}", err = err),
+    }
+
+    Ok(())
+}

tests/test-sample-basic.rs

@@ -3,11 +3,12 @@ use fixtures::*;
 
 #[test]
 fn test_sample() -> anyhow::Result<()> {
-    let (_t, exps) = with_basic_dotenv()?;
+    let (_t, mut exps) = with_basic_dotenv()?;
     for (key, value) in dotenv::from_filename(".env")?.iter() {
-        let expected = exps.get(key).unwrap();
-        assert_eq!(expected, &value, "check {}", key);
+        let expected = exps.remove(key).unwrap();
+        assert_eq!(expected, value, "check {}", key);
     }
+    assert!(exps.is_empty());
 
     Ok(())
 }

tests/test-sample-expand.rs

@@ -3,11 +3,12 @@ use fixtures::*;
 
 #[test]
 fn test_sample() -> anyhow::Result<()> {
-    let (_t, exps) = with_expand_dotenv()?;
+    let (_t, mut exps) = with_expand_dotenv()?;
     for (key, value) in dotenv::from_filename(".env")?.iter() {
-        let expected = exps.get(key).unwrap();
-        assert_eq!(expected, &value, "check {}", key);
+        let expected = exps.remove(key).unwrap();
+        assert_eq!(expected, value, "check {}", key);
     }
+    assert!(exps.is_empty());
 
     Ok(())
 }

tests/test-sample-multiline.rs

@@ -3,11 +3,12 @@ use fixtures::*;
 
 #[test]
 fn test_sample() -> anyhow::Result<()> {
-    let (_t, exps) = with_multiline_dotenv()?;
+    let (_t, mut exps) = with_multiline_dotenv()?;
     for (key, value) in dotenv::from_filename(".env")?.iter() {
-        let expected = exps.get(key).unwrap();
-        assert_eq!(expected, &value, "check {}", key);
+        let expected = exps.remove(key).unwrap();
+        assert_eq!(expected, value, "check {}", key);
     }
+    assert!(exps.is_empty());
 
     Ok(())
 }