Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    Msg(String),
    SyntaxError(Box<ReportError>),
    RenderingError(Box<ReportError>),
    CircularExtend {
        tpl: String,
        inheritance_chain: Vec<String>,
    },
    CircularInclude {
        tpl: String,
        include_chain: Vec<String>,
    },
    MissingParent {
        current: String,
        parent: String,
    },
    NamespaceNotLoaded {
        tpl: String,
        namespace: String,
    },
    MacroNotFound {
        tpl: String,
        namespace: String,
        name: String,
    },
    TemplateNotFound(String),
    ComponentNotFound(String),
    InvalidArgument {
        expected_type: String,
        actual_type: String,
    },
    MissingArgument {
        arg_name: String,
    },
    Io(ErrorKind),
    Utf8Conversion,
}

All the kind of errors Tera can produce. Non-exhaustive so we can add more if needed without a breaking change.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Msg(String)

Generic error

SyntaxError(Box<ReportError>)

Both lexer and parser errors. Will point to the source file

RenderingError(Box<ReportError>)

An error that happens while rendering a template. Will point to the source file

CircularExtend

A loop was found while looking up the inheritance chain

Fields

tpl: String

Name of the template with the loop

inheritance_chain: Vec<String>

All the parents templates we found so far

CircularInclude

A loop was found while following {% include %} calls between templates

Fields

tpl: String

Name of the template where the cycle was detected

include_chain: Vec<String>

Ordered chain of templates from tpl back to tpl

MissingParent

A template is extending a template that wasn’t found in the Tera instance

Fields

current: String

The template we are currently looking at

parent: String

The missing template

NamespaceNotLoaded

A template is calling a macro namespace that is not loaded

Fields

tpl: String

Name of the template with the issue

namespace: String

The namespace causing problems

MacroNotFound

The template is calling a macro which isn’t found in the namespace

Fields

tpl: String

Name of the template with the issue

namespace: String

The namespace used

name: String

The name of the macro that cannot be found

TemplateNotFound(String)

A template was missing

ComponentNotFound(String)

A component was missing Only raised if you’re trying to render a specific component

InvalidArgument

A filter/test main value was not the expected type

Fields

expected_type: String

actual_type: String

MissingArgument

A function/test/filter was expecting an argument but it wasn’t found

Fields

arg_name: String

Io(ErrorKind)

An IO error occurred

Utf8Conversion

UTF-8 conversion error when converting output to UTF-8

This should not occur unless invalid UTF8 chars are rendered

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl PartialEq for ErrorKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ErrorKind

impl StructuralPartialEq for ErrorKind