femstache 0.1.5

Embrace the feminine mustache to unlock your templating dreams! Or something, I don't know. :3
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

use femstache_parser::nodes::{Access, BinOp, Expr, ExprValue, Literal};

use crate::{
    TemplateInput,
    env::TemplateEnv,
    error::{EvalError, EvalResult},
    value::Value,
};

pub fn eval_expr<'i, I: TemplateInput>(env: &TemplateEnv<'i, I>, expr: &Expr) -> EvalResult<Value> {
    match expr {
        Expr::Value(v) => match v {
            ExprValue::Ident(ident) => env
                .get(&ident.data)
                .ok_or_else(|| EvalError::VariableNotFound(ident.clone())),
            ExprValue::Literal(literal) => Ok(match literal {
                Literal::Null(_) => Value::Null,
                Literal::True(_) => Value::Bool(true),
                Literal::False(_) => Value::Bool(false),
                Literal::String(s) => Value::String(s.as_str().to_owned()),
                Literal::List(l) => {
                    let mut items = Vec::new();
                    for item in &l.items {
                        let value = eval_expr(env, &item)?;
                        items.push(value);
                    }
                    Value::List(items)
                }
            }),
            ExprValue::Group(group) => {
                let r = eval_expr(env, &group.expr)?;
                Ok(r)
            }
        },
        Expr::Access(st, Access::Member(ma)) => {
            let st = eval_expr(env, st)?;
            let Some(fields) = st.as_struct() else {
                return Err(EvalError::InvalidType);
            };
            let Some(field) = fields.get(&ma.ident.data) else {
                return Err(EvalError::NoMember(ma.ident.clone()));
            };
            Ok(field.clone())
        }
        Expr::Access(st, Access::Dict(da)) => {
            let st = eval_expr(env, st)?;
            let key = eval_expr(env, &da.expr)?;
            let Some(map) = st.as_dict() else {
                return Err(EvalError::InvalidType);
            };
            let Some(key_str) = key.as_str() else {
                return Err(EvalError::InvalidType);
            };
            let Some(field) = map.get(key_str) else {
                return Err(EvalError::NoDictKey(key_str.to_owned()));
            };
            Ok(field.clone())
        }
        Expr::BinOp(lhs, binop, rhs) => {
            let lhs = eval_expr(env, lhs)?;
            match binop {
                BinOp::Eq(_) => {
                    let rhs = eval_expr(env, rhs)?;
                    Ok(Value::Bool(lhs == rhs))
                }
                BinOp::Neq(_) => {
                    let rhs = eval_expr(env, rhs)?;
                    Ok(Value::Bool(lhs != rhs))
                }
                BinOp::PlusPlus(_) => {
                    let rhs = eval_expr(env, rhs)?;
                    let Some(ls) = lhs.as_str() else {
                        return Err(EvalError::InvalidType);
                    };
                    let Some(rs) = rhs.as_str() else {
                        return Err(EvalError::InvalidType);
                    };
                    let mut full = String::with_capacity(ls.len() + rs.len());
                    full.push_str(ls);
                    full.push_str(rs);
                    Ok(Value::String(full))
                }
            }
        }
    }
}