Struct rocket_contrib::templates::Template [−][src]
pub struct Template { /* fields omitted */ }
Expand description
Responder that renders a dynamic template.
Usage
To use, add the handlebars_templates
feature, the tera_templates
feature, or both, to the rocket_contrib
dependencies section of your
Cargo.toml
:
[dependencies.rocket_contrib]
version = "0.4.10"
default-features = false
features = ["handlebars_templates", "tera_templates"]
Then, ensure that the template Fairing
is attached to your Rocket
application:
use rocket_contrib::templates::Template; fn main() { rocket::ignite() .attach(Template::fairing()) // ... }
The Template
type implements Rocket’s Responder
trait, so it can be
returned from a request handler directly:
use rocket_contrib::templates::Template; #[get("/")] fn index() -> Template { let context = context(); Template::render("index", &context) }
Helpers, Filters, and Customization
You may use the Template::custom()
method to construct a fairing with
customized templating engines. Among other things, this method allows you to
register template helpers and register templates from strings.
Implementations
impl Template
[src]
impl Template
[src]pub fn fairing() -> impl Fairing
[src]
pub fn fairing() -> impl Fairing
[src]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_contrib; use rocket_contrib::templates::Template; fn main() { rocket::ignite() // ... .attach(Template::fairing()) // ... }
pub fn custom<F>(f: F) -> impl Fairing where
F: Fn(&mut Engines) + Send + Sync + 'static,
[src]
pub fn custom<F>(f: F) -> impl Fairing where
F: Fn(&mut Engines) + Send + Sync + 'static,
[src]Returns a fairing that initializes and maintains templating state.
Unlike Template::fairing()
, this method allows you to configure
templating engines via the parameter f
. Note that only the enabled
templating engines will be accessible from the Engines
type.
Example
extern crate rocket; extern crate rocket_contrib; use rocket_contrib::templates::Template; fn main() { rocket::ignite() // ... .attach(Template::custom(|engines| { // engines.handlebars.register_helper ... })) // ... }
pub fn render<S, C>(name: S, context: C) -> Template where
S: Into<Cow<'static, str>>,
C: Serialize,
[src]
pub fn render<S, C>(name: S, context: C) -> Template where
S: Into<Cow<'static, str>>,
C: Serialize,
[src]Render the template named name
with the context context
. The
context
can be of any type that implements Serialize
. This is
typically a HashMap
or a custom struct
.
Example
use std::collections::HashMap; use rocket_contrib::templates::Template; // Create a `context`. Here, just an empty `HashMap`. let mut context = HashMap::new(); let template = Template::render("index", context);
pub fn show<S, C>(rocket: &Rocket, name: S, context: C) -> Option<String> where
S: Into<Cow<'static, str>>,
C: Serialize,
[src]
pub fn show<S, C>(rocket: &Rocket, name: S, context: C) -> Option<String> where
S: Into<Cow<'static, str>>,
C: Serialize,
[src]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_contrib::templates::Template; use rocket::local::Client; fn main() { let rocket = rocket::ignite().attach(Template::fairing()); let client = Client::new(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 Responder<'static> for Template
[src]
impl Responder<'static> for Template
[src]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: &Request<'_>) -> Result<'static>
[src]
fn respond_to(self, req: &Request<'_>) -> Result<'static>
[src]Returns Ok
if a Response
could be generated successfully. Otherwise,
returns an Err
with a failing Status
. Read more
Auto Trait Implementations
impl RefUnwindSafe for Template
impl Send for Template
impl Sync for Template
impl Unpin for Template
impl UnwindSafe for Template
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
pub fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
pub fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
Converts self
into a collection.
pub fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
F: FnMut(T) -> U,
A: Array<Item = U>,
F: FnMut(T) -> U,
A: Array<Item = U>,
impl<T> IntoSql for T
[src]
impl<T> IntoSql for T
[src]fn into_sql<T>(self) -> Self::Expression where
Self: AsExpression<T>,
[src]
fn into_sql<T>(self) -> Self::Expression where
Self: AsExpression<T>,
[src]Convert self
to an expression for Diesel’s query builder. Read more
fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression where
&'a Self: AsExpression<T>,
[src]
fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression where
&'a Self: AsExpression<T>,
[src]Convert &self
to an expression for Diesel’s query builder. Read more
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,