git-next/crates/cli/src/server/gitforge/errors.rs

use crate::server::config::{BranchName, GitDir};

#[derive(Debug)]
pub enum ForgeFileError {
    NotFound(String),
    ParseContent,
    DecodeFromBase64,
    DecodeFromUtf8,
    UnknownEncoding(String),
    NotFile(String),
    Unknown(String),
}
impl std::error::Error for ForgeFileError {}
impl std::fmt::Display for ForgeFileError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NotFound(file_path) => write!(f, "File not found: {file_path}"),
            Self::NotFile(file_path) => write!(f, "Not a file: {file_path}"),
            Self::DecodeFromBase64 => write!(f, "Unable to decode from base64"),
            Self::DecodeFromUtf8 => write!(f, "Unable to decode from UTF-8"),
            Self::UnknownEncoding(encoding) => write!(f, "Unknown file encoding: {encoding}"),
            Self::ParseContent => write!(f, "Unable to parse file contents"),
            Self::Unknown(status) => write!(f, "Unknown error (status: {status})"),
        }
    }
}

#[derive(Debug)]
pub enum ForgeBranchError {
    NotFound(BranchName),
    NoneFound,
}
impl std::error::Error for ForgeBranchError {}
impl std::fmt::Display for ForgeBranchError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NotFound(branch_name) => write!(f, "Branch not found: {branch_name}"),
            Self::NoneFound => write!(f, "Unable to find any branches"),
        }
    }
}

#[derive(Debug)]
pub enum RepoCloneError {
    InvalidGitDir(GitDir),
    Io(std::io::Error),
    Wait(std::io::Error),
    Spawn(std::io::Error),
    Validation(String),
    GixClone(Box<gix::clone::Error>),
    GixOpen(Box<gix::open::Error>),
    GixFetch(Box<gix::clone::fetch::Error>),
}
impl std::error::Error for RepoCloneError {}
impl std::fmt::Display for RepoCloneError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::InvalidGitDir(gitdir) => write!(f, "Invalid Git dir: {:?}", gitdir),
            Self::Io(err) => write!(f, "IO error: {:?}", err),
            Self::Wait(err) => write!(f, "Waiting for command: {:?}", err),
            Self::Spawn(err) => write!(f, "Spawning comming: {:?}", err),
            Self::Validation(err) => write!(f, "Validation: {}", err),
            Self::GixClone(err) => write!(f, "Clone: {:?}", err),
            Self::GixOpen(err) => write!(f, "Open: {:?}", err),
            Self::GixFetch(err) => write!(f, "Fetch: {:?}", err),
        }
    }
}
impl From<gix::clone::Error> for RepoCloneError {
    fn from(value: gix::clone::Error) -> Self {
        Self::GixClone(Box::new(value))
    }
}
impl From<gix::open::Error> for RepoCloneError {
    fn from(value: gix::open::Error) -> Self {
        Self::GixOpen(Box::new(value))
    }
}
impl From<gix::clone::fetch::Error> for RepoCloneError {
    fn from(value: gix::clone::fetch::Error) -> Self {
        Self::GixFetch(Box::new(value))
    }
}