duster/src/renderer/errors.rs

use crate::renderer::walkable::ContextElement;
use std::error;
use std::fmt;

pub enum RenderError<'a> {
    Generic(String),
    /// For when walking is absolutely impossible
    CantWalk {
        segment: String,
        elem: &'a dyn ContextElement,
    },
    /// For when walking fails (example, a missing key on a map)
    WontWalk {
        segment: String,
        elem: &'a dyn ContextElement,
    },
    /// Attempting to render and unrenderable type (for example, an object without any filters)
    CantRender {
        elem: &'a dyn ContextElement,
    },
}

#[derive(Clone)]
pub struct CompileError {
    pub message: String,
}

impl fmt::Display for RenderError<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RenderError::Generic(msg) => write!(f, "{}", msg),
            RenderError::CantWalk { segment, elem } => {
                write!(f, "Tried to walk to {} from {:?}", segment, elem)
            }
            RenderError::WontWalk { segment, elem } => {
                write!(f, "Failed to walk to {} from {:?}", segment, elem)
            }
            RenderError::CantRender { elem } => write!(f, "Cant render {:?}", elem),
        }
    }
}

impl fmt::Debug for RenderError<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RenderError::Generic(msg) => write!(f, "{}", msg),
            RenderError::CantWalk { segment, elem } => {
                write!(f, "Tried to walk to {} from {:?}", segment, elem)
            }
            RenderError::WontWalk { segment, elem } => {
                write!(f, "Failed to walk to {} from {:?}", segment, elem)
            }
            RenderError::CantRender { elem } => write!(f, "Cant render {:?}", elem),
        }
    }
}

impl error::Error for RenderError<'_> {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        None
    }
}

impl fmt::Display for CompileError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Error compiling: {}", self.message)
    }
}

impl fmt::Debug for CompileError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Error compiling: {}", self.message)
    }
}

impl error::Error for CompileError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        None
    }
}