Struct LuaEnvironment 

pub struct LuaEnvironment(/* private fields */);

A wrapper around a minijinja::Environment. This wrapper can be serialized into an mlua::UserData object for use within mlua::Lua.

Methods from Deref<Target = Environment<'static>>

pub fn keep_trailing_newline(&self) -> bool

Returns the value of the trailing newline preservation flag.

pub fn trim_blocks(&self) -> bool

Returns the value of the trim blocks flag.

pub fn lstrip_blocks(&self) -> bool

Returns the value of the lstrip blocks flag.

pub fn templates(&self) -> impl Iterator<Item = (&str, Template<'_, '_>)>

Returns an iterator over the already loaded templates and their names.

Only templates that are already loaded will be returned.

let mut env = Environment::new();
env.add_template("hello.txt", "Hello {{ name }}!").unwrap();
env.add_template("goodbye.txt", "Goodbye {{ name }}!").unwrap();

for (name, tmpl) in env.templates() {
    println!("{}", tmpl.render(context!{ name => "World" }).unwrap());
}

pub fn get_template(&self, name: &str) -> Result<Template<'_, '_>, Error>

Fetches a template by name.

This requires that the template has been loaded with add_template beforehand. If the template was not loaded an error of kind TemplateNotFound is returned. If a loader was added to the engine this can also dynamically load templates.

let mut env = Environment::new();
env.add_template("hello.txt", "Hello {{ name }}!").unwrap();
let tmpl = env.get_template("hello.txt").unwrap();
println!("{}", tmpl.render(context!{ name => "World" }).unwrap());

pub fn template_from_named_str( &self, name: &'source str, source: &'source str, ) -> Result<Template<'_, 'source>, Error>

Loads a template from a string.

In some cases you only need to work with (e.g., render) a template once.

let env = Environment::new();
let tmpl = env.template_from_named_str("template_name", "Hello {{ name }}").unwrap();
let rv = tmpl.render(context! { name => "World" });
println!("{}", rv.unwrap());

pub fn template_from_str( &self, source: &'source str, ) -> Result<Template<'_, 'source>, Error>

Loads a template from a string, with name <string>.

This is a shortcut to template_from_named_str with name set to <string>.

pub fn render_named_str<S>( &self, name: &str, source: &str, ctx: S, ) -> Result<String, Error>

where S: Serialize,

Parses and renders a template from a string in one go with name.

Like render_str, but provide a name for the template to be used instead of the default <string>. This is an alias for template_from_named_str paired with render.

let env = Environment::new();
let rv = env.render_named_str(
    "template_name",
    "Hello {{ name }}",
    context!{ name => "World" }
);
println!("{}", rv.unwrap());

Note on values: The Value type implements Serialize and can be efficiently passed to render. It does not undergo actual serialization.

pub fn render_str<S>(&self, source: &str, ctx: S) -> Result<String, Error>

where S: Serialize,

Parses and renders a template from a string in one go.

In some cases you really only need a template to be rendered once from a string and returned. The internal name of the template is <string>.

This is an alias for template_from_str paired with render.

Note on values: The Value type implements Serialize and can be efficiently passed to render. It does not undergo actual serialization.

pub fn undefined_behavior(&self) -> UndefinedBehavior

Returns the current undefined behavior.

This is particularly useful if a filter function or similar wants to change its behavior with regards to undefined values.

pub fn debug(&self) -> bool

Returns the current value of the debug flag.

pub fn fuel(&self) -> Option<u64>

Returns the configured fuel.

pub fn syntax(&self) -> &SyntaxConfig

Returns the current syntax config.

pub fn recursion_limit(&self) -> usize

Returns the current max recursion limit.

pub fn compile_expression( &self, expr: &'source str, ) -> Result<Expression<'_, 'source>, Error>

Compiles an expression.

This lets you compile an expression in the template language and evaluate it. This makes it possible to use the language’s expressions as a minimal scripting language. For more information and an example see Expression.

pub fn compile_expression_owned<E>( &self, expr: E, ) -> Result<Expression<'_, 'source>, Error>

where E: Into<Cow<'source, str>>,

Compiles an expression without capturing the lifetime.

This works exactly like compile_expression but lets you pass an owned string without capturing the lifetime.

pub fn globals(&self) -> impl Iterator<Item = (&str, Value)>

Returns an iterator of all global variables.

pub fn empty_state(&self) -> State<'_, '_>

Returns an empty State for testing purposes and similar.

Trait Implementations

impl Debug for LuaEnvironment

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

Formats the value using the given formatter.

impl Deref for LuaEnvironment

type Target = Environment<'static>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for LuaEnvironment

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

Formats the value using the given formatter.

impl From<Environment<'static>> for LuaEnvironment

fn from(value: Environment<'static>) -> Self

Converts to this type from the input type.

impl From<LuaEnvironment> for Environment<'static>

fn from(value: LuaEnvironment) -> Self

Converts to this type from the input type.

impl UserData for LuaEnvironment

fn register(registry: &mut UserDataRegistry<Self>)

Registers this type for use in Lua.

fn add_fields<F>(fields: &mut F)

where F: UserDataFields<Self>,

Adds custom fields specific to this userdata.

fn add_methods<M>(methods: &mut M)

where M: UserDataMethods<Self>,

Adds custom methods and operators specific to this userdata.