nix_builder/src/error/error.rs

use std::str::Utf8Error;
use std::string::FromUtf8Error;

#[derive(Debug)]
pub(crate) enum CustomError {
    Static(#[allow(dead_code)] &'static str),
    String(#[allow(dead_code)] String),
    IO(#[allow(dead_code)] std::io::Error),
    TomlSerialize(#[allow(dead_code)] toml::ser::Error),
    TomlDeserialize(#[allow(dead_code)] toml::de::Error),
    Tokio(#[allow(dead_code)] tokio::task::JoinError),
    Serde(#[allow(dead_code)] serde_json::Error),
    Utf8(#[allow(dead_code)] Utf8Error),
    FromUtf8(#[allow(dead_code)] FromUtf8Error),
    PathStripPrefix(#[allow(dead_code)] std::path::StripPrefixError),
    UrlParseError(#[allow(dead_code)] url::ParseError),
    Migrate(#[allow(dead_code)] sqlx::migrate::MigrateError),
    Sql(#[allow(dead_code)] sqlx::Error),
}

impl From<std::io::Error> for CustomError {
    fn from(value: std::io::Error) -> Self {
        CustomError::IO(value)
    }
}

impl From<&'static str> for CustomError {
    fn from(value: &'static str) -> Self {
        CustomError::Static(value)
    }
}

impl From<String> for CustomError {
    fn from(value: String) -> Self {
        CustomError::String(value)
    }
}

impl From<toml::ser::Error> for CustomError {
    fn from(value: toml::ser::Error) -> Self {
        CustomError::TomlSerialize(value)
    }
}

impl From<toml::de::Error> for CustomError {
    fn from(value: toml::de::Error) -> Self {
        CustomError::TomlDeserialize(value)
    }
}

impl From<tokio::task::JoinError> for CustomError {
    fn from(value: tokio::task::JoinError) -> Self {
        CustomError::Tokio(value)
    }
}

impl From<serde_json::Error> for CustomError {
    fn from(value: serde_json::Error) -> Self {
        CustomError::Serde(value)
    }
}

impl From<Utf8Error> for CustomError {
    fn from(value: Utf8Error) -> Self {
        CustomError::Utf8(value)
    }
}

impl From<FromUtf8Error> for CustomError {
    fn from(value: FromUtf8Error) -> Self {
        CustomError::FromUtf8(value)
    }
}

impl From<std::path::StripPrefixError> for CustomError {
    fn from(value: std::path::StripPrefixError) -> Self {
        CustomError::PathStripPrefix(value)
    }
}

impl From<url::ParseError> for CustomError {
    fn from(value: url::ParseError) -> Self {
        CustomError::UrlParseError(value)
    }
}

impl From<sqlx::migrate::MigrateError> for CustomError {
    fn from(value: sqlx::migrate::MigrateError) -> Self {
        CustomError::Migrate(value)
    }
}

impl From<sqlx::Error> for CustomError {
    fn from(value: sqlx::Error) -> Self {
        CustomError::Sql(value)
    }
}