upon 0.10.0

A simple, powerful template engine with minimal dependencies and configurable delimiters
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

//! Defines a compiled [`Template`] which is a sequence of [`Instr`] that can be
//! executed by the renderer.

use std::borrow::Cow;

use crate::types::ast;
use crate::types::span::Span;

#[cfg_attr(internal_debug, derive(Debug))]
pub struct Template<'source> {
    pub source: Cow<'source, str>,
    pub instrs: Vec<Instr>,
}

#[cfg_attr(internal_debug, derive(Debug))]
pub enum Instr {
    /// Jump to an instruction
    Jump(usize),

    /// Jump to the instruction if the current expression is true
    JumpIfTrue(usize),

    /// Jump to the instruction if the current expression is false
    JumpIfFalse(usize),

    /// Emit the current expression
    Emit,

    /// Emit raw template
    EmitRaw(Span),

    /// Apply the formatter or function to the current expression and emit.
    ///
    /// The second value is the number of arguments to pop from the stack
    /// excluding the value itself.
    EmitWith(ast::Ident, usize, Span),

    /// Start a loop over the current expression
    LoopStart(ast::LoopVars, Span),

    /// Advance and jump to the start of the loop
    LoopNext(usize),

    /// Push the current expression to the stack as a variable
    WithStart(ast::Ident),

    /// Remove a previously added variable from the stack
    WithEnd,

    /// Render a template
    Include(ast::String),

    /// Render a template with the current expression
    IncludeWith(ast::String),

    /// Lookup a variable and start building an expression
    ExprStartVar(ast::Var),

    /// Start building an expression using a literal
    ExprStartLiteral(ast::Literal),

    /// Start building a list expression
    ExprStartList(Span),

    /// Start building a map expression
    ExprStartMap(Span),

    /// Append an item to the current list expression
    ExprListPush,

    /// Insert an item to the current map expression
    ExprMapInsert(ast::String),

    /// Apply the function using the value and args on the top of the stack.
    ///
    /// The second value is the number of arguments to pop from the stack
    /// excluding the value itself.
    Apply(ast::Ident, usize, Span),
}

#[cfg(not(internal_debug))]
impl std::fmt::Debug for Template<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Template").finish_non_exhaustive()
    }
}