Struct rocket_dyn_templates::Template

pub struct Template { /* private fields */ }

Responder that renders a dynamic template.

Template serves as a proxy type for rendering a template and does not contain the rendered template itself. The template is lazily rendered, at response time. To render a template greedily, use Template::show().

See the crate root for usage details.

Implementations

impl Template

pub fn fairing() -> impl Fairing

Returns a fairing that initializes and maintains templating state.

This fairing, or the one returned by Template::custom(), must be attached to any Rocket instance that wishes to render templates. Failure to attach this fairing will result in a “Uninitialized template context: missing fairing.” error message when a template is attempted to be rendered.

If you wish to customize the internal templating engines, use Template::custom() instead.

Example

To attach this fairing, simple call attach on the application’s Rocket instance with Template::fairing():

extern crate rocket;
extern crate rocket_dyn_templates;

use rocket_dyn_templates::Template;

fn main() {
    rocket::build()
        // ...
        .attach(Template::fairing())
        // ...
}

pub fn custom<F: Send + Sync + 'static>(f: F) -> impl Fairing where
    F: Fn(&mut Engines), 

Returns a fairing that initializes and maintains templating state.

Unlike Template::fairing(), this method allows you to configure templating engines via the function f. Note that only the enabled templating engines will be accessible from the Engines type.

This method does not allow the function f to fail. If f is fallible, use Template::try_custom() instead.

Example

extern crate rocket;
extern crate rocket_dyn_templates;

use rocket_dyn_templates::Template;

fn main() {
    rocket::build()
        // ...
        .attach(Template::custom(|engines| {
            // engines.handlebars.register_helper ...
        }))
        // ...
}

pub fn try_custom<F: Send + Sync + 'static>(f: F) -> impl Fairing where
    F: Fn(&mut Engines) -> Result<(), Box<dyn Error>>, 

Returns a fairing that initializes and maintains templating state.

This variant of Template::custom() allows a fallible f. If f returns an error during initialization, it will cancel the launch. If f returns an error during template reloading (in debug mode), then the newly-reloaded templates are discarded.

Example

extern crate rocket;
extern crate rocket_dyn_templates;

use rocket_dyn_templates::Template;

fn main() {
    rocket::build()
        // ...
        .attach(Template::try_custom(|engines| {
            // engines.handlebars.register_helper ...
            Ok(())
        }))
        // ...
}

pub fn render<S, C>(name: S, context: C) -> Template where
    S: Into<Cow<'static, str>>,
    C: Serialize, 

Render the template named name with the context context. The context is typically created using the context! macro, but it can be of any type that implements Serialize, such as HashMap or a custom struct.

Examples

Using the context macro:

use rocket_dyn_templates::{Template, context};

let template = Template::render("index", context! {
    foo: "Hello, world!",
});

Using a HashMap as the context:

use std::collections::HashMap;
use rocket_dyn_templates::Template;

// Create a `context` from a `HashMap`.
let mut context = HashMap::new();
context.insert("foo", "Hello, world!");

let template = Template::render("index", context);

pub fn show<S, C>(rocket: &Rocket<Orbit>, name: S, context: C) -> Option<String> where
    S: Into<Cow<'static, str>>,
    C: Serialize, 

Render the template named name with the context context into a String. This method should not be used in any running Rocket application. This method should only be used during testing to validate Template responses. For other uses, use render() instead.

The context can be of any type that implements Serialize. This is typically a HashMap or a custom struct.

Returns Some if the template could be rendered. Otherwise, returns None. If rendering fails, error output is printed to the console. None is also returned if a Template fairing has not been attached.

Example

use std::collections::HashMap;

use rocket_dyn_templates::Template;
use rocket::local::blocking::Client;

fn main() {
    let rocket = rocket::build().attach(Template::fairing());
    let client = Client::untracked(rocket).expect("valid rocket");

    // Create a `context`. Here, just an empty `HashMap`.
    let mut context = HashMap::new();
    let template = Template::show(client.rocket(), "index", context);
}

Trait Implementations

impl Debug for Template

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

Formats the value using the given formatter.

impl<'r> Responder<'r, 'static> for Template

Returns a response with the Content-Type derived from the template’s extension and a fixed-size body containing the rendered template. If rendering fails, an Err of Status::InternalServerError is returned.

fn respond_to(self, req: &'r Request<'_>) -> Result<'static>

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status.

impl Sentinel for Template

fn abort(rocket: &Rocket<Ignite>) -> bool

Returns true if launch should be aborted and false otherwise.