Struct Atom 

pub struct Atom { /* private fields */ }

The main template engine struct.

Atom provides methods for creating templates, registering components, rendering templates, and managing context.

Example

use atom_engine::Atom;
use serde_json::json;

let mut engine = Atom::new();
engine.add_template("greeting.html", "Hello, {{ name }}!").unwrap();
let result = engine.render("greeting.html", &json!({"name": "Alice"})).unwrap();
assert_eq!(result, "Hello, Alice!");

Implementations

impl Atom

pub fn new() -> Self

Creates a new Atom engine instance with all built-in filters and functions registered.

Example

use atom_engine::Atom;

let engine = Atom::new();

pub fn load_templates(&mut self, glob_pattern: &str) -> Result<(), Error>

Loads templates from the filesystem using a glob pattern.

Arguments

• glob_pattern - A glob pattern to match template files (e.g., “templates/**/*.html”)

Example

let mut engine = atom_engine::Atom::new();
engine.load_templates("templates/**/*.html").unwrap();

pub fn add_template(&mut self, name: &str, content: &str) -> Result<(), Error>

Adds a raw template to the engine.

Arguments

• name - The template name (e.g., “index.html”)
• content - The template content

Example

let mut engine = atom_engine::Atom::new();
engine.add_template("hello.html", "Hello, {{ name }}!").unwrap();

pub fn register_component( &mut self, path: &str, template: &str, ) -> Result<(), Error>

Registers a reusable component.

Arguments

• path - Component path/name (e.g., “button”)
• template - Component template content

Example

let mut engine = atom_engine::Atom::new();
engine.register_component("button", "<button>{{ text }}</button>").unwrap();

pub fn register_filter<F>(&mut self, name: &str, filter: F)

where F: Filter + Send + Sync + 'static,

Registers a custom filter.

Arguments

• name - Filter name
• filter - The filter function

pub fn register_function<F>(&mut self, name: &str, function: F)

where F: Function + Send + Sync + 'static,

Registers a custom global function.

Arguments

• name - Function name
• function - The function to register

pub fn set_max_loop_iter(&mut self, max: usize)

Sets the maximum number of iterations for loops.

This prevents infinite loops in templates.

pub fn set_debug(&mut self, debug: bool)

Sets debug mode for the engine.

When enabled, additional debugging information may be logged.

pub fn render(&self, template: &str, context: &Value) -> Result<String, Error>

Renders a template with the given context.

Arguments

• template - The template name to render
• context - The context data as a JSON value

Example

use atom_engine::Atom;
use serde_json::json;

let mut engine = Atom::new();
engine.add_template("greeting.html", "Hello, {{ name }}!").unwrap();
let result = engine.render("greeting.html", &json!({"name": "World"})).unwrap();
assert_eq!(result, "Hello, World!");

pub fn render_with_components( &self, template: &str, context: &Value, component_data: &Value, ) -> Result<String, Error>

Renders a template with component data included in the context.

This is useful when you want to pass additional component-specific data alongside the regular context.

Arguments

• template - The template name to render
• context - The context data as a JSON value
• component_data - Additional component-specific data

pub fn provide(&mut self, key: &str, value: Value)

Provides a value to the context chain.

This implements a provide/inject pattern (similar to Vue.js) where values can be provided at a higher level and injected in child components.

Arguments

• key - The context key
• value - The value to provide

Example

use atom_engine::Atom;
use serde_json::json;

let mut engine = Atom::new();
engine.add_template("child.html", "{{ theme }}").unwrap();
engine.provide("theme", json!("dark"));
let result = engine.render("child.html", &json!({})).unwrap();
assert_eq!(result, "dark");

pub fn reload(&mut self) -> Result<(), Error>

Reloads all templates from the filesystem.

This is useful during development when templates change on disk.

pub fn template_exists(&self, name: &str) -> bool

Checks if a template exists in the engine.

Arguments

• name - The template name to check

Returns

true if the template exists, false otherwise

pub fn get_registered_templates(&self) -> Vec<String>

Gets a list of all registered template names.

Returns

A vector of template names

pub fn clear_cache(&mut self)

Clears the template cache.

This forces templates to be re-parsed on next render.

pub fn set_parallel(&mut self, enabled: bool)

Enables or disables parallel rendering.

When enabled with the parallel feature, multiple templates can be rendered concurrently using Rayon.

pub fn is_parallel(&self) -> bool

Returns whether parallel rendering is enabled.

pub fn enable_component_cache(&mut self, enabled: bool)

Enables or disables component caching.

When enabled, rendered components are cached based on their props hash.

pub fn is_component_cache_enabled(&self) -> bool

Returns whether component caching is enabled.

pub fn clear_component_cache(&mut self)

Clears the component cache.

pub fn component_cache_len(&self) -> usize

Returns the number of cached component renders.

pub fn render_many( &self, templates: &[(&str, &Value)], ) -> Result<Vec<(String, String)>, Error>

Renders multiple templates in parallel (when the parallel feature is enabled).

Requires the parallel feature to be enabled. Without it, templates are rendered sequentially.

Arguments

• templates - A slice of template name and context pairs

Returns

A vector of (template_name, rendered_output) pairs

pub async fn render_async( &self, template: &str, context: &Value, ) -> Result<String, Error>

Renders a template asynchronously.

Requires the async feature to be enabled.

Arguments

• template - The template name to render
• context - The context data as a JSON value

Example

#[cfg(feature = "async")]
async fn render_template() {
    use atom_engine::Atom;
    use serde_json::json;

    let engine = Atom::new();
    let result = engine.render_async("hello.html", &json!({"name": "World"})).await;
}

pub async fn render_many_async( &self, templates: &[(&str, &Value)], ) -> Result<Vec<(String, String)>, Error>

Renders multiple templates asynchronously.

Requires the async feature to be enabled.

Arguments

• templates - A slice of template name and context pairs

Returns

A vector of (template_name, rendered_output) pairs

Trait Implementations

impl Clone for Atom

fn clone(&self) -> Atom

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Atom

fn default() -> Self

Returns the “default value” for a type.