polly 0.1.2

A templating language for Rust.
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

use std::fmt;
use std::fmt::{Display, Formatter};
use std::error;

use super::{ComponentCall, Element, FunctionCall, Lexeme};
use self::AstError::*;

/// TODO
#[derive(Debug, PartialEq, Clone)]
pub enum Token {
    /// TODO
    Html(Element),
    /// TODO
    Text(String),
    /// TODO
    Variable(String),
    /// TODO
    CompCall(ComponentCall),
    /// TODO
    Function(FunctionCall),
}

/// Errors defining all the errors that can be encountered while parsing.
#[derive(Debug, PartialEq, Clone)]
pub enum AstError {
    /// End of File
    Eof,
    /// Expected a Component name.
    ExpectedCompCall(Lexeme),
    /// Expected a Variable name.
    ExpectedVariable(Lexeme),
    /// No name attached to component.
    InvalidComponent(Lexeme),
    /// No name attached to element.
    InvalidElement(Lexeme),
    /// No name attached to function.
    InvalidFunctionCall(Lexeme),
    /// Token that isn't (, ), =, ", ', or a word. 
    InvalidTokenInAttributes(Lexeme),
    /// Having a . without anything following it up.
    NoNameAttachedToClass(Lexeme),
    /// Having a # without anything following it up.
    NoNameAttachedToId(Lexeme),
    /// Extra } braces
    UnclosedCloseBraces(usize),
    /// Extra { braces
    UnclosedOpenBraces(usize),
    /// File ended while we tried to parse element.
    UnexpectedEof(Lexeme),
    /// Unknown token
    UnexpectedToken(Lexeme),
}

impl AstError {
    /// The length of a token, for error printing.
    pub fn values(&self) -> (usize, usize) {
        match *self {
            Eof => (0, 0),
            ExpectedCompCall(ref lexeme) |
            ExpectedVariable(ref lexeme) |
            InvalidComponent(ref lexeme) |
            InvalidElement(ref lexeme) |
            InvalidFunctionCall(ref lexeme) |
            InvalidTokenInAttributes(ref lexeme) |
            NoNameAttachedToClass(ref lexeme) |
            NoNameAttachedToId(ref lexeme) |
            UnexpectedEof(ref lexeme) |
            UnexpectedToken(ref lexeme) => (lexeme.index(), lexeme.length()),
            UnclosedCloseBraces(index) | UnclosedOpenBraces(index) => (index, 1),
        }
    }
}

impl error::Error for AstError {
    fn description(&self) -> &str {
        match *self {
            Eof => "The file ended normally.",
            ExpectedCompCall(_) | InvalidComponent(_) => "Component names can only be words.",
            ExpectedVariable(_) => "Variable names can only be words.",
            InvalidElement(_) => "Element names can only be words.",
            InvalidFunctionCall(_) => "Function names can only be words.",
            InvalidTokenInAttributes(_) => {
                "Attributes fields only accept words as single value, or as key-value word pairs, \
                 or a \") which ends the attributes.\""
            }
            NoNameAttachedToClass(_) => "Class names can only be words.",
            NoNameAttachedToId(_) => "Id names can only be words.",
            UnclosedCloseBraces(_) => "You have an extra closing brace.",
            UnclosedOpenBraces(_) => "You have an extra open brace.",
            UnexpectedEof(_) => "File ended before an element is finished being parsed",
            UnexpectedToken(_) => "Unknown token in use.",
        }
    }
}


impl Display for AstError {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        use std::error::Error;
        let lexeme = match *self {
            Eof => return write!(f, "{}", self.description()),
            ExpectedCompCall(ref lexeme) |
            ExpectedVariable(ref lexeme) |
            InvalidComponent(ref lexeme) |
            InvalidElement(ref lexeme) |
            InvalidFunctionCall(ref lexeme) |
            InvalidTokenInAttributes(ref lexeme) |
            NoNameAttachedToClass(ref lexeme) |
            NoNameAttachedToId(ref lexeme) |
            UnexpectedEof(ref lexeme) |
            UnexpectedToken(ref lexeme) => lexeme,
            UnclosedCloseBraces(_) | UnclosedOpenBraces(_) => {
                return write!(f, "{}", self.description())
            }

        };
        write!(f, "{}, Got: {}", self.description(), lexeme)
    }
}