[][src]Struct handlebars::Handlebars

pub struct Handlebars<'reg> { /* fields omitted */ }

The single entry point of your Handlebars templates

It maintains compiled templates and registered helpers.

Methods

impl<'reg> Registry<'reg>[src]

pub fn new() -> Registry<'reg>[src]

pub fn source_map_enabled(&mut self, enable: bool)[src]

Enable handlebars template source map

Source map provides line/col reporting on error. It uses slightly more memory to maintain the data.

Default is true.

pub fn set_strict_mode(&mut self, enable: bool)[src]

Enable handlebars strict mode

By default, handlebars renders empty string for value that undefined or never exists. Since rust is a static type language, we offer strict mode in handlebars-rust. In strict mode, if you were to render a value that doesn't exist, a RenderError will be raised.

pub fn strict_mode(&self) -> bool[src]

Return strict mode state, default is false.

By default, handlebars renders empty string for value that undefined or never exists. Since rust is a static type language, we offer strict mode in handlebars-rust. In strict mode, if you were access a value that doesn't exist, a RenderError will be raised.

pub fn register_template_string<S>(
    &mut self,
    name: &str,
    tpl_str: S
) -> Result<(), TemplateError> where
    S: AsRef<str>, 
[src]

Register a template string

Returns TemplateError if there is syntax error on parsing template.

pub fn register_partial<S>(
    &mut self,
    name: &str,
    partial_str: S
) -> Result<(), TemplateError> where
    S: AsRef<str>, 
[src]

Register a partial string

A named partial will be added to the registry. It will overwrite template with same name. Currently registered partial is just identical to template.

pub fn register_template_file<P>(
    &mut self,
    name: &str,
    tpl_path: P
) -> Result<(), TemplateFileError> where
    P: AsRef<Path>, 
[src]

Register a template from a path

pub fn register_templates_directory<P>(
    &mut self,
    tpl_extension: &'static str,
    dir_path: P
) -> Result<(), TemplateFileError> where
    P: AsRef<Path>, 
[src]

Register templates from a directory

  • tpl_extension: the template file extension
  • dir_path: the path of directory

Hidden files and tempfile (starts with #) will be ignored. All registered will use their relative name as template name. For example, when dir_path is templates/ and tpl_extension is .hbs, the file templates/some/path/file.hbs will be registerd as some/path/file.

pub fn register_template_source<R>(
    &mut self,
    name: &str,
    tpl_source: &mut R
) -> Result<(), TemplateFileError> where
    R: Read
[src]

Register a template from std::io::Read source

pub fn unregister_template(&mut self, name: &str)[src]

remove a template from the registry

pub fn register_helper(
    &mut self,
    name: &str,
    def: Box<dyn HelperDef + 'reg>
) -> Option<Box<dyn HelperDef + 'reg>>
[src]

register a helper

pub fn register_decorator(
    &mut self,
    name: &str,
    def: Box<dyn DirectiveDef + 'reg>
) -> Option<Box<dyn DirectiveDef + 'reg>>
[src]

register a decorator

pub fn register_escape_fn<F: 'static + Fn(&str) -> String + Send + Sync>(
    &mut self,
    escape_fn: F
)
[src]

Register a new escape fn to be used from now on by this registry.

pub fn unregister_escape_fn(&mut self)[src]

Restore the default escape fn.

pub fn get_escape_fn(&self) -> &dyn Fn(&str) -> String[src]

Get a reference to the current escape fn.

pub fn has_template(&self, name: &str) -> bool[src]

Return true if a template is registered for the given name

pub fn get_template(&self, name: &str) -> Option<&Template>[src]

Return a registered template,

pub fn get_helper(&self, name: &str) -> Option<&dyn HelperDef>[src]

Return a registered helper

pub fn get_decorator(&self, name: &str) -> Option<&dyn DirectiveDef>[src]

Return a registered directive, aka decorator

pub fn get_templates(&self) -> &HashMap<String, Template>[src]

Return all templates registered

pub fn clear_templates(&mut self)[src]

Unregister all templates

pub fn render<T>(&self, name: &str, data: &T) -> Result<String, RenderError> where
    T: Serialize
[src]

Render a registered template with some data into a string

  • name is the template name you registred previously
  • ctx is the data that implements serde::Serialize

Returns rendered string or an struct with error information

pub fn render_to_write<T, W>(
    &self,
    name: &str,
    data: &T,
    writer: W
) -> Result<(), RenderError> where
    T: Serialize,
    W: Write
[src]

Render a registered template and write some data to the std::io::Write

pub fn render_template<T>(
    &self,
    template_string: &str,
    data: &T
) -> Result<String, TemplateRenderError> where
    T: Serialize
[src]

render a template string using current registry without register it

pub fn render_template_to_write<T, W>(
    &self,
    template_string: &str,
    data: &T,
    writer: W
) -> Result<(), TemplateRenderError> where
    T: Serialize,
    W: Write
[src]

render a template string using current registry without register it

pub fn render_template_source_to_write<T, R, W>(
    &self,
    template_source: &mut R,
    data: &T,
    writer: W
) -> Result<(), TemplateRenderError> where
    T: Serialize,
    W: Write,
    R: Read
[src]

render a template source using current registry without register it

Trait Implementations

impl<'reg> Debug for Registry<'reg>[src]

impl<'reg> Default for Registry<'reg>[src]

Auto Trait Implementations

impl<'reg> !RefUnwindSafe for Registry<'reg>

impl<'reg> Send for Registry<'reg>

impl<'reg> Sync for Registry<'reg>

impl<'reg> Unpin for Registry<'reg>

impl<'reg> !UnwindSafe for Registry<'reg>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.