thot-local 0.10.0-intermediate

//! Common error types.
use serde::{self, Deserialize, Serialize};
use settings_manager::prelude::Error as SettingsError;
use std::io;
use std::path::PathBuf;
use std::result::Result as StdResult;
use thot_core::result::Error as CoreError;

// ***********************
// *** Settings Errors ***
// ***********************

#[derive(Debug)]
pub enum SettingsFileError {
    CouldNotLoad(SettingsError),
    CouldNotSave(SettingsError),
}

#[derive(Serialize, Deserialize, Debug)]
pub enum SettingsValidationError {
    InvalidSetting,
}

// **********************
// *** Project Error ***
// **********************

#[derive(Serialize, Deserialize, Debug)]
pub enum ProjectError {
    DuplicatePath(PathBuf),
    PathNotAProjectRoot(PathBuf),
    PathNotInProject(PathBuf),
    PathNotAResource(PathBuf),
}

// ***********************
// *** Container Error ***
// ***********************

#[derive(Serialize, Deserialize, Debug)]
pub enum ContainerError {
    InvalidChildPath(PathBuf),
    PathNotAContainer(PathBuf),
}

// *******************
// *** Asset Error ***
// *******************

#[derive(Serialize, Deserialize, Debug)]
pub enum AssetError {
    PathNotAContainer(PathBuf),
    FileAlreadyAsset(PathBuf),
    ContainerNotFound(PathBuf),
    InvalidPath(PathBuf, String),
}

// ********************
// *** Users Errors ***
// ********************

#[derive(Serialize, Deserialize, Debug)]
pub enum UsersError {
    DuplicateEmail(String),
    InvalidEmail(String),
}

// *******************
// *** Local Error ***
// *******************

#[derive(Debug)]
pub enum Error {
    AssetError(AssetError),
    ContainerError(ContainerError),
    CoreError(CoreError),
    ProjectError(ProjectError),
    SettingsError(SettingsError),
    SettingsFileError(SettingsFileError),
    SettingsValidationError(SettingsValidationError),
    UsersError(UsersError),
}

impl From<CoreError> for Error {
    fn from(err: CoreError) -> Self {
        Error::CoreError(err)
    }
}

impl From<SettingsError> for Error {
    fn from(err: SettingsError) -> Self {
        Error::SettingsError(err)
    }
}

impl From<io::Error> for Error {
    fn from(err: io::Error) -> Self {
        Error::CoreError(CoreError::IoError(err))
    }
}

impl From<serde_json::Error> for Error {
    fn from(err: serde_json::Error) -> Self {
        Error::CoreError(CoreError::SerdeError(err))
    }
}

// @todo: Make better.
impl Serialize for Error {
    fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        let msg = format!("{:?}", self);
        serializer.serialize_str(msg.as_ref())
    }
}

// *******************
// *** Thot Result ***
// *******************

pub type Result<T = ()> = StdResult<T, Error>;

impl From<Error> for Result {
    fn from(err: Error) -> Self {
        Err(err)
    }
}

#[cfg(test)]
#[path = "./result_test.rs"]
mod result_test;