incrust 0.0.15

Template engine inspired by Jinja2
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

use std::fmt::Debug;

use ::types::abc::{Type};
use ::types::context::{Context};
use ::incrust::Incrust;
use ::template::Template;


pub type LoadResult = Result<String, LoadError>;

#[derive(Debug)]
pub enum LoadError {
    NotFound,
}


pub trait Loader: Debug {
    fn load(&self, name: &str) -> LoadResult;
}


pub type EvalResult = Result<Option<Box<Type>>, EvalError>;

#[derive(Debug)]
pub enum EvalError {
    Input(String),
    Process(String),
}


//pub trait Eval: Debug {
//    fn eval(&self, op: EvalOp, other: Option<Value>, context: &Context, env: &Incrust) -> EvalResult;
//}


#[derive(Debug)]
pub enum CloneError {
    Error
}


pub type FilterResult = Result<Option<String>, FilterError>;

#[derive(Debug)]
pub enum FilterError {
    UnknownFormatter(String),
    Input(String),
    Process(String),
}


pub trait Filter: Debug {
    fn filter(&self, value: Option<String>, context: &Context, env: &Incrust) -> FilterResult;
}


pub type ParseResult = Result<Template, ParseError>;

#[derive(Debug)]
pub enum ParseError {
    Syntax(String),
}


pub type RenderResult = Result<String, RenderError>;

#[derive(Debug)]
pub enum RenderError {
    LoadTemplate(LoadError),
    ParseTemplate(ParseError),
    VariableNotExists(String),
    EvalExpression(EvalError),
    Filter(FilterError),
    FunctionCallException(String),
}

impl From<LoadError>   for RenderError { fn from(err: LoadError)   -> Self { RenderError::LoadTemplate(err) } }
impl From<EvalError>   for RenderError { fn from(err: EvalError)   -> Self { RenderError::EvalExpression(err) } }
impl From<ParseError>  for RenderError { fn from(err: ParseError)  -> Self { RenderError::ParseTemplate(err) } }
impl From<FilterError> for RenderError { fn from(err: FilterError) -> Self { RenderError::Filter(err) } }

impl From<CloneError>  for EvalError   { fn from(err: CloneError)  -> Self { EvalError::Input(format!("{:?}", err)) } }