Struct rocket_include_handlebars::ReloadableHandlebars

pub struct ReloadableHandlebars { /* private fields */ }

Reloadable Handlebars.

Implementations

impl ReloadableHandlebars

pub fn new() -> ReloadableHandlebars

Create an instance of ReloadableHandlebars.

pub fn register_template_file<P: Into<PathBuf>>(
    &mut self,
    name: &'static str,
    file_path: P
) -> Result<(), TemplateError>

Register a template from a path and it can be reloaded automatically.

pub fn unregister_template_file<S: AsRef<str>>(
    &mut self,
    name: S
) -> Option<PathBuf>

Unregister a template from a file by a name.

pub fn reload_if_needed(&mut self) -> Result<(), TemplateError>

Reload templates if needed.

Methods from Deref<Target = Handlebars<'static>>

pub fn set_strict_mode(&mut self, enabled: bool)

Enable or disable 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 dev_mode(&self) -> bool

Return dev mode state, default is false

With dev mode turned on, handlebars enables a set of development friendly features, that may affect its performance.

pub fn set_dev_mode(&mut self, enabled: bool)

Enable or disable dev mode

With dev mode turned on, handlebars enables a set of development friendly features, that may affect its performance.

Note that you have to enable dev mode before adding templates to the registry. Otherwise it won’t take effect at all.

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

Enable or disable indent for partial include tag {{>}}

By default handlebars keeps indent whitespaces for partial include tag, to change this behaviour, set this toggle to true.

pub fn prevent_indent(&self) -> bool

Return state for prevent_indent option, default to false.

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.

Dev mode doesn’t apply for pre-compiled template because it’s lifecycle is not managed by the registry.

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<(), TemplateError> where
    P: AsRef<Path>, 

Register a template from a path on file system

If dev mode is enabled, the registry will keep reading the template file from file system everytime it’s visited.

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

Register a helper

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

Register a decorator

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

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)

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_templates(&self) -> &HashMap<String, Template, RandomState>

Return all templates registered

Note that in dev mode, the template returned from this method may not reflect its latest state. This method doesn’t try to reload templates from its source.

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

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<(), RenderError> where
    T: Serialize,
    W: Write, 

Render a template string using current registry without registering it

Trait Implementations

impl Debug for ReloadableHandlebars

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

Formats the value using the given formatter.

impl Default for ReloadableHandlebars

fn default() -> Self

Returns the “default value” for a type.

impl Deref for ReloadableHandlebars

type Target = Registry<'static>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ReloadableHandlebars

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.