Struct handlebars::Handlebars

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

The single entry point of your Handlebars templates

It maintains compiled templates and registered helpers.

Implementations

impl<'reg> Registry<'reg>

pub fn new() -> Registry<'reg>

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 to render 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(&mut self, name: &str, tpl: Template)

Register a Template

This is infallible since the template has already been parsed and insert cannot fail. If there is an existing template with this name it will be overwritten.

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 the 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 a registered partial is just identical to a 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 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 registered as some/path/file.

This method is not available by default. You will need to enable the dir_source feature to use it.

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

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<dyn HelperDef + Send + Sync + 'reg>
) -> Option<Box<dyn HelperDef + Send + Sync + 'reg>>

Register a helper

pub fn register_script_helper(
    &mut self,
    name: &str,
    script: String
) -> Result<Option<Box<dyn HelperDef + Send + Sync + 'reg>>, ScriptError>

Register a rhai script as handlebars helper

Currently only simple helpers are supported. You can do computation or string formatting with rhai script.

Helper parameters and hash are available in rhai script as array params and map hash. Example script:

{{percent 0.34 label="%"}}

// percent.rhai
let value = params[0];
let label = hash["label"];

(value * 100).to_string() + label

pub fn register_script_helper_file<P>(
    &mut self,
    name: &str,
    script_path: P
) -> Result<Option<Box<dyn HelperDef + Send + Sync + 'reg>>, ScriptError> where
    P: AsRef<Path>, 

Register a rhai script from file

pub fn register_decorator(
    &mut self,
    name: &str,
    def: Box<dyn DecoratorDef + Send + Sync + 'reg>
) -> Option<Box<dyn DecoratorDef + Send + Sync + 'reg>>

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) -> &dyn Fn(&str) -> String

Get a reference to the current escape fn.

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

Return true if a template is registered for the given name

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

Return a registered template,

pub fn get_helper(
    &self,
    name: &str
) -> Option<&(dyn HelperDef + Send + Sync + 'reg)>

Return a registered helper

pub fn get_decorator(
    &self,
    name: &str
) -> Option<&(dyn DecoratorDef + Send + Sync + 'reg)>

Return a registered 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 registered previously
• data is the data that implements serde::Serialize

Returns rendered string or a struct with error information

pub fn render_with_context(
    &self,
    name: &str,
    ctx: &Context
) -> Result<String, RenderError>

Render a registered template with reused context

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 registering it

pub fn render_template_with_context(
    &self,
    template_string: &str,
    ctx: &Context
) -> Result<String, TemplateRenderError>

Render a template string using reused context data

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

Render a template source using current registry without registering it

Trait Implementations

impl<'reg> Debug for Registry<'reg>

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

Formats the value using the given formatter.

impl<'reg> Default for Registry<'reg>

fn default() -> Self

Returns the "default value" for a type.