1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::fmt::Display;

use crate::ast::{InvalidAttributeName, InvalidAttributeValue, InvalidBlockName, InvalidRaw};
use crate::parser::ParseError;

#[derive(Debug)]
enum ErrorKind {
    Parse(ParseError),
    InvalidBlockName(InvalidBlockName),
    InvalidAttributeName(InvalidAttributeName),
    InvalidAttributeValue(InvalidAttributeValue),
    InvalidRaw(InvalidRaw),
}

/// A generic error.
///
/// This error is less specific than others in the crate, but they can all be converted to this
/// error.
#[derive(Debug)]
pub struct Error(ErrorKind);

impl Error {
    fn get_ref(&self) -> &(dyn std::error::Error + 'static) {
        let Self(inner) = self;

        match inner {
            ErrorKind::Parse(err) => err,
            ErrorKind::InvalidBlockName(err) => err,
            ErrorKind::InvalidAttributeName(err) => err,
            ErrorKind::InvalidAttributeValue(err) => err,
            ErrorKind::InvalidRaw(err) => err,
        }
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.get_ref(), f)
    }
}

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

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

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

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

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

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