Enum Node 

pub enum Node {
    Text(String),
    Echo {
        expr: Expr,
        escaped: bool,
    },
    If {
        branches: Vec<Branch>,
        otherwise: Option<Vec<Node>>,
    },
    Foreach {
        subject: Expr,
        binding: String,
        body: Vec<Node>,
    },
    Yield {
        section: String,
        default: Option<Expr>,
    },
    Include(TemplateRef),
    Lang {
        key: String,
        replacements: Vec<(String, Expr)>,
    },
    Route {
        name: String,
        params: Vec<(String, Expr)>,
    },
}

One renderable piece of a template.

Variants

Text(String)

Literal markup.

Echo

{{ expr }} when escaped, {!! expr !!} when not.

Fields

expr: Expr

escaped: bool

If

@if / @elseif / @else: the first branch whose condition is truthy wins, otherwise otherwise runs if there is one.

Fields

branches: Vec<Branch>

otherwise: Option<Vec<Node>>

Foreach

@foreach(subject as binding).

Fields

subject: Expr

binding: String

body: Vec<Node>

Yield

@yield("name"), with the optional fallback from @yield("name", expr).

Fields

section: String

default: Option<Expr>

Include(TemplateRef)

@include("partial").

Lang

@lang("auth.sign_in"), and @lang("greeting", "name", user.name) when the phrase has placeholders.

The key is resolved when the page is rendered, never when the template is parsed. A parsed template is cached and shared between requests, so baking one language’s words into it would serve those words to everybody — see Engine::translator.

Fields

key: String

replacements: Vec<(String, Expr)>

Route

@route("users.show", "id", user.id) — the path of a named route.

Fields

name: String

params: Vec<(String, Expr)>

Trait Implementations

impl Clone for Node

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Node

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Node

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Node