Module axum_template::engine
source · Expand description
Types that implement TemplateEngine
for commonly used template engines
Note: each engine is guarded behind a feature with the same name
§Table of contents
§handlebars
//! Simple usage of using `axum_template` with the `handlebars` crate
//!
//! Run the example using
//!
//! ```sh
//! cargo run --example=handlebars --features=handlebars
//! ```
use std::net::Ipv4Addr;
use axum::{
extract::{FromRef, Path},
response::IntoResponse,
routing::get,
serve, Router,
};
use axum_template::{engine::Engine, Key, RenderHtml};
use handlebars::Handlebars;
use serde::Serialize;
use tokio::net::TcpListener;
// Type alias for our engine. For this example, we are using Handlebars
type AppEngine = Engine<Handlebars<'static>>;
#[derive(Debug, Serialize)]
pub struct Person {
name: String,
}
async fn get_name(
// Obtain the engine
engine: AppEngine,
// Extract the key
Key(key): Key,
Path(name): Path<String>,
) -> impl IntoResponse {
let person = Person { name };
RenderHtml(key, engine, person)
}
// Define your application shared state
#[derive(Clone, FromRef)]
struct AppState {
engine: AppEngine,
}
#[tokio::main]
async fn main() {
// Set up the Handlebars engine with the same route paths as the Axum router
let mut hbs = Handlebars::new();
hbs.register_template_string("/:name", "<h1>Hello HandleBars!</h1><p>{{name}}</p>")
.unwrap();
let app = Router::new()
.route("/:name", get(get_name))
// Create the application state
.with_state(AppState {
engine: Engine::from(hbs),
});
println!("See example: http://127.0.0.1:8080/example");
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
.await
.unwrap();
serve(listener, app.into_make_service()).await.unwrap();
}
§minijinja
//! Simple usage of using `axum_template` with the `minijinja` crate
//!
//! Run the example using
//!
//! ```sh
//! cargo run --example=minijinja --features=minijinja
//! ```
use std::net::Ipv4Addr;
use axum::{
extract::{FromRef, Path},
response::IntoResponse,
routing::get,
serve, Router,
};
use axum_template::{engine::Engine, Key, RenderHtml};
use minijinja::Environment;
use serde::Serialize;
use tokio::net::TcpListener;
// Type alias for our engine. For this example, we are using Mini Jinja
type AppEngine = Engine<Environment<'static>>;
#[derive(Debug, Serialize)]
pub struct Person {
name: String,
}
async fn get_name(
// Obtain the engine
engine: AppEngine,
// Extract the key
Key(key): Key,
Path(name): Path<String>,
) -> impl IntoResponse {
let person = Person { name };
RenderHtml(key, engine, person)
}
// Define your application shared state
#[derive(Clone, FromRef)]
struct AppState {
engine: AppEngine,
}
#[tokio::main]
async fn main() {
// Set up the `minijinja` engine with the same route paths as the Axum router
let mut jinja = Environment::new();
jinja
.add_template("/:name", "<h1>Hello Minijinja!</h1><p>{{name}}</p>")
.unwrap();
let app = Router::new()
.route("/:name", get(get_name))
// Create the application state
.with_state(AppState {
engine: Engine::from(jinja),
});
println!("See example: http://127.0.0.1:8080/example");
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
.await
.unwrap();
serve(listener, app.into_make_service()).await.unwrap();
}
§tera
//! Simple usage of using `axum_template` with the `tera` crate
//!
//! Run the example using
//!
//! ```sh
//! cargo run --example=tera --features=tera
//! ```
use std::net::Ipv4Addr;
use axum::{
extract::{FromRef, Path},
response::IntoResponse,
routing::get,
serve, Router,
};
use axum_template::{engine::Engine, Key, RenderHtml};
use serde::Serialize;
use tera::Tera;
use tokio::net::TcpListener;
// Type alias for our engine. For this example, we are using Tera
type AppEngine = Engine<Tera>;
#[derive(Debug, Serialize)]
pub struct Person {
name: String,
}
async fn get_name(
// Obtain the engine
engine: AppEngine,
// Extract the key
Key(key): Key,
Path(name): Path<String>,
) -> impl IntoResponse {
let person = Person { name };
RenderHtml(key, engine, person)
}
// Define your application shared state
#[derive(Clone, FromRef)]
struct AppState {
engine: AppEngine,
}
#[tokio::main]
async fn main() {
// Set up the Tera engine with the same route paths as the Axum router
let mut tera = Tera::default();
tera.add_raw_template("/:name", "<h1>Hello Tera!</h1><p>{{name}}</p>")
.unwrap();
let app = Router::new()
.route("/:name", get(get_name))
// Create the application state
.with_state(AppState {
engine: Engine::from(tera),
});
println!("See example: http://127.0.0.1:8080/example");
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
.await
.unwrap();
serve(listener, app.into_make_service()).await.unwrap();
}
Structs§
- A wrapper type that implements
TemplateEngine
for multiple commonly used engines. Seecrate::engine
for detailed usage instructions and examples
Enums§
- Error wrapper for
handlebars::RenderError
- Error wrapper for
minijinja::Error
- Error wrapper for
tera::Error