Module template 

Two-pass template rendering with style tag processing.

This module provides the core rendering pipeline that transforms templates and data into styled terminal output. Templates are processed in two passes: template engine for logic, then BBParser for style tags.

Template Engines

Two template engines are available:

Engine	Syntax	Features	Use When
MiniJinjaEngine	{{ var }}	Loops, conditionals, filters, includes	Full template logic needed
SimpleEngine	{var}	Variable substitution only	Simple output, smaller binary

MiniJinja (Default)

Full-featured Jinja2-compatible engine. File extensions: .jinja, .jinja2, .j2

[title]{{ name | upper }}[/title] has {{ count }} items
{% for item in items %}{{ item.name }}{% endfor %}

Simple Engine

Lightweight format-string style substitution. File extension: .stpl

[title]{name}[/title] has {count} items
{user.profile.email}

Two-Pass Rendering

Templates are processed in two distinct passes, which is why style tags use bracket notation ([name]...[/name]) instead of template syntax:

Pass 1 - Template Engine: Variable substitution (and control flow for MiniJinja).

Template: [title]{{ name | upper }}[/title] has {{ count }} items
After:    [title]WIDGET[/title] has 42 items

Pass 2 - BBParser: Style tags converted to ANSI codes (or stripped).

Input:  [title]WIDGET[/title] has 42 items
Output: \x1b[1;32mWIDGET\x1b[0m has 42 items

This separation keeps template logic independent from styling concerns.

Which Render Function?

Choose based on your needs:

Function	Use When
render	Simple case, let Standout auto-detect everything
render_with_output	Honoring --output flag (Term/Text/Auto)
render_with_mode	Full control over output mode AND color mode
render_auto	CLI with --output=json support (skips template for structured modes)

The “auto” in render_auto refers to template-vs-serialization dispatch, not color detection. Structured modes (JSON, YAML, XML, CSV) serialize data directly, skipping the template entirely.

Style Tags in Templates

Use bracket notation for styling (works with both engines):

[title]{{ name }}[/title] - [muted]{{ description }}[/muted]  // MiniJinja
[title]{name}[/title] - [muted]{description}[/muted]          // Simple

Tags can nest, span multiple lines, and contain template logic. Unknown tags show a ? marker ([unknown?]text[/unknown?]) — use validate_template to catch typos at startup or in tests.

Template Registry

For file-based templates, use TemplateRegistry:

let mut registry = TemplateRegistry::new();
registry.add_from_files(walk_template_dir("./templates")?)?;
let content = registry.get_content("config")?;

Resolution priority: inline templates → embedded (compile-time) → file-based. Supported extensions: .jinja, .jinja2, .j2, .stpl, .txt (in priority order).

Key Types

• Renderer: Pre-compiled template renderer for repeated rendering
• TemplateRegistry: Template resolution from multiple sources
• TemplateEngine: Trait for pluggable template backends
• MiniJinjaEngine: Full-featured Jinja2 engine (default)
• SimpleEngine: Lightweight format-string engine
• validate_template: Check templates for unknown style tags

See Also

• crate::theme: Theme and style definitions
• crate::tabular: Column formatting utilities and template filters
• crate::context: Context injection for templates

Re-exports

pub use registry::walk_template_dir;

pub use registry::RegistryError;

pub use registry::ResolvedTemplate;

pub use registry::TemplateFile;

pub use registry::TemplateRegistry;

pub use registry::TEMPLATE_EXTENSIONS;

Modules

filters

MiniJinja filter registration.

registry

Template registry for file-based and inline templates.

Structs

MiniJinjaEngine

MiniJinja-based template engine.

Renderer

A renderer with pre-registered templates.

SimpleEngine

A lightweight template engine using format-string style substitution.

Traits

TemplateEngine

A template engine that can render templates with data.

Functions

register_filters

Registers standout’s custom filters with a MiniJinja environment.

render

Renders a template with automatic terminal color detection.

render_auto

Auto-dispatches between template rendering and direct serialization.

render_auto_with_context

Auto-dispatches with context injection support.

render_auto_with_engine

Auto-dispatches rendering using a provided TemplateEngine.

render_auto_with_spec

Auto-dispatches with granular control over structured output.

render_with_context

Renders a template with additional context objects injected.

render_with_mode

Renders a template with explicit output mode and color mode control.

render_with_output

Renders a template with explicit output mode control.

render_with_vars

Renders a template with additional variables injected into the context.

validate_template

Validates a template for unknown style tags.