Add EmailReader trait

This trait is now also implemented for reading the test messages.

Signed-off-by: Jacob Kiers <jacob@jacobkiers.net>

bin/src/main.rs

@@ -1,10 +1,11 @@
 use std::{
     collections::HashMap,
     error::Error,
-    fs::{read_dir, OpenOptions},
+    fs::{read_dir, DirEntry, OpenOptions},
     io::Write,
     net::TcpStream,
     path::{Path, PathBuf},
+    vec::IntoIter,
 };
 
 use imap::Session;
@@ -26,10 +27,14 @@ fn main() {
         std::fs::create_dir(&dir).expect("Could not create directory");
     }
 
-    let messsages = messages_from_tests(&Path::new("tests/data")) //connect("my.kiers.eu", 993, "newsletters@kie.rs", "Jjkcloudron1!")
-        .expect("A list of messages");
+    // let messsages = messages_from_tests(&Path::new("tests/data")) //connect("my.kiers.eu", 993, "newsletters@kie.rs", "Jjkcloudron1!")
+    //     .expect("A list of messages");
 
-    for (uid, message) in messsages {
+    // for (uid, message) in messages {
+
+    let mut reader = TestMessagesReader::new((&Path::new("tests/data")).to_path_buf());
+
+    for (uid, message) in reader.read_rfc822_messages() {
         println!("Processing message {}", &uid);
 
         let parsed = Message::parse(&message).expect("A parsed messsage.");
@@ -144,32 +149,6 @@ fn process_html(input: &str) -> Result<String, sanitize_html::errors::SanitizeEr
     //Ok(input.to_owned())
 }
 
-fn messages_from_tests(path: &Path) -> Result<HashMap<String, Vec<u8>>, Box<dyn Error>> {
-    let mut messages = HashMap::<String, Vec<u8>>::new();
-
-    let items = match read_dir(path) {
-        Ok(i) => i,
-        Err(e) => return Err(Box::new(e)),
-    };
-
-    for item in items {
-        if let Ok(item) = item {
-            if let Some(extension) = item.path().extension() {
-                if extension != "eml" {
-                    continue;
-                }
-
-                let uid = item.path().file_stem().unwrap().to_owned();
-                if let Ok(data) = std::fs::read(item.path()) {
-                    messages.insert(uid.into_string().unwrap(), data);
-                }
-            }
-        }
-    }
-
-    Ok(messages)
-}
-
 fn write_to_test_path(uid: &str, message: &[u8]) {
     let test_path: PathBuf = [Path::new("tests/data"), Path::new(&format!("{}.eml", &uid))]
         .iter()
@@ -182,3 +161,48 @@ fn write_to_test_path(uid: &str, message: &[u8]) {
         .expect("Could not open file fir writing")
         .write_all(&message);
 }
+
+pub trait EmailReader {
+    fn read_rfc822_messages(&mut self) -> Box<IntoIter<(String, Vec<u8>)>>;
+}
+
+struct TestMessagesReader {
+    path: PathBuf,
+}
+
+impl TestMessagesReader {
+    pub fn new(path: PathBuf) -> Self {
+        TestMessagesReader { path }
+    }
+}
+
+impl EmailReader for TestMessagesReader {
+    fn read_rfc822_messages(&mut self) -> Box<IntoIter<(String, Vec<u8>)>> {
+        let reader = match read_dir(&self.path) {
+            Ok(r) => r,
+            Err(_) => return Box::new(Vec::new().into_iter()),
+        };
+
+        let items = reader
+            .filter(|i| i.is_ok())
+            .map(|i| i.unwrap() as DirEntry)
+            .filter(|d| match d.path().extension() {
+                Some(ext) => ext == "eml",
+                None => false,
+            })
+            .map(|i| {
+                let uid = i.path().file_stem().unwrap().to_owned();
+                if let Ok(data) = std::fs::read(i.path()) {
+                    Some((uid.into_string().unwrap(), data))
+                } else {
+                    None
+                }
+            })
+            .filter(|i| i.is_some())
+            .map(|i| i.unwrap());
+
+        let iter = items.collect::<Vec<(String, Vec<u8>)>>().into_iter();
+
+        Box::new(iter)
+    }
+}