temple 0.0.0

WIP
Documentation 
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::error;
use std::fmt;
use std::io;

#[derive(Debug)]
pub enum Error {
    Io(io::Error),
    ParseRender(ErrorKind),
}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ErrorKind {
    Unspecified,
    YetUnsupported,
    FileNotFound,
    ExtensionDisabled,
    TemplateEnvAbsent,
    TemplateNotFound,
    TemplateNotParsed,
    InvalidValueType,
    InvalidTemplateName,
    ExpectedStringLiteral(SourceLocation),
    ExpectedIdentifier(SourceLocation),
    ExpectedSquareBracket(SourceLocation),
    ExpectedRoundBracket(SourceLocation),
    ExpectedCurlyBracket(SourceLocation),
    ExpectedToken(SourceLocation),
    ExpectedExpression(SourceLocation),
    ExpectedEndOfStatement(SourceLocation),
    ExpectedRawEnd(SourceLocation),
    UnexpectedToken(SourceLocation),
    UnexpectedStatement(SourceLocation),
    UnexpectedCommentBegin(SourceLocation),
    UnexpectedCommentEnd(SourceLocation),
    UnexpectedExprBegin(SourceLocation),
    UnexpectedExprEnd(SourceLocation),
    UnexpectedStmtBegin(SourceLocation),
    UnexpectedStmtEnd(SourceLocation),
    UnexpectedRawBegin(SourceLocation),
    UnexpectedRawEnd(SourceLocation),
}

impl ErrorKind {
    fn as_str(&self) -> &str {
        match &*self {
            ErrorKind::Unspecified => "Unspecified error",
            ErrorKind::YetUnsupported => "Jinja feature not yet supported ",
            ErrorKind::FileNotFound => "File not found",
            ErrorKind::ExtensionDisabled => "Extension disabled ",
            ErrorKind::TemplateEnvAbsent => "Expected template environment",
            ErrorKind::TemplateNotFound => "Template not found",
            ErrorKind::TemplateNotParsed => "Template not parsed",
            ErrorKind::InvalidValueType => "Invalid type of the value in the particular context",
            ErrorKind::InvalidTemplateName => "Invalid name of the template",
            //           ErrorKind::MetadataParseError => "Metadata Parse Error ", // TODO: Solve in jinja2cpp
            ErrorKind::ExpectedStringLiteral(_location) => "String literal expected",
            ErrorKind::ExpectedIdentifier(_location) => "Identifier expected",
            ErrorKind::ExpectedSquareBracket(_location) => "']' expected",
            ErrorKind::ExpectedRoundBracket(_location) => "')' expected",
            ErrorKind::ExpectedCurlyBracket(_location) => "'}}' expected",
            ErrorKind::ExpectedToken(_location) => "Specific token(s) expected",
            ErrorKind::ExpectedExpression(_location) => "Expression expected",
            ErrorKind::ExpectedEndOfStatement(_location) => "End of statement expected",
            ErrorKind::ExpectedRawEnd(_location) => "{{% endraw %}} expected",
            ErrorKind::UnexpectedToken(_location) => "Unexpected token",
            ErrorKind::UnexpectedStatement(_location) => "Unexpected statement",
            ErrorKind::UnexpectedCommentBegin(_location) => {
                "Unexpected comment block begin ('{{#')"
            }
            ErrorKind::UnexpectedCommentEnd(_location) => "Unexpected comment block end ('#}}')",
            ErrorKind::UnexpectedExprBegin(_location) => {
                "Unexpected expression block begin ('{{{{}}')"
            }
            ErrorKind::UnexpectedExprEnd(_location) => "Unexpected expression block end ('}}}}')",
            ErrorKind::UnexpectedStmtBegin(_location) => "Unexpected statement block begin ('{{%')",
            ErrorKind::UnexpectedStmtEnd(_location) => "Unexpected statement block end ('%}}')",
            ErrorKind::UnexpectedRawBegin(_location) => "Unexpected raw block begin {{% raw %}}",
            ErrorKind::UnexpectedRawEnd(_location) => "Unexpected raw block end {{% endraw %}}",
        }
    }
}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SourceLocation {
    /// Line number (1-based)
    line: usize,
    /// Column number (1-based)
    col: usize,
}

impl SourceLocation {
    pub fn new(line: usize, col: usize) -> Self {
        Self { line, col }
    }
}
impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::Io(ref err) => err.fmt(f),
            Error::ParseRender(ref err) => write!(f, "{:?}", err),
        }
    }
}
impl error::Error for ErrorKind {}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match *self {
            Error::Io(ref err) => err.source(),
            Error::ParseRender(ref err) => Some(err),
        }
    }
}

impl fmt::Display for ErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

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

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

pub type Result<T> = std::result::Result<T, Error>;