refactor: make use of common FsError and FsResult

Also improved inline documentation.

Author: soywod

src/coroutines/create-dir.rs

@@ -1,28 +1,15 @@
-//! Module dedicated to the [`CreateDir`] I/O-free coroutine.
+//! I/O-free coroutine to create a filesystem directory.
 
 use std::path::PathBuf;
 
 use log::{debug, trace};
-use thiserror::Error;
 
-use crate::io::FsIo;
+use crate::{
+    error::{FsError, FsResult},
+    io::FsIo,
+};
 
-#[derive(Clone, Debug, Error)]
-pub enum CreateDirError {
-    #[error("Missing input: path missing or already consumed")]
-    MissingInput,
-    #[error("Invalid argument: expected {0}, got {1:?}")]
-    InvalidArgument(&'static str, FsIo),
-}
-
-#[derive(Clone, Debug)]
-pub enum CreateDirResult {
-    Ok,
-    Err(CreateDirError),
-    Io(FsIo),
-}
-
-/// I/O-free coroutine for creating a directory.
+/// I/O-free coroutine to create a filesystem directory.
 #[derive(Debug)]
 pub struct CreateDir {
     path: Option<PathBuf>,
@@ -35,27 +22,27 @@ impl CreateDir {
         Self { path }
     }
 
-    /// Makes create dir progress.
-    pub fn resume(&mut self, arg: Option<FsIo>) -> CreateDirResult {
+    /// Makes the coroutine progress.
+    pub fn resume(&mut self, arg: Option<FsIo>) -> FsResult {
         let Some(arg) = arg else {
             let Some(path) = self.path.take() else {
-                return CreateDirResult::Err(CreateDirError::MissingInput);
+                return FsResult::Err(FsError::MissingInput);
             };
 
             trace!("wants I/O to create directory at {}", path.display());
-            return CreateDirResult::Io(FsIo::CreateDir(Err(path)));
+            return FsResult::Io(FsIo::CreateDir(Err(path)));
         };
 
         debug!("resume after creating directory");
 
         let FsIo::CreateDir(io) = arg else {
-            let err = CreateDirError::InvalidArgument("create dir output", arg);
-            return CreateDirResult::Err(err);
+            let err = FsError::InvalidArgument("create dir output", arg);
+            return FsResult::Err(err);
         };
 
         match io {
-            Ok(()) => CreateDirResult::Ok,
-            Err(path) => CreateDirResult::Io(FsIo::CreateDir(Err(path))),
+            Ok(()) => FsResult::Ok(()),
+            Err(path) => FsResult::Io(FsIo::CreateDir(Err(path))),
         }
     }
 }

src/coroutines/create-dirs.rs

@@ -1,61 +1,48 @@
-//! Module dedicated to the [`CreateDirs`] I/O-free coroutine.
+//! I/O-free coroutine to create multiple filesystem directories.
 
 use std::{collections::HashSet, path::PathBuf};
 
 use log::{debug, trace};
-use thiserror::Error;
 
-use crate::io::FsIo;
+use crate::{
+    error::{FsError, FsResult},
+    io::FsIo,
+};
 
-#[derive(Clone, Debug, Error)]
-pub enum CreateDirsError {
-    #[error("Missing input: paths missing or already consumed")]
-    MissingInput,
-    #[error("Invalid argument: expected {0}, got {1:?}")]
-    InvalidArgument(&'static str, FsIo),
-}
-
-#[derive(Clone, Debug)]
-pub enum CreateDirsResult {
-    Ok,
-    Err(CreateDirsError),
-    Io(FsIo),
-}
-
-/// I/O-free coroutine for creating a dirsectory.
+/// I/O-free coroutine to create multiple filesystem directories.
 #[derive(Debug)]
 pub struct CreateDirs {
     paths: Option<HashSet<PathBuf>>,
 }
 
 impl CreateDirs {
-    /// Creates a new coroutine from the given dirsectory path.
+    /// Creates a new coroutine from the given directory path.
     pub fn new(paths: impl IntoIterator<Item = PathBuf>) -> Self {
         let paths = Some(paths.into_iter().collect());
         Self { paths }
     }
 
-    /// Makes create dirs progress.
-    pub fn resume(&mut self, arg: Option<FsIo>) -> CreateDirsResult {
+    /// Makes the coroutine progress.
+    pub fn resume(&mut self, arg: Option<FsIo>) -> FsResult {
         let Some(arg) = arg else {
             let Some(paths) = self.paths.take() else {
-                return CreateDirsResult::Err(CreateDirsError::MissingInput);
+                return FsResult::Err(FsError::MissingInput);
             };
 
             trace!("wants I/O to create directories: {paths:?}");
-            return CreateDirsResult::Io(FsIo::CreateDirs(Err(paths)));
+            return FsResult::Io(FsIo::CreateDirs(Err(paths)));
         };
 
         debug!("resume after creating directories");
 
         let FsIo::CreateDirs(io) = arg else {
-            let err = CreateDirsError::InvalidArgument("create dirs output", arg);
-            return CreateDirsResult::Err(err);
+            let err = FsError::InvalidArgument("create dirs output", arg);
+            return FsResult::Err(err);
         };
 
         match io {
-            Ok(()) => CreateDirsResult::Ok,
-            Err(path) => CreateDirsResult::Io(FsIo::CreateDirs(Err(path))),
+            Ok(()) => FsResult::Ok(()),
+            Err(path) => FsResult::Io(FsIo::CreateDirs(Err(path))),
         }
     }
 }

src/coroutines/create-file.rs

@@ -1,62 +1,49 @@
-//! Module dedicated to the [`CreateFile`] I/O-free coroutine.
+//! I/O-free coroutine to create a filesystem file.
 
 use std::path::PathBuf;
 
 use log::{debug, trace};
-use thiserror::Error;
 
-use crate::io::FsIo;
+use crate::{
+    error::{FsError, FsResult},
+    io::FsIo,
+};
 
-#[derive(Clone, Debug, Error)]
-pub enum CreateFileError {
-    #[error("Missing input: contents missing or already consumed")]
-    MissingInput,
-    #[error("Invalid argument: expected {0}, got {1:?}")]
-    InvalidArgument(&'static str, FsIo),
-}
-
-#[derive(Clone, Debug)]
-pub enum CreateFileResult {
-    Ok,
-    Err(CreateFileError),
-    Io(FsIo),
-}
-
-/// I/O-free coroutine for creating a fileectory.
+/// I/O-free coroutine to create a filesystem file.
 #[derive(Debug)]
 pub struct CreateFile {
     contents: Option<(PathBuf, Vec<u8>)>,
 }
 
 impl CreateFile {
-    /// Creates a new coroutine from the given fileectory path.
+    /// Creates a new coroutine from the given file path and contents.
     pub fn new(path: impl Into<PathBuf>, contents: impl IntoIterator<Item = u8>) -> Self {
         let contents = contents.into_iter().collect();
         let contents = Some((path.into(), contents));
         Self { contents }
     }
 
-    /// Makes create file progress.
-    pub fn resume(&mut self, arg: Option<FsIo>) -> CreateFileResult {
+    /// Makes the coroutine progress.
+    pub fn resume(&mut self, arg: Option<FsIo>) -> FsResult {
         let Some(arg) = arg else {
             let Some((path, contents)) = self.contents.take() else {
-                return CreateFileResult::Err(CreateFileError::MissingInput);
+                return FsResult::Err(FsError::MissingInput);
             };
 
             trace!("wants I/O to create file at {}", path.display());
-            return CreateFileResult::Io(FsIo::CreateFile(Err((path, contents))));
+            return FsResult::Io(FsIo::CreateFile(Err((path, contents))));
         };
 
         debug!("resume after creating file");
 
         let FsIo::CreateFile(io) = arg else {
-            let err = CreateFileError::InvalidArgument("create file output", arg);
-            return CreateFileResult::Err(err);
+            let err = FsError::InvalidArgument("create file output", arg);
+            return FsResult::Err(err);
         };
 
         match io {
-            Ok(()) => CreateFileResult::Ok,
-            Err(path) => CreateFileResult::Io(FsIo::CreateFile(Err(path))),
+            Ok(()) => FsResult::Ok(()),
+            Err(path) => FsResult::Io(FsIo::CreateFile(Err(path))),
         }
     }
 }

src/coroutines/create-files.rs

@@ -1,35 +1,22 @@
-//! Module dedicated to the [`CreateFiles`] I/O-free coroutine.
+//! I/O-free coroutine to create multiple filesystem files.
 
 use std::{collections::HashMap, path::PathBuf};
 
 use log::{debug, trace};
-use thiserror::Error;
 
-use crate::io::FsIo;
+use crate::{
+    error::{FsError, FsResult},
+    io::FsIo,
+};
 
-#[derive(Clone, Debug, Error)]
-pub enum CreateFilesError {
-    #[error("Missing input: contents missing or already consumed")]
-    MissingInput,
-    #[error("Invalid argument: expected {0}, got {1:?}")]
-    InvalidArgument(&'static str, FsIo),
-}
-
-#[derive(Clone, Debug)]
-pub enum CreateFilesResult {
-    Ok,
-    Err(CreateFilesError),
-    Io(FsIo),
-}
-
-/// I/O-free coroutine for creating a file.
+/// I/O-free coroutine to create multiple filesystem files.
 #[derive(Debug)]
 pub struct CreateFiles {
     contents: Option<HashMap<PathBuf, Vec<u8>>>,
 }
 
 impl CreateFiles {
-    /// Creates a new coroutine from the given file path and contents.
+    /// Creates a new coroutine from the given file paths and contents.
     pub fn new(
         contents: impl IntoIterator<Item = (impl Into<PathBuf>, impl IntoIterator<Item = u8>)>,
     ) -> Self {
@@ -40,27 +27,27 @@ impl CreateFiles {
         Self { contents }
     }
 
-    /// Makes create files progress.
-    pub fn resume(&mut self, arg: Option<FsIo>) -> CreateFilesResult {
+    /// Makes the coroutine progress.
+    pub fn resume(&mut self, arg: Option<FsIo>) -> FsResult {
         let Some(arg) = arg else {
             let Some(contents) = self.contents.take() else {
-                return CreateFilesResult::Err(CreateFilesError::MissingInput);
+                return FsResult::Err(FsError::MissingInput);
             };
 
             trace!("wants I/O to create files");
-            return CreateFilesResult::Io(FsIo::CreateFiles(Err(contents)));
+            return FsResult::Io(FsIo::CreateFiles(Err(contents)));
         };
 
         debug!("resume after creating files");
 
         let FsIo::CreateFiles(io) = arg else {
-            let err = CreateFilesError::InvalidArgument("create files output", arg);
-            return CreateFilesResult::Err(err);
+            let err = FsError::InvalidArgument("create files output", arg);
+            return FsResult::Err(err);
         };
 
         match io {
-            Ok(()) => CreateFilesResult::Ok,
-            Err(path) => CreateFilesResult::Io(FsIo::CreateFiles(Err(path))),
+            Ok(()) => FsResult::Ok(()),
+            Err(path) => FsResult::Io(FsIo::CreateFiles(Err(path))),
         }
     }
 }

src/coroutines/mod.rs

@@ -1,10 +1,10 @@
 //! Collection of I/O-free, resumable and composable filesystem state
 //! machines.
 //!
-//! Coroutines emit [`Io`] requests that need to be processed by
+//! Coroutines emit [I/O] requests that need to be processed by
 //! [runtimes] in order to continue their progression.
 //!
-//! [`Io`]: crate::Io
+//! [I/O]: crate::io
 //! [runtimes]: crate::runtimes
 
 #[path = "create-dir.rs"]

src/coroutines/read-dir.rs

@@ -1,61 +1,50 @@
-//! Module dedicated to the [`ReadDir`] I/O-free coroutine.
+//! I/O-free coroutine to read entries contained inside a filesystem
+//! directory.
 
 use std::{collections::HashSet, path::PathBuf};
 
 use log::{debug, trace};
-use thiserror::Error;
 
-use crate::io::FsIo;
+use crate::{
+    error::{FsError, FsResult},
+    io::FsIo,
+};
 
-#[derive(Clone, Debug, Error)]
-pub enum ReadDirError {
-    #[error("Missing input: path missing or already consumed")]
-    MissingInput,
-    #[error("Invalid argument: expected {0}, got {1:?}")]
-    InvalidArgument(&'static str, FsIo),
-}
-
-#[derive(Clone, Debug)]
-pub enum ReadDirResult {
-    Ok(HashSet<PathBuf>),
-    Err(ReadDirError),
-    Io(FsIo),
-}
-
-/// I/O-free coroutine for reading directory entries.
+/// I/O-free coroutine to read entries contained inside a filesystem
+/// directory.
 #[derive(Debug)]
 pub struct ReadDir {
     path: Option<PathBuf>,
 }
 
 impl ReadDir {
-    /// Reads a new coroutine from the given directory path.
+    /// Creates a new coroutine from the given directory path.
     pub fn new(path: impl Into<PathBuf>) -> Self {
         let input = Some(path.into());
         Self { path: input }
     }
 
     /// Makes the coroutine progress.
-    pub fn resume(&mut self, arg: Option<FsIo>) -> ReadDirResult {
+    pub fn resume(&mut self, arg: Option<FsIo>) -> FsResult<HashSet<PathBuf>> {
         let Some(arg) = arg else {
             let Some(path) = self.path.take() else {
-                return ReadDirResult::Err(ReadDirError::MissingInput);
+                return FsResult::Err(FsError::MissingInput);
             };
 
             trace!("wants I/O to read directory at {}", path.display());
-            return ReadDirResult::Io(FsIo::ReadDir(Err(path)));
+            return FsResult::Io(FsIo::ReadDir(Err(path)));
         };
 
         debug!("resume after reading directory");
 
         let FsIo::ReadDir(io) = arg else {
-            let err = ReadDirError::InvalidArgument("read dir output", arg);
-            return ReadDirResult::Err(err);
+            let err = FsError::InvalidArgument("read dir output", arg);
+            return FsResult::Err(err);
         };
 
         match io {
-            Ok(paths) => ReadDirResult::Ok(paths),
-            Err(path) => ReadDirResult::Io(FsIo::ReadDir(Err(path))),
+            Ok(paths) => FsResult::Ok(paths),
+            Err(path) => FsResult::Io(FsIo::ReadDir(Err(path))),
         }
     }
 }