rshtml_core 0.6.1

RsHtml: A Template Engine for Seamless HTML and Rust Integration.
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

use super::{
    Input,
    utils::{escape_or_raw, get_struct_field},
};
use crate::{diagnostic::Diagnostic, position::Position};
use proc_macro2::TokenStream;
use quote::quote;
use syn::{Expr, parse_str};
use winnow::{
    ModalResult, Parser,
    combinator::{alt, opt, repeat},
    error::{AddContext, ContextError, ErrMode, StrContext, StrContextValue},
    stream::Stream,
    token::any,
};

pub fn simple_expr_paren<'a, 'ctx>(
    input: &mut Input<'a, 'ctx>,
) -> ModalResult<(TokenStream, TokenStream)> {
    let start = input.input;
    let checkpoint = input.checkpoint();

    let position: Position = (
        input.state.source,
        input.state.source.len().saturating_sub(input.input.len()),
    )
        .into();

    let message = Diagnostic(input.state.source).message(
        input.state.path,
        &position,
        "attempt to use an expression that does not implement the Display trait.",
        "this expression does not implement the Display trait.",
        1,
    );

    let is_escaped = (
        opt('#'),
        '(',
        repeat(
            0..,
            alt((nested_expression, any.verify(|c| *c != ')').void())),
        )
        .fold(|| (), |_, _| ()),
        ')',
    )
        .map(|(is_not_escaped_opt, _, _, _)| is_not_escaped_opt.is_none())
        .parse_next(input)?;

    let consumed = start.len() - input.len();
    let raw_expr = &start[..consumed];

    let start_offset = if is_escaped { 1 } else { 2 };
    let end_offset = raw_expr.len() - 1;
    let expr = &raw_expr[start_offset..end_offset];

    let expression = parse_str::<Expr>(expr).map_err(|_| {
        input.reset(&checkpoint);

        ErrMode::Cut(ContextError::new().add_context(
            input,
            &checkpoint,
            StrContext::Expected(StrContextValue::Description("invalid expression")),
        ))
    })?;

    if let Some(field) = get_struct_field(expr)
        && !input.state.struct_fields.contains(&field)
    {
        input.reset(&checkpoint);

        return Err(ErrMode::Cut(ContextError::new().add_context(
            input,
            &checkpoint,
            StrContext::Expected(StrContextValue::Description(
                "attempt to use undefined struct field",
            )),
        )));
    }

    let expr_ts = escape_or_raw(quote!(#expression), is_escaped, &message);

    Ok((quote! {#expression}, expr_ts))
}

fn nested_expression<'a, 'ctx>(input: &mut Input<'a, 'ctx>) -> ModalResult<()> {
    alt((
        (
            '(',
            repeat(
                0..,
                alt((nested_expression, any.verify(|c| *c != ')').void())),
            )
            .fold(|| (), |_, _| ()),
            ')',
        ),
        (
            '[',
            repeat(
                0..,
                alt((nested_expression, any.verify(|c| *c != ']').void())),
            )
            .fold(|| (), |_, _| ()),
            ']',
        ),
        (
            '{',
            repeat(
                0..,
                alt((nested_expression, any.verify(|c| *c != '}').void())),
            )
            .fold(|| (), |_, _| ()),
            '}',
        ),
    ))
    .void()
    .parse_next(input)
}