MiniJinja

https://docs.rs/minijinja/latest/minijinja/
Admin
MiniJinja is a powerful Rust template engine based on Jinja2 syntax with minimal dependencies,...
Tokens:80,462
Snippets:967
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### is_startingwith usage examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_startingwith.html

Examples of using the is_startingwith test within a template.

```jinja2
{{ "foobar" is startingwith "foo" }} -> true
{{ "foobar" is startingwith "bar" }} -> false
```

--------------------------------

### Jinja2 Template Syntax Example

Source: https://docs.rs/minijinja/latest/minijinja/index.html

A basic example of a Jinja2-style loop for rendering a list of users.

```jinja2
{% for user in users %}
  <li>{{ user.name }}</li>
{% endfor %}
```

--------------------------------

### Mathematical Expression Examples

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Examples of basic arithmetic operations supported within template expressions.

```jinja2
{{ 1 + 1 }}
```

```jinja2
{{ 3 - 2 }}
```

```jinja2
{{ 1 / 2 }}
```

```jinja2
{{ 5 // 3 }}
```

```jinja2
{{ 11 % 7 }}
```

```jinja2
{{ 2 * 2 }}
```

```jinja2
{{ 2**3 }}
```

--------------------------------

### Jinja2 is_sameas Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_sameas.html

Examples demonstrating the strict comparison behavior of is_sameas in templates.

```jinja2
{{ [1, 2, 3] is sameas [1, 2, 3] }}
    -> false

{{ false is sameas false }}
    -> true
```

--------------------------------

### is_startingwith

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_startingwith.html

Checks if the value is starting with a string.

```APIDOC
## is_startingwith

### Description
Checks if the provided string value starts with the specified prefix string.

### Signature
`pub fn is_startingwith(v: Cow<'_, str>, other: Cow<'_, str>) -> bool`

### Requirements
- Available on crate feature `builtins` only.

### Usage Example
```jinja
{{ "foobar" is startingwith "foo" }} -> true
{{ "foobar" is startingwith "bar" }} -> false
```
```

--------------------------------

### Split string examples

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.split.html

Demonstrates splitting a string by whitespace and by a specific comma separator.

```jinja2
{{ "hello world"|split|list }}
    -> ["hello", "world"]
```

```jinja2
{{ "c,s,v"|split(",")|list }}
    -> ["c", "s", "v"]
```

--------------------------------

### is_number usage examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_number.html

Examples demonstrating the behavior of the is_number test in Jinja templates.

```jinja
{{ 42 is number }} -> true
{{ "42" is number }} -> false
```

--------------------------------

### Template Render Output

Source: https://docs.rs/minijinja/latest/minijinja/index.html

The expected output from the template rendering example.

```text
Hello John!
```

--------------------------------

### select filter usage examples

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.select.html

Examples of using the select filter in templates with a test name or as a boolean filter.

```jinja2
{{ [1, 2, 3, 4]|select("odd") }} -> [1, 3]
{{ [false, null, 42]|select }} -> [42]
```

--------------------------------

### is_gt Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_gt.html

Examples showing the usage of is_gt as a test and within a select filter.

```jinja2
{{ 2 is gt 1 }} -> true
{{ [1, 2, 3]|select(">", 2) }} => [3]
```

--------------------------------

### Minimal MiniJinja Template Example

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

A basic template structure demonstrating blocks, loops, variable output, and comments.

```jinja2
<!doctype html>
<title>{% block title %}My Website{% endblock %}</title>
<ul id="navigation">
{% for item in navigation %}
    <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
{% endfor %}
</ul>

<h1>My Webpage</h1>
{% block body %}{% endblock %}

{# a comment #}
```

--------------------------------

### Partitioning a slice

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Examples demonstrating how to use partition_point to find the split index in a slice or maintain sorted order in a vector.

```rust
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);
```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### length filter usage example

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.length.html

Example of using the length filter in a template.

```jinja2
<p>Search results: {{ results|length }}
```

--------------------------------

### Sorting lists in MiniJinja templates

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.sort.html

Examples demonstrating basic sorting, reverse sorting, and attribute-based sorting for complex objects.

```jinja2
{{ [1, 3, 2, 4]|sort }} -> [4, 3, 2, 1]
{{ [1, 3, 2, 4]|sort(reverse=true) }} -> [1, 2, 3, 4]
# Sort users by age attribute in descending order.
{{ users|sort(attribute="age") }}
# Sort users by age attribute in ascending order.
{{ users|sort(attribute="age", reverse=true) }}
# Sort cities by their name, and sort those with the same name by their state.
{{ cities|sort(attribute="name, state") }}
```

--------------------------------

### is_le Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_le.html

Demonstrates the usage of the is le test and the select filter with the less-than-or-equal-to operator.

```jinja2
{{ 1 is le 2 }} -> true
{{ [1, 2, 3]|select("<=", 2) }} => [1, 2]
```

--------------------------------

### is_iterable Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_iterable.html

Demonstrates the behavior of the is_iterable test with different input types.

```jinja2
{{ [1, 2, 3] is iterable }} -> true
{{ 42 is iterable }} -> false
```

--------------------------------

### is_ge Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_ge.html

Demonstrates the use of the ge test for direct comparison and within a select filter.

```jinja2
{{ 2 is ge 1 }} -> true
{{ [1, 2, 3]|select(">=", 2) }} => [2, 3]
```

--------------------------------

### Zip filter usage examples

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.zip.html

Examples of using the zip filter in templates to combine lists.

```jinja2
{{ [1, 2, 3]|zip(['a', 'b', 'c']) }}
-> [(1, 'a'), (2, 'b'), (3, 'c')]

{{ [1, 2]|zip(['a', 'b', 'c'], ['x', 'y', 'z']) }}
-> [(1, 'a', 'x'), (2, 'b', 'y')]
```

--------------------------------

### Using the chain filter in templates

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.chain.html

Examples of chaining users, dictionary shards, and lists within Minijinja templates.

```jinja2
{{ users | chain(moreusers) | length }}
{% for user, info in shard0 | chain(shard1, shard2) | dictsort %}
  {{user}}: {{info}}
{% endfor %}
{{ list1 | chain(list2) | attr(1) }}
```

--------------------------------

### Using rejectattr in templates

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.rejectattr.html

Examples showing how to filter sequences by checking boolean attributes or applying specific tests to attributes.

```jinja2
{{ users|rejectattr("is_active") }} -> all users where x.is_active is false
{{ users|rejectattr("id", "even") }} -> returns all users with an odd id
```

--------------------------------

### Usage of args! macro

Source: https://docs.rs/minijinja/latest/minijinja/macro.args.html

Example of passing positional and keyword arguments to a function call using the args! macro.

```rust
value.call(state, args!(1, 2, foo => "bar"));
```

--------------------------------

### is_none Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_none.html

Example of using the is_none check within a template.

```jinja2
{{ none is none }} -> true
```

--------------------------------

### Float filter usage example

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.float.html

Demonstrates converting a string representation of a number into a float.

```jinja2
{{ "42.5"|float == 42.5 }} -> true
```

--------------------------------

### is_true Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_true.html

Example of using the is_true test within a Jinja template.

```jinja
{% if value is true %}...{% endif %}
```

--------------------------------

### Usage of is test in Jinja templates

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_test.html

Example showing how to check for the existence of a test within a template.

```jinja2
{% if 'greaterthan' is test %}...{% endif %}
```

--------------------------------

### Using indent with keyword arguments

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.indent.html

Example of applying the indent filter using keyword arguments for better readability and compatibility.

```jinja2
{{ global_config|indent(width=4, first=true, blank=false) }}
```

--------------------------------

### is_sequence Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_sequence.html

Examples of using the is sequence test within a Jinja template.

```jinja
{{ [1, 2, 3] is sequence }} -> true
{{ 42 is sequence }} -> false
```

--------------------------------

### LaTeX Template with Custom Delimiters

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Example template structure using the custom LaTeX-style delimiters defined in the configuration.

```jinja
\begin{itemize}
\BLOCK{for item in sequence}
  \item \VAR{item}
\BLOCK{endfor}
\end{itemize}
```

--------------------------------

### is_in Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_in.html

Demonstrates the use of is_in as a test and within a select filter.

```jinja2
{{ 1 is in [1, 2, 3] }} -> true
{{ [1, 2, 3]|select("in", [1, 2]) }} => [1, 2]
```

--------------------------------

### Using slice in a template

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.slice.html

Example of using the slice filter to partition items into columns within a template.

```jinja2
<div class="columnwrapper">
{% for column in items|slice(3) %}
  <ul class="column-{{ loop.index }}">
  {% for item in column %}
    <li>{{ item }}</li>
  {% endfor %}
  </ul>
{% endfor %}
</div>
```

--------------------------------

### Implementing a Dynamic Struct

Source: https://docs.rs/minijinja/latest/minijinja/value/trait.Object.html

Example implementation of a dynamic object representing a struct, requiring get_value and enumerate methods.

```rust
use std::sync::Arc;
use minijinja::value::{Value, Object, Enumerator};

#[derive(Debug)]
struct Point(f32, f32, f32);

impl Object for Point {
    fn get_value(self: &Arc<Self>, key: &Value) -> Option<Value> {
        match key.as_str()? {
            "x" => Some(Value::from(self.0)),
            "y" => Some(Value::from(self.1)),
            "z" => Some(Value::from(self.2)),
            _ => None,
        }
    }

    fn enumerate(self: &Arc<Self>) -> Enumerator {
        Enumerator::Str(&["x", "y", "z"])
    }
}

let value = Value::from_object(Point(1.0, 2.5, 3.0));
```

--------------------------------

### is_eq Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_eq.html

Examples of using the is_eq test within Jinja templates.

```jinja
{{ 1 is eq 1 }} -> true
{{ [1, 2, 3]|select("==", 1) }} => [1]
```

--------------------------------

### is_mapping Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_mapping.html

Examples of using the is_mapping test within a Jinja template.

```jinja
{{ {"foo": "bar"} is mapping }} -> true
{{ [1, 2, 3] is mapping }} -> false
```

--------------------------------

### is_false Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_false.html

Example of using the is_false test within a Jinja2 template.

```jinja2
{% if value is false %}...{% endif %}
```

--------------------------------

### Basic Usage of tojson in Templates

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.tojson.html

Examples of using the tojson filter within HTML script tags and attributes.

```jinja2
<script>
  const GLOBAL_CONFIG = {{ global_config|tojson }};
</script>
<a href="#" data-info='{{ json_object|tojson }}'>...</a>
```

--------------------------------

### is_lt Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_lt.html

Demonstrates the use of the is_lt test in template expressions and its application with the select filter.

```jinja2
{{ 1 is lt 2 }} -> true
{{ [1, 2, 3]|select("<", 2) }} => [1]
```

--------------------------------

### is_divisibleby Usage Example

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_divisibleby.html

Example usage of the is_divisibleby test within a template.

```jinja2
{{ 42 is divisibleby(2) }} -> true
```

--------------------------------

### Rendering Templates with Environment

Source: https://docs.rs/minijinja/latest/minijinja/index.html

Demonstrates creating an Environment, adding a template, and rendering it using the context! macro.

```rust
use minijinja::{Environment, context};

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

--------------------------------

### is_ne Usage Examples

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_ne.html

Demonstrates the use of the is_ne test and its equivalent operator within Jinja templates.

```jinja2
{{ 2 is ne 1 }} -> true
{{ [1, 2, 3]|select("!=", 1) }} => [2, 3]
```

--------------------------------

### Slice lists or strings

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Use bracket notation with start, stop, and step indices to slice sequences.

```jinja
"Hello World"[:5]
```

```jinja
"Hello"[1:-1]
```

```jinja
"12345"[::2]
```

--------------------------------

### Template Whitespace with trim_blocks and lstrip_blocks

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Example of a template rendered with both trim_blocks and lstrip_blocks enabled, removing block lines.

```jinja
<div>
    yay
</div>
```

--------------------------------

### Using indent with positional arguments

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.indent.html

Examples of applying the indent filter using positional arguments to control indentation behavior.

```jinja2
example:
  config:
{{ global_config|indent(2) }}          # does not indent first line
{{ global_config|indent(2,true) }}     # indent whole Value with two spaces
{{ global_config|indent(2,true,true)}} # indent whole Value and all blank lines
```

--------------------------------

### Environment::new

Source: https://docs.rs/minijinja/latest/minijinja/struct.Environment.html

Creates a new environment preconfigured with sensible defaults, including built-in filters, tests, and globals.

```APIDOC
## pub fn new() -> Environment<'source>

### Description
Creates a new environment with sensible defaults. This environment does not yet contain any templates but it will have all the default filters, tests and globals loaded.
```

--------------------------------

### Create and use a namespace

Source: https://docs.rs/minijinja/latest/minijinja/functions/fn.namespace.html

Initializes a namespace and assigns a value to it using the set tag.

```jinja2
{% set ns = namespace() %}
{% set ns.foo = 'bar' %}
```

--------------------------------

### Using range in a template

Source: https://docs.rs/minijinja/latest/minijinja/functions/fn.range.html

Example of using the range function within a Jinja2 template to generate a list of items.

```jinja2
<ul>
{% for num in range(1, 11) %}
  <li>{{ num }}
{% endfor %}
</ul>
```

--------------------------------

### Retrieve Keyword Arguments

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Kwargs.html

Demonstrates how to retrieve optional and required keyword arguments from a Kwargs instance using the get method.

```rust
// f(int=42) -> Some(42)
// f() -> None
let optional_int: Option<u32> = kwargs.get("int")?;
// f(int=42) -> 42
// f() -> Error
let required_int: u32 = kwargs.get("int")?;
```

--------------------------------

### Create a basic context

Source: https://docs.rs/minijinja/latest/minijinja/macro.context.html

Initialize a context with explicit key-value pairs.

```rust
let ctx = context!{
    name => "Peter",
    location => "World",
};
```

--------------------------------

### path_loader<P: AsRef<Path>>(dir: P)

Source: https://docs.rs/minijinja/latest/minijinja/fn.path_loader.html

Creates a loader that looks up templates in the provided directory. Templates starting with a dot or located in hidden directories are restricted.

```APIDOC
## path_loader

### Description
Helper to load templates from a given directory. This creates a dynamic loader which looks up templates in the given directory. Templates that start with a dot (.) or are contained in a folder starting with a dot cannot be loaded.

### Signature
`pub fn path_loader<'x, P: AsRef<Path> + 'x>(dir: P) -> impl for<'a> Fn(&'a str) -> Result<Option<String>, Error> + Send + Sync + 'static`

### Parameters
- **dir** (P: AsRef<Path>) - Required - The directory path from which to load templates.

### Example
```rust
fn create_env() -> Environment<'static> {
    let mut env = Environment::new();
    env.set_loader(path_loader("path/to/templates"));
    env
}
```
```

--------------------------------

### args!

Source: https://docs.rs/minijinja/latest/minijinja/macro.args.html

The args macro creates a slice of values that can be passed to various MiniJinja execution APIs. It supports positional arguments and keyword arguments.

```APIDOC
## args!

### Description
Creates a slice of values on the stack for use in function calls, filters, or tests. It supports both positional arguments and keyword arguments (using `name => value` syntax).

### Usage
```rust
value.call(state, args!(1, 2, foo => "bar"));
```

### Parameters
- **...args** (tt) - A comma-separated list of values or keyword pairs (name => value) to be converted into a slice of `Value` objects.
```

--------------------------------

### items filter usage example

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.items.html

Example of using the items filter within a Jinja template to iterate over dictionary entries.

```jinja2
<dl>
{% for key, value in my_dict|items %}
  <dt>{{ key }}
  <dd>{{ value }}
{% endfor %}
</dl>
```

--------------------------------

### Default Template Whitespace Behavior

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Example of a template rendered without trim_blocks or lstrip_blocks, resulting in preserved blank lines.

```jinja
<div>
  {% if True %}
    yay
  {% endif %}
</div>
```

```text
<div>

    yay

</div>
```

--------------------------------

### Initialize Vec via as_non_null

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Demonstrates manual initialization using the nightly-only as_non_null API.

```rust
#![feature(box_vec_non_null)]

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_non_null();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

--------------------------------

### Create an Environment with path_loader

Source: https://docs.rs/minijinja/latest/minijinja/fn.path_loader.html

Configures a MiniJinja environment to use a specific directory for template loading.

```rust
fn create_env() -> Environment<'static> {
    let mut env = Environment::new();
    env.set_loader(path_loader("path/to/templates"));
    env
}
```

--------------------------------

### Get slice length

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Get Item by Index

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Value.html

Retrieves an item from a sequence by its index.

```rust
let seq = Value::from(vec![0u32, 1, 2]);
let value = seq.get_item_by_index(1).unwrap();
assert_eq!(value.try_into().ok(), Some(1));
```

--------------------------------

### Implement a function using Kwargs

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Kwargs.html

Demonstrates how to use Kwargs to fetch optional parameters and validate that all provided keyword arguments were consumed.

```rust
use minijinja::value::{Value, Kwargs};
use minijinja::Error;

fn modify(mut values: Vec<Value>, options: Kwargs) -> Result<Vec<Value>, Error> {
    // get pulls a parameter of any type.  Same as from_args.  For optional
    // boolean values the type inference is particularly convenient.
    if let Some(true) = options.get("reverse")? {
        values.reverse();
    }
    if let Some(limit) = options.get("limit")? {
        values.truncate(limit);
    }
    options.assert_all_used()?;
    Ok(values)
}
```

--------------------------------

### first filter usage in template

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.first.html

Example of using the first filter within a Jinja template to retrieve an email address.

```html
<dl>
  <dt>primary email
  <dd>{{ user.email_addresses|first|default('no user') }}
</dl>
```

--------------------------------

### is_upper template usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_upper.html

Example of using the is_upper test within a template.

```jinja2
{{ 'FOO' is upper }} -> true
```

--------------------------------

### Template Using Line Statements and Comments

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Demonstrates the use of line-based syntax within a template.

```jinja
## This block is
## completely removed
<ul>
  # for item in [1, 2]
    ## this is a comment that is also removed including leading whitespace
    <li>{{ item }}
  # endfor
</ul>
```

--------------------------------

### Check if a value is odd

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_odd.html

Usage example for the is_odd test within a template.

```jinja2
{{ 41 is odd }} -> true
```

--------------------------------

### Apply str.format style formatting

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.format.html

Uses Python-style str.format() syntax, available through the minijinja-contrib crate.

```jinja2
{{ "{}, {name}!".format(greeting, name="Alice") }}
-> Hello, Alice!
```

--------------------------------

### is_boolean Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_boolean.html

Example of using the boolean test within a template.

```jinja2
{{ true is boolean }} -> true
```

--------------------------------

### Define and call macros

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Create reusable template functions with macros and invoke them like standard functions.

```jinja
{% macro input(name, value="", type="text") -%}
<input type="{{ type }}" name="{{ name }}" value="{{ value }}">
{%- endmacro %}
```

```jinja
<p>{{ input('username') }}</p>
<p>{{ input('password', type='password') }}</p>
```

--------------------------------

### Get last element

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns the last element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Get first element

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns the first element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Initialize Vec via as_mut_ptr

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Demonstrates manual initialization of a vector's buffer using a raw mutable pointer.

```rust
// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_mut_ptr();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        *x_ptr.add(i) = i as i32;
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

--------------------------------

### is_string Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_string.html

Examples of using the is_string test within a Jinja template.

```jinja
{{ "42" is string }} -> true
{{ 42 is string }} -> false
```

--------------------------------

### Environment::add_template

Source: https://docs.rs/minijinja/latest/minijinja/struct.Environment.html

Loads a template from a string into the environment.

```APIDOC
## pub fn add_template(&mut self, name: &'source str, source: &'source str) -> Result<(), Error>

### Description
Loads a template from a string into the environment. The name parameter defines the name of the template which identifies it.
```

--------------------------------

### is_lower template usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_lower.html

Example of using the is_lower test within a Jinja template.

```jinja
{{ 'foo' is lower }} -> true
```

--------------------------------

### Defining and Registering Custom Tests

Source: https://docs.rs/minijinja/latest/minijinja/tests/index.html

Shows how to implement a custom test function in Rust and register it with the MiniJinja environment.

```rust
fn is_lowercase(value: String) -> bool {
    value.chars().all(|x| x.is_lowercase())
}

env.add_test("lowercase", is_lowercase);
```

--------------------------------

### get_template

Source: https://docs.rs/minijinja/latest/minijinja/struct.Environment.html

Fetches a template by name from the environment.

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

### Description
Fetches a template by name. This requires that the template has been loaded with `add_template` beforehand.
```

--------------------------------

### is_integer Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_integer.html

Examples of using the is_integer test within Jinja templates.

```jinja2
{{ 42 is integer }} -> true
{{ 42.0 is integer }} -> false
```

--------------------------------

### Apply printf-style formatting

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.format.html

Uses a printf-style format string to format provided arguments.

```jinja2
{{ "%s, %s!"|format(greeting, name) }}
-> Hello, World!
```

--------------------------------

### context! Macro

Source: https://docs.rs/minijinja/latest/minijinja/macro.context.html

Creates a template context from keys and values or merges in another value. The return value is a Value.

```APIDOC
## context! Macro

### Description
Creates a template context from keys and values or merges in another value. The return value is a Value.

### Syntax
- `context!{ key => value, ... }`
- `context!{ variable_name }` (shorthand)
- `context!{ ..ctx, key => value }` (merging)

### Examples
```rust
// Basic usage
let ctx = context!{
    name => "Peter",
    location => "World",
};

// Shorthand usage
let name = "Peter";
let ctx = context!{ name };

// Nested usage
let ctx = context! {
    nav => vec![
        context!(path => "/", title => "Index"),
        context!(path => "/downloads", title => "Downloads"),
    ]
};

// Merging usage
let ctx = context! { a => "A" };
let ctx = context! { ..ctx, ..context! {
    b => "B"
}};
```
```

--------------------------------

### is_endingwith Template Usage

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_endingwith.html

Examples of using the is_endingwith test within a MiniJinja template.

```jinja2
{{ "foobar" is endingwith "bar" }} -> true
{{ "foobar" is endingwith "foo" }} -> false
```

--------------------------------

### Template::render

Source: https://docs.rs/minijinja/latest/minijinja/struct.Template.html

Renders the template into a string using the provided context.

```APIDOC
## pub fn render<S: Serialize>(&self, ctx: S) -> Result<String, Error>

### Description
Renders the template into a string. The provided value is used as the initial context for the template.
```

--------------------------------

### Use ViaDeserialize in a filter

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.ViaDeserialize.html

Example of using ViaDeserialize to accept a PathBuf as an argument in a custom filter.

```rust
use std::path::PathBuf;
use minijinja::value::ViaDeserialize;

fn dirname(path: ViaDeserialize<PathBuf>) -> String {
    match path.parent() {
        Some(parent) => parent.display().to_string(),
        None => "".to_string()
    }
}

env.add_filter("dirname", dirname);
```

--------------------------------

### Create and convert Kwargs

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Kwargs.html

Shows how to instantiate a Kwargs object from an iterator and convert it back into a Value.

```rust
use minijinja::value::{Value, Kwargs};
let kwargs = Kwargs::from_iter([
    ("foo", Value::from(true)),
    ("bar", Value::from(42)),
]);
let value = Value::from(kwargs);
assert!(value.is_kwargs());
```

--------------------------------

### Split arguments using from_args

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Kwargs.html

Illustrates how to separate positional arguments and keyword arguments from a Rest argument list.

```rust
fn my_func(args: Rest<Value>) -> Result<Value, Error> {
    let (args, kwargs) = from_args::<(&[Value], Kwargs)>(&args)?;
    // do something with args and kwargs
}
```

--------------------------------

### format(format_str, *format_args)

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.format.html

Applies the given values to a printf-style format string. This function is available when the 'builtins' feature is enabled.

```APIDOC
## format(format_str, *format_args)

### Description
Applies the given values to a printf-style format string.

### Parameters
- **format_str** (str) - The printf-style format string.
- **format_args** (Rest<Value>) - The values to be formatted into the string.

### Usage Example
{{ "%s, %s!"|format(greeting, name) }}
-> Hello, World!
```

--------------------------------

### Render a default block with else

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Provide fallback content if the sequence is empty or all items are filtered out.

```jinja
<ul>
{% for user in users %}
  <li>{{ user.username }}</li>
{% else %}
  <li><em>no users found</em></li>
{% endfor %}
</ul>
```

--------------------------------

### Manual macro caller implementation

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Demonstrates the functional equivalent of the call tag by passing a macro explicitly.

```jinja
{% macro dialog(title) %}
  <div class="dialog">
    <h3>{{ title }}</h3>
    <div class="contents">{{ caller() }}</div>
  </div>
{% endmacro %}

{% macro caller() %}
  This is the dialog body.
{% endmacro %}
{{ dialog(title="Hello World", caller=caller) }}
```

--------------------------------

### Usage of title filter in template

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.title.html

Example of applying the title filter to a variable within a Jinja template.

```jinja
<h1>{{ chapter.title|title }}</h1>
```

--------------------------------

### Render template errors with causes

Source: https://docs.rs/minijinja/latest/minijinja/struct.Error.html

Demonstrates how to handle template rendering errors by iterating through the error chain to display causes.

```rust
match template.render(ctx) {
    Ok(result) => println!("{}", result),
    Err(err) => {
        eprintln!("Could not render template: {:#}", err);
        // render causes as well
        let mut err = &err as &dyn std::error::Error;
        while let Some(next_err) = err.source() {
            eprintln!();
            eprintln!("caused by: {:#}", next_err);
            err = next_err;
        }
    }
}
```

--------------------------------

### Split slice from the end with rsplitn

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Splits a slice into at most n subslices starting from the end based on a predicate.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

--------------------------------

### Reverse split slice by predicate

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Splits a slice into subslices starting from the end, excluding the matched elements.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

```rust
let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);
```

--------------------------------

### Define custom syntax configuration

Source: https://docs.rs/minijinja/latest/minijinja/syntax/struct.SyntaxConfig.html

Configures an environment with custom delimiters for blocks, variables, and comments using the SyntaxConfig builder.

```rust
let mut environment = Environment::new();
environment.set_syntax(
    SyntaxConfig::builder()
        .block_delimiters("\\BLOCK{", "}")
        .variable_delimiters("\\VAR{", "}")
        .comment_delimiters("\\#{", "}")
        .build()
        .unwrap()
);
```

--------------------------------

### Get mutable last element

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns a mutable reference to the last item in the slice, or None if it is empty.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

--------------------------------

### Render Template to String

Source: https://docs.rs/minijinja/latest/minijinja/struct.Template.html

Renders a template into a String using a provided context.

```rust
let tmpl = env.get_template("hello").unwrap();
println!("{}", tmpl.render(context!(name => "John")).unwrap());
```

--------------------------------

### Get mutable first element

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns a mutable reference to the first element of the slice, or None if it is empty.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

--------------------------------

### render_str

Source: https://docs.rs/minijinja/latest/minijinja/struct.Environment.html

Parses and renders a template from a string in one go. This is a convenient alias for creating a template from a string and rendering it immediately.

```APIDOC
## render_str<S: Serialize>(&self, source: &str, ctx: S) -> Result<String, Error>

### Description
Parses and renders a template from a string in one go. The internal name of the template is `<string>`.

### Parameters
- **source** (&str) - Required - The template source string.
- **ctx** (S) - Required - The context data to render the template with, which must implement Serialize.
```

--------------------------------

### Get Item by Key

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Value.html

Looks up an item or attribute using a Value as a key, supporting sequence indexing.

```rust
let ctx = minijinja::context! {
    foo => "Foo",
};
let value = ctx.get_item(&Value::from("foo")).unwrap();
assert_eq!(value.to_string(), "Foo");
```

--------------------------------

### Configuring Filters via Global Variables

Source: https://docs.rs/minijinja/latest/minijinja/filters/index.html

Use state.lookup to retrieve configuration values from the template context, allowing for dynamic behavior changes.

```rust
use minijinja::State;

fn timeformat(state: &State, ts: f64) -> String {
    let configured_format = state.lookup("TIME_FORMAT");
    let format = configured_format
        .as_ref()
        .and_then(|x| x.as_str())
        .unwrap_or("HH:MM:SS");
    format_unix_timestamp(ts, format)
}

env.add_filter("timeformat", timeformat);
```

--------------------------------

### Get Attribute

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Value.html

Looks up an attribute by name, returning UNDEFINED for invalid keys or an error if the value is not an object.

```rust
let ctx = minijinja::context! {
    foo => "Foo"
};
let value = ctx.get_attr("foo")?;
assert_eq!(value.to_string(), "Foo");
```

--------------------------------

### is_startingwith function signature

Source: https://docs.rs/minijinja/latest/minijinja/tests/fn.is_startingwith.html

The function signature for is_startingwith, requiring the builtins feature.

```rust
pub fn is_startingwith(v: Cow<'_, str>, other: Cow<'_, str>) -> bool
```

--------------------------------

### Get Value Length

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Value.html

Returns the length of the contained value, returning None if the value does not support length.

```rust
let seq = Value::from(vec![1, 2, 3, 4]);
assert_eq!(seq.len(), Some(4));
```

--------------------------------

### Partition slice by key

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Uses a nightly-only experimental API to move consecutive elements that resolve to the same key to the end of the slice.

```rust
#![feature(slice_partition_dedup)]

let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];

let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);

assert_eq!(dedup, [10, 20, 30, 20, 11]);
assert_eq!(duplicates, [21, 30, 13]);
```

--------------------------------

### Configure Line Statements and Comments

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Enables line-based syntax features by setting prefixes for line statements and comments.

```rust
let mut environment = Environment::new();
environment.set_syntax(SyntaxConfig::builder()
    .line_statement_prefix("#")
    .line_comment_prefix("##")
    .build()
    .unwrap()
);
```

--------------------------------

### Check slice prefix with starts_with

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Determines if a slice begins with a specific sequence.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### SyntaxConfig::builder

Source: https://docs.rs/minijinja/latest/minijinja/syntax/struct.SyntaxConfig.html

Creates a new SyntaxConfigBuilder to construct a custom syntax configuration.

```APIDOC
## SyntaxConfig::builder

### Description
Creates a new builder instance for configuring custom template delimiters.

### Signature
`pub fn builder() -> SyntaxConfigBuilder`
```

--------------------------------

### Filter sequences by attribute

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.selectattr.html

Examples of using selectattr to filter a sequence based on a boolean attribute or a specific test.

```jinja2
{{ users|selectattr("is_active") }} -> all users where x.is_active is true
{{ users|selectattr("id", "even") }} -> returns all users with an even id
```

--------------------------------

### Include Templates

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Include rendered content from other files, with support for ignoring missing files or providing fallback lists.

```jinja
{% include 'header.html' %}
  Body
{% include 'footer.html' %}
```

```jinja
{% include 'customization.html' ignore missing %}
```

```jinja
{% include ['page_detailed.html', 'page.html'] %}
{% include ['special_sidebar.html', 'sidebar.html'] ignore missing %}
```

--------------------------------

### Evaluate a compiled expression in Rust

Source: https://docs.rs/minijinja/latest/minijinja/struct.Expression.html

Demonstrates compiling an expression string and evaluating it against a provided context using the context! macro.

```rust
let env = Environment::new();
let expr = env.compile_expression("number > 10 and number < 20").unwrap();
let rv = expr.eval(context!(number => 15)).unwrap();
assert!(rv.is_true());
```

--------------------------------

### Batch filter template usage

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.batch.html

Example of using the batch filter in a Jinja template to create table rows.

```jinja
<table>
  {% for row in items|batch(3, '&nbsp;') %}
  <tr>
  {% for column in row %}
    <td>{{ column }}</td>
  {% endfor %}
  </tr>
  {% endfor %}
</table>
```

--------------------------------

### Reverse split mutable slice

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Splits a mutable slice into subslices starting from the end, excluding the matched elements.

```rust
let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);
```

--------------------------------

### Iterate over mutable chunks in reverse

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Uses rchunks_exact_mut to iterate over a mutable slice in fixed-size chunks starting from the end.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[0, 2, 2, 1, 1]);
```

--------------------------------

### new_state

Source: https://docs.rs/minijinja/latest/minijinja/struct.Template.html

Creates an empty State for this template.

```APIDOC
## pub fn new_state(&self) -> State<'_, 'env>

### Description
Creates an empty State for this template. This is useful when testing values or working with macros or other callable objects from outside the template environment.
```

--------------------------------

### Create overlapping windows

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Use windows() to iterate over contiguous sub-slices of a fixed size. Panics if the size is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

```rust
use std::cell::Cell;

let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
let slice = &mut array[..];
let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
for w in slice_of_cells.windows(3) {
    Cell::swap(&w[0], &w[2]);
}
assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);
```

--------------------------------

### Split slice into right-aligned chunks

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Splits a slice into N-element arrays starting from the end, returning the remainder and the chunks.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

--------------------------------

### Disable lstrip_blocks Manually

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Use a plus sign at the start of a block to prevent lstrip_blocks from removing leading whitespace.

```jinja
<div>
  {%+ if something %}yay{% endif %}
</div>
```

--------------------------------

### debug(state, args)

Source: https://docs.rs/minijinja/latest/minijinja/functions/fn.debug.html

Outputs the current context or the arguments stringified. This function is available when the 'builtins' feature is enabled.

```APIDOC
## debug(state, args)

### Description
Outputs the current context or the arguments stringified. This is a useful function to quickly figure out the state of affairs in a template. It emits a stringified debug dump of the current engine state including the layers of the context, the current block and auto escaping setting.

### Signature
`pub fn debug(state: &State<'_, '_>, args: Rest<Value>) -> String`

### Usage Examples
```
<pre>{{ debug() }}</pre>
<pre>{{ debug(variable1, variable2) }}</pre>
```

### Requirements
- **Feature Flag**: builtins
```

--------------------------------

### Render with explicit environment

Source: https://docs.rs/minijinja/latest/minijinja/macro.render.html

Providing a custom environment instance for the rendering process.

```rust
let env = Environment::new();
println!("{}", render!(in env, "Hello {{ name }}!", name => "World"));
```

--------------------------------

### Get last chunk of slice mutably

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns a mutable array reference to the last N items in the slice.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());
```

--------------------------------

### Create Values using From trait

Source: https://docs.rs/minijinja/latest/minijinja/value/index.html

Create Value instances from standard Rust types like integers, units, booleans, and maps.

```rust
use std::collections::BTreeMap;
let int_value = Value::from(42);
let none_value = Value::from(());
let true_value = Value::from(true);
let map = Value::from({
    let mut m = BTreeMap::new();
    m.insert("foo", 1);
    m.insert("bar", 2);
    m
});
```

--------------------------------

### Get first chunk

Source: https://docs.rs/minijinja/latest/minijinja/value/struct.Rest.html

Returns an array reference to the first N items in the slice, or None if the slice is too short.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### Group objects using keyword arguments

Source: https://docs.rs/minijinja/latest/minijinja/filters/fn.groupby.html

Demonstrates using the attribute keyword argument and accessing the resulting named tuple properties.

```jinja2
<ul>{% for group in users|groupby(attribute="city") %}
  <li>{{ group.grouper }}
  <ul>{% for user in group.list %}
    <li>{{ user.name }}
  {% endfor %}</ul>
</li>
{% endfor %}</ul>
```

--------------------------------

### Control loop flow with {% break %} and {% continue %}

Source: https://docs.rs/minijinja/latest/minijinja/syntax/index.html

Requires the loop_controls feature. Use continue to skip iterations and break to terminate loops early.

```jinja
{% for user in users %}
{%- if loop.index is even %}{% continue %}{% endif %}
...
{% endfor %}
```

```jinja
{% for user in users %}
{%- if loop.index >= 10 %}{% break %}{% endif %}
{%- endfor %}
```
Tokens:
Raw