Struct handlebars::Handlebars

pub struct Handlebars { /* fields omitted */ }

The single entry point of your Handlebars templates

It maintains compiled templates and registered helpers.

Methods

impl Registry

pub fn new() -> Registry

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

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)

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 access a value that doesn't exist, a RenderError will be raised.

pub fn strict_mode(&self) -> bool

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>,

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>,

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>,

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>,

Register a template from a directory

pub fn register_template_source(     &mut self,     name: &str,     tpl_source: &mut Read ) -> Result<(), TemplateFileError>

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

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

remove a template from the registry

pub fn register_helper(     &mut self,     name: &str,     def: Box<HelperDef + 'static> ) -> Option<Box<HelperDef + 'static>>

register a helper

pub fn register_decorator(     &mut self,     name: &str,     def: Box<DirectiveDef + 'static> ) -> Option<Box<DirectiveDef + 'static>>

register a decorator

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

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

pub fn unregister_escape_fn(&mut self)

Restore the default escape fn.

pub fn get_escape_fn(&self) -> &Fn(&str) -> String

Get a reference to the current escape fn.

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

Return a registered template,

pub fn get_helper(&self, name: &str) -> Option<&Box<HelperDef + 'static>>

Return a registered helper

pub fn get_decorator(&self, name: &str) -> Option<&Box<DirectiveDef + 'static>>

Return a registered directive, aka decorator

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

Return all templates registered

pub fn clear_templates(&mut self)

Unregister all templates

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

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,

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,

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,

render a template string using current registry without register it

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

render a template source using current registry without register it

Trait Implementations

impl Debug for Registry

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

Formats the value using the given formatter.