m2dir/

store.rs

use std::{
    error::Error,
    ffi::OsStr,
    fmt::{Debug, Display},
    fs::{self, create_dir_all},
    io::Read,
    os::unix::ffi::OsStrExt,
    path::{Component, Path, PathBuf},
};

use crate::{
    error::LoadM2DirError,
    fs::is_dotfile,
    percent::{percent_decode_bytes, percent_encode_bytes},
    walk::Walker,
    Entry, M2Dir,
};

/// Represents an m2store directory structure.
pub struct M2Store {
    path: PathBuf,
}

impl M2Store {
    /// Returns the path to the m2store root directory.
    pub fn path(&self) -> &Path {
        &self.path
    }

    /// Determines the appropriate [`M2Dir`] for delivering new messages.
    pub fn delivery_target(&self) -> Result<M2Dir, DeliveryError> {
        let delivery = self.path.join(".delivery");

        if delivery.exists() {
            if let Ok(target) = fs::read_link(&delivery) {
                return Ok(M2Dir::new(self.path.join(target))?);
            }

            if delivery.is_file() {
                let target = self.path.join(fs::read_to_string(&delivery)?.trim());
                return Ok(M2Dir::new(target)?);
            }
        }

        Err(DeliveryError::UnspecifiedTarget)
    }

    /// Deliver a new message to the m2store's delivery target
    ///
    /// The delivery target will be resolved using the `.delivery` file and the
    /// message will be stored in the target m2dir.
    ///
    /// # Errors
    ///
    /// This function will error if the delivery target is not a valid m2dir.
    /// Additionally, if any io errors arise while storing the message, they
    /// will also get thrown.
    pub fn deliver<R: Read>(&self, reader: R) -> Result<Entry, DeliveryError> {
        Ok(self.delivery_target()?.store(reader)?)
    }

    /// Creates a new folder within the m2store.
    ///
    /// The given path has to be relative, and the created folder will be
    /// relative to the root of the m2store. The function returns the created
    /// [`M2Dir`].
    ///
    /// # Errors
    ///
    /// If the given path is absolute, an error is returned. An error is also
    /// returned if the directory creation failed.
    pub fn new_folder<P: AsRef<Path> + Debug>(&self, path: P) -> Result<M2Dir, NewFolderError<P>> {
        let mut encoded_path = self.path.clone();
        for component in path.as_ref().components() {
            match component {
                Component::Prefix(_) | Component::RootDir => {
                    return Err(NewFolderError::AbsolutePath(path))
                }
                Component::Normal(s) => encoded_path.push(self.encode_folder_name(s)),
                _ => {}
            }
        }
        create_dir_all(&encoded_path)?;
        Ok(M2Dir { path: encoded_path })
    }

    /// Returns an iterator over folders in the m2store.
    ///
    /// The decoded names and the corresponding [`M2Dir`] are returned,
    /// respectively.
    pub fn folders(&self) -> impl Iterator<Item = (String, M2Dir)> + '_ {
        Walker::new(self.path())
            .unwrap_or_default()
            .filter(|path| path.is_dir())
            .filter(|path| !is_dotfile(path))
            .filter_map(|path| Some((self.decode_folder_name(&path), M2Dir::try_from(path).ok()?)))
    }

    /// Returns an iterator over the m2dir objects in the m2store.
    ///
    /// Only the [`M2Dir`] are returned by this iterator. See
    /// [`M2Store::folders`] for an iterator that returns both the decoded
    /// name and [`M2Dir`] objects.
    pub fn m2dirs(&self) -> impl Iterator<Item = M2Dir> + '_ {
        self.folders().map(|(_, m2dir)| m2dir)
    }

    /// Returns an iterator over the decoded names of the folders in the
    /// m2store.
    ///
    /// Only the decoded names are returned by this iterator. See
    /// [`M2Store::folders`] for an iterator that returns both the decoded names
    /// and [`M2Dir`] objects.
    pub fn folder_names(&self) -> impl Iterator<Item = String> + '_ {
        self.folders().map(|(name, _)| name)
    }

    fn decode_folder_name(&self, path: &Path) -> String {
        // FIXME: If percent decoding yields invalid UTF-8, this will panic
        percent_decode_bytes(path.to_string_lossy().bytes())
            .expect("Decoding folder name failed: Percent encoding yields invalid UTF-8")
    }

    fn encode_folder_name(&self, name: &OsStr) -> PathBuf {
        let mut path = String::new();
        // FIXME: If OsStr is not UTF-8, this might panic
        percent_encode_bytes(name.as_bytes(), &mut path)
            .expect("Folder name encoding failed: OsStr not UTF-8");
        PathBuf::from(path)
    }
}

impl TryFrom<&Path> for M2Store {
    type Error = LoadM2StoreError;

    fn try_from(path: &Path) -> Result<Self, Self::Error> {
        Self::try_from(path.to_path_buf())
    }
}

impl TryFrom<PathBuf> for M2Store {
    type Error = LoadM2StoreError;

    fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
        if !path.is_dir() {
            return Err(LoadM2StoreError::NotDir);
        }

        if !path.join(".m2store").exists() {
            return Err(LoadM2StoreError::NoDotM2Store);
        }

        Ok(Self { path })
    }
}

/// An error that can occur while loading an m2store
#[derive(Debug)]
pub enum LoadM2StoreError {
    /// The given path was not a directory
    NotDir,
    /// The given path does not contain a valid `.m2store` file
    NoDotM2Store,
}

impl Display for LoadM2StoreError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NotDir => write!(f, "is not a directory"),
            Self::NoDotM2Store => write!(f, "no valid `.m2store` found in directory"),
        }
    }
}

impl Error for LoadM2StoreError {}

/// An error that can occur during delivery.
#[derive(Debug)]
pub enum DeliveryError {
    /// Represents an I/O error that occurred during the delivery process.
    Io(std::io::Error),
    /// Indicates that the targetted m2dir is invalid
    InvalidTarget(LoadM2DirError),
    /// Represents the absence of a `.delivery` entry in an m2store, required to
    /// determine where the delivery target is.
    UnspecifiedTarget,
}

impl Display for DeliveryError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Io(e) => write!(f, "{e}"),
            Self::InvalidTarget(e) => write!(f, "{e}"),
            Self::UnspecifiedTarget => write!(f, "could not find `.delivery` in m2store"),
        }
    }
}

impl Error for DeliveryError {}

impl From<std::io::Error> for DeliveryError {
    fn from(e: std::io::Error) -> Self {
        Self::Io(e)
    }
}

impl From<LoadM2DirError> for DeliveryError {
    fn from(e: LoadM2DirError) -> Self {
        Self::InvalidTarget(e)
    }
}

/// An error that can occur while creating a folder in an m2store
#[derive(Debug)]
pub enum NewFolderError<P: AsRef<Path> + Debug> {
    /// The given path was absolute, which is invalid when creating a folder
    AbsolutePath(P),
    /// Represents an I/O error that occurred during the creation of the folder.
    Io(std::io::Error),
}

impl<P: AsRef<Path> + Debug> Error for NewFolderError<P> {}

impl<P: AsRef<Path> + Debug> Display for NewFolderError<P> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Io(e) => write!(f, "{e}"),
            Self::AbsolutePath(path) => write!(f, "Path {:?} has to be relative", path.as_ref()),
        }
    }
}

impl<P: AsRef<Path> + Debug> From<std::io::Error> for NewFolderError<P> {
    fn from(e: std::io::Error) -> Self {
        Self::Io(e)
    }
}