🚧 Working out a few ideas

Author: rster2002

src/modules/logs/log_dir.rs

@@ -23,8 +23,10 @@ pub enum LogDirError {
 }
 
 impl LogDir {
-    pub fn new(dir_path: PathBuf) -> LogDir {
-        LogDir { dir_path }
+    pub fn new(dir_path: impl Into<PathBuf>) -> LogDir {
+        LogDir {
+            dir_path: dir_path.into(),
+        }
     }
 
     pub fn path(&self) -> &Path {

src/modules/logs/mod.rs

@@ -283,3 +283,4 @@ pub mod blocking;
 #[cfg(feature = "asynchronous")]
 #[cfg_attr(docsrs, doc(cfg(feature = "asynchronous")))]
 pub mod asynchronous;
+mod models;

src/modules/logs/models.rs

@@ -0,0 +1,2 @@
+pub mod log_dir;
+mod log_file;

src/modules/logs/models/log_dir.rs

@@ -0,0 +1,38 @@
+use std::borrow::Cow;
+use std::path::{Path, PathBuf};
+
+mod iter;
+mod try_iter;
+
+pub use iter::Iter;
+use crate::logs::models::log_dir::try_iter::TryIter;
+
+pub struct LogDir<'a> {
+    path: Cow<'a, Path>,
+}
+
+impl<'a> LogDir<'a> {
+    pub fn new(path: &'a Path) -> Self {
+        LogDir { path: Cow::Borrowed(path) }
+    }
+
+    pub fn iter(&'a self) -> Iter<'a> {
+        Iter { inner: self }
+    }
+
+    pub fn try_iter(&'a self) -> TryIter<'a> {
+        TryIter { inner: self }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::logs::models::log_dir::LogDir;
+
+    #[test]
+    fn api_design() {
+        let log_dir = LogDir::new("./path".as_ref());
+
+        log_dir.iter();
+    }
+}

src/modules/logs/models/log_dir/iter.rs

@@ -0,0 +1,14 @@
+use crate::logs::models::log_dir::LogDir;
+use crate::logs::models::log_file::LogFile;
+
+pub struct Iter<'a> {
+    pub(crate) inner: &'a LogDir<'a>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = LogFile<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        todo!()
+    }
+}

src/modules/logs/models/log_dir/try_iter.rs

@@ -0,0 +1,27 @@
+use crate::logs::models::log_file::{LogFile, LogFileError};
+use crate::logs::models::log_dir::LogDir;
+
+pub struct TryIter<'a> {
+    pub(crate) inner: &'a LogDir<'a>,
+}
+
+impl<'a> TryIter<'a> {
+    pub fn new(inner: &'a LogDir) -> Self {
+        TryIter { inner }
+    }
+}
+
+impl<'a> Iterator for TryIter<'a> {
+    type Item = Result<LogFile<'a>, LogFileError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let dir = self.inner
+            .path
+            .read_dir();
+
+        let value = match dir {
+            Ok(value) => value,
+            Err(error) => return Some(Err(error.into())),
+        };
+    }
+}

src/modules/logs/models/log_file.rs

@@ -0,0 +1,43 @@
+use std::borrow::Cow;
+use std::fs::DirEntry;
+use std::path::Path;
+use lazy_static::lazy_static;
+use regex::Regex;
+use thiserror::Error;
+
+pub struct LogFile<'a> {
+    path: Cow<'a, Path>,
+}
+
+#[derive(Debug, Error)]
+#[error(transparent)]
+pub enum LogFileError {
+    IO(#[from] std::io::Error),
+}
+
+#[cfg(not(feature = "legacy"))]
+type RegexList = [(Regex, &'static str); 1];
+
+#[cfg(feature = "legacy")]
+type RegexList = [(Regex, &'static str); 2];
+
+lazy_static! {
+    static ref FILE_NAME_REGEXES: RegexList = [
+        // Journal.YYYY-MM-DDTHHmmss.01.log
+        (Regex::new(r"Journal\.(\d{4}-\d{2}-\d{2}T\d+)\.(\d{2})\.log").unwrap(), "%Y-%m-%dT%H%M%S"),
+
+        // Journal.YYMMDDHHMMSS.01.log
+        #[cfg(feature = "legacy")]
+        (Regex::new(r"Journal\.(\d{12})\.(\d{2})\.log").unwrap(), "%y%m%d%H%M%S"),
+    ];
+}
+
+impl<'a> TryFrom<DirEntry> for LogFile<'a> {
+    type Error = LogFileError;
+
+    fn try_from(value: DirEntry) -> Result<Self, Self::Error> {
+        let file_name = value.file_name();
+
+        // let path = value.path();
+    }
+}