use std::collections::HashMap;
use std::fmt::{self, Debug, Formatter};
use std::fs::File;
use std::io::prelude::*;
use std::path::Path;
use serde::Serialize;
use regex::{Captures, Regex};
use context::Context;
use directives::{self, DirectiveDef};
use error::{RenderError, TemplateError, TemplateFileError, TemplateRenderError};
use helpers::{self, HelperDef};
use output::{Output, StringOutput, WriteOutput};
use render::{RenderContext, Renderable};
use support::str::StringWriter;
use template::Template;
#[cfg(not(feature = "no_dir_source"))]
use walkdir::{DirEntry, WalkDir};
lazy_static! {
static ref DEFAULT_REPLACE: Regex = Regex::new(">|<|\"|&").unwrap();
}
pub type EscapeFn = Box<Fn(&str) -> String + Send + Sync>;
pub fn html_escape(data: &str) -> String {
DEFAULT_REPLACE
.replace_all(data, |cap: &Captures| {
match cap.get(0).map(|m| m.as_str()) {
Some("<") => "<",
Some(">") => ">",
Some("\"") => """,
Some("&") => "&",
_ => unreachable!(),
}.to_owned()
}).into_owned()
}
pub fn no_escape(data: &str) -> String {
data.to_owned()
}
pub struct Registry {
templates: HashMap<String, Template>,
helpers: HashMap<String, Box<HelperDef + 'static>>,
directives: HashMap<String, Box<DirectiveDef + 'static>>,
escape_fn: EscapeFn,
source_map: bool,
strict_mode: bool,
}
impl Debug for Registry {
fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
f.debug_struct("Handlebars")
.field("templates", &self.templates)
.field("helpers", &self.helpers.keys())
.field("directives", &self.directives.keys())
.field("source_map", &self.source_map)
.finish()
}
}
impl Default for Registry {
fn default() -> Self {
Self::new()
}
}
#[cfg(not(feature = "no_dir_source"))]
fn filter_file(entry: &DirEntry, suffix: &str) -> bool {
let path = entry.path();
!path.is_file() || path
.file_name()
.map(|s| {
let ds = s.to_string_lossy();
ds.starts_with(".") || ds.starts_with("#") || !ds.ends_with(suffix)
}).unwrap_or(true)
}
impl Registry {
pub fn new() -> Registry {
let r = Registry {
templates: HashMap::new(),
helpers: HashMap::new(),
directives: HashMap::new(),
escape_fn: Box::new(html_escape),
source_map: true,
strict_mode: false,
};
r.setup_builtins()
}
fn setup_builtins(mut self) -> Registry {
self.register_helper("if", Box::new(helpers::IF_HELPER));
self.register_helper("unless", Box::new(helpers::UNLESS_HELPER));
self.register_helper("each", Box::new(helpers::EACH_HELPER));
self.register_helper("with", Box::new(helpers::WITH_HELPER));
self.register_helper("lookup", Box::new(helpers::LOOKUP_HELPER));
self.register_helper("raw", Box::new(helpers::RAW_HELPER));
self.register_helper("log", Box::new(helpers::LOG_HELPER));
self.register_helper("eq", Box::new(helpers::helper_boolean::eq));
self.register_helper("ne", Box::new(helpers::helper_boolean::ne));
self.register_helper("gt", Box::new(helpers::helper_boolean::gt));
self.register_helper("gte", Box::new(helpers::helper_boolean::gte));
self.register_helper("lt", Box::new(helpers::helper_boolean::lt));
self.register_helper("lte", Box::new(helpers::helper_boolean::lte));
self.register_helper("and", Box::new(helpers::helper_boolean::and));
self.register_helper("or", Box::new(helpers::helper_boolean::or));
self.register_helper("not", Box::new(helpers::helper_boolean::not));
self.register_decorator("inline", Box::new(directives::INLINE_DIRECTIVE));
self
}
pub fn source_map_enabled(&mut self, enable: bool) {
self.source_map = enable;
}
pub fn set_strict_mode(&mut self, enable: bool) {
self.strict_mode = enable;
}
pub fn strict_mode(&self) -> bool {
self.strict_mode
}
pub fn register_template_string<S>(
&mut self,
name: &str,
tpl_str: S,
) -> Result<(), TemplateError>
where
S: AsRef<str>,
{
Template::compile_with_name(tpl_str, name.to_owned(), self.source_map)
.and_then(|t| Ok(self.templates.insert(name.to_string(), t)))?;
Ok(())
}
pub fn register_partial<S>(&mut self, name: &str, partial_str: S) -> Result<(), TemplateError>
where
S: AsRef<str>,
{
self.register_template_string(name, partial_str)
}
pub fn register_template_file<P>(
&mut self,
name: &str,
tpl_path: P,
) -> Result<(), TemplateFileError>
where
P: AsRef<Path>,
{
let mut file =
File::open(tpl_path).map_err(|e| TemplateFileError::IOError(e, name.to_owned()))?;
self.register_template_source(name, &mut file)
}
#[cfg(not(feature = "no_dir_source"))]
pub fn register_templates_directory<P>(
&mut self,
tpl_extension: &'static str,
dir_path: P,
) -> Result<(), TemplateFileError>
where
P: AsRef<Path>,
{
let dir_path = dir_path.as_ref();
let prefix_len = if dir_path.to_string_lossy().ends_with('/') {
dir_path.to_string_lossy().len()
} else {
dir_path.to_string_lossy().len() + 1
};
let walker = WalkDir::new(dir_path);
let dir_iter = walker
.min_depth(1)
.into_iter()
.filter(|e| e.is_ok() && !filter_file(e.as_ref().unwrap(), tpl_extension));
for entry in dir_iter {
let entry = entry?;
let tpl_path = entry.path();
let tpl_file_path = entry.path().to_string_lossy();
let tpl_name = &tpl_file_path[prefix_len..tpl_file_path.len() - tpl_extension.len()];
let tpl_canonical_name = tpl_name.replace("\\", "/");
self.register_template_file(&tpl_canonical_name, &tpl_path)?;
}
Ok(())
}
pub fn register_template_source(
&mut self,
name: &str,
tpl_source: &mut Read,
) -> Result<(), TemplateFileError> {
let mut buf = String::new();
tpl_source
.read_to_string(&mut buf)
.map_err(|e| TemplateFileError::IOError(e, name.to_owned()))?;
self.register_template_string(name, buf)?;
Ok(())
}
pub fn unregister_template(&mut self, name: &str) {
self.templates.remove(name);
}
pub fn register_helper(
&mut self,
name: &str,
def: Box<HelperDef + 'static>,
) -> Option<Box<HelperDef + 'static>> {
self.helpers.insert(name.to_string(), def)
}
pub fn register_decorator(
&mut self,
name: &str,
def: Box<DirectiveDef + 'static>,
) -> Option<Box<DirectiveDef + 'static>> {
self.directives.insert(name.to_string(), def)
}
pub fn register_escape_fn<F: 'static + Fn(&str) -> String + Send + Sync>(
&mut self,
escape_fn: F,
) {
self.escape_fn = Box::new(escape_fn);
}
pub fn unregister_escape_fn(&mut self) {
self.escape_fn = Box::new(html_escape);
}
pub fn get_escape_fn(&self) -> &Fn(&str) -> String {
&*self.escape_fn
}
pub fn has_template(&self, name: &str) -> bool {
self.get_template(name).is_some()
}
pub fn get_template(&self, name: &str) -> Option<&Template> {
self.templates.get(name)
}
pub fn get_helper(&self, name: &str) -> Option<&Box<HelperDef + 'static>> {
self.helpers.get(name)
}
pub fn get_decorator(&self, name: &str) -> Option<&Box<DirectiveDef + 'static>> {
self.directives.get(name)
}
pub fn get_templates(&self) -> &HashMap<String, Template> {
&self.templates
}
pub fn clear_templates(&mut self) {
self.templates.clear();
}
fn render_to_output<T>(
&self,
name: &str,
data: &T,
output: &mut Output,
) -> Result<(), RenderError>
where
T: Serialize,
{
self.get_template(name)
.ok_or_else(|| RenderError::new(format!("Template not found: {}", name)))
.and_then(|t| {
let ctx = Context::wraps(data)?;
let mut render_context = RenderContext::new(t.name.as_ref());
t.render(self, &ctx, &mut render_context, output)
}).map(|_| ())
}
pub fn render<T>(&self, name: &str, data: &T) -> Result<String, RenderError>
where
T: Serialize,
{
let mut output = StringOutput::new();
self.render_to_output(name, data, &mut output)?;
output.into_string().map_err(RenderError::from)
}
pub fn render_to_write<T, W>(&self, name: &str, data: &T, writer: W) -> Result<(), RenderError>
where
T: Serialize,
W: Write,
{
let mut output = WriteOutput::new(writer);
self.render_to_output(name, data, &mut output)
}
pub fn render_template<T>(
&self,
template_string: &str,
data: &T,
) -> Result<String, TemplateRenderError>
where
T: Serialize,
{
let mut writer = StringWriter::new();
self.render_template_to_write(template_string, data, &mut writer)?;
Ok(writer.into_string())
}
pub fn render_template_to_write<T, W>(
&self,
template_string: &str,
data: &T,
writer: W,
) -> Result<(), TemplateRenderError>
where
T: Serialize,
W: Write,
{
let tpl = Template::compile2(template_string, self.source_map)?;
let ctx = Context::wraps(data)?;
let mut render_context = RenderContext::new(None);
let mut out = WriteOutput::new(writer);
tpl.render(self, &ctx, &mut render_context, &mut out)
.map(|_| ())
.map_err(TemplateRenderError::from)
}
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,
{
let mut tpl_str = String::new();
template_source
.read_to_string(&mut tpl_str)
.map_err(|e| TemplateRenderError::IOError(e, "Unnamed template source".to_owned()))?;
self.render_template_to_write(&tpl_str, data, writer)
}
}
#[cfg(test)]
mod test {
use context::Context;
use error::RenderError;
use helpers::HelperDef;
use output::Output;
use registry::Registry;
use render::{Helper, RenderContext, Renderable};
#[cfg(not(feature = "no_dir_source"))]
use std::fs::{DirBuilder, File};
#[cfg(not(feature = "no_dir_source"))]
use std::io::Write;
use support::str::StringWriter;
#[cfg(not(feature = "no_dir_source"))]
use tempfile::tempdir;
#[derive(Clone, Copy)]
struct DummyHelper;
impl HelperDef for DummyHelper {
fn call<'reg: 'rc, 'rc>(
&self,
h: &Helper<'reg, 'rc>,
r: &'reg Registry,
ctx: &Context,
rc: &mut RenderContext<'reg>,
out: &mut Output,
) -> Result<(), RenderError> {
h.template().unwrap().render(r, ctx, rc, out)
}
}
static DUMMY_HELPER: DummyHelper = DummyHelper;
#[test]
fn test_registry_operations() {
let mut r = Registry::new();
assert!(r.register_template_string("index", "<h1></h1>").is_ok());
assert!(r.register_template_string("index2", "<h2></h2>").is_ok());
assert_eq!(r.templates.len(), 2);
r.unregister_template("index");
assert_eq!(r.templates.len(), 1);
r.clear_templates();
assert_eq!(r.templates.len(), 0);
r.register_helper("dummy", Box::new(DUMMY_HELPER));
let num_helpers = 7;
let num_boolean_helpers = 9;
let num_custom_helpers = 1;
assert_eq!(
r.helpers.len(),
num_helpers + num_boolean_helpers + num_custom_helpers
);
}
#[test]
#[cfg(not(feature = "no_dir_source"))]
fn test_register_templates_directory() {
let mut r = Registry::new();
{
let dir = tempdir().unwrap();
assert_eq!(r.templates.len(), 0);
let file1_path = dir.path().join("t1.hbs");
let mut file1: File = File::create(&file1_path).unwrap();
writeln!(file1, "<h1>Hello {{world}}!</h1>").unwrap();
let file2_path = dir.path().join("t2.hbs");
let mut file2: File = File::create(&file2_path).unwrap();
writeln!(file2, "<h1>Hola {{world}}!</h1>").unwrap();
let file3_path = dir.path().join("t3.hbs");
let mut file3: File = File::create(&file3_path).unwrap();
writeln!(file3, "<h1>Hallo {{world}}!</h1>").unwrap();
let file4_path = dir.path().join(".t4.hbs");
let mut file4: File = File::create(&file4_path).unwrap();
writeln!(file4, "<h1>Hallo {{world}}!</h1>").unwrap();
r.register_templates_directory(".hbs", dir.path()).unwrap();
assert_eq!(r.templates.len(), 3);
assert_eq!(r.templates.contains_key("t1"), true);
assert_eq!(r.templates.contains_key("t2"), true);
assert_eq!(r.templates.contains_key("t3"), true);
assert_eq!(r.templates.contains_key("t4"), false);
drop(file1);
drop(file2);
drop(file3);
dir.close().unwrap();
}
{
let dir = tempdir().unwrap();
let file1_path = dir.path().join("t4.hbs");
let mut file1: File = File::create(&file1_path).unwrap();
writeln!(file1, "<h1>Hello {{world}}!</h1>").unwrap();
let file2_path = dir.path().join("t5.erb");
let mut file2: File = File::create(&file2_path).unwrap();
writeln!(file2, "<h1>Hello {{% world %}}!</h1>").unwrap();
let file3_path = dir.path().join("t6.html");
let mut file3: File = File::create(&file3_path).unwrap();
writeln!(file3, "<h1>Hello world!</h1>").unwrap();
r.register_templates_directory(".hbs", dir.path()).unwrap();
assert_eq!(r.templates.len(), 4);
assert_eq!(r.templates.contains_key("t4"), true);
drop(file1);
drop(file2);
drop(file3);
dir.close().unwrap();
}
{
let dir = tempdir().unwrap();
let _ = DirBuilder::new().create(dir.path().join("french")).unwrap();
let _ = DirBuilder::new()
.create(dir.path().join("portugese"))
.unwrap();
let _ = DirBuilder::new()
.create(dir.path().join("italian"))
.unwrap();
let file1_path = dir.path().join("french/t7.hbs");
let mut file1: File = File::create(&file1_path).unwrap();
writeln!(file1, "<h1>Bonjour {{world}}!</h1>").unwrap();
let file2_path = dir.path().join("portugese/t8.hbs");
let mut file2: File = File::create(&file2_path).unwrap();
writeln!(file2, "<h1>Ola {{world}}!</h1>").unwrap();
let file3_path = dir.path().join("italian/t9.hbs");
let mut file3: File = File::create(&file3_path).unwrap();
writeln!(file3, "<h1>Ciao {{world}}!</h1>").unwrap();
r.register_templates_directory(".hbs", dir.path()).unwrap();
assert_eq!(r.templates.len(), 7);
assert_eq!(r.templates.contains_key("french/t7"), true);
assert_eq!(r.templates.contains_key("portugese/t8"), true);
assert_eq!(r.templates.contains_key("italian/t9"), true);
drop(file1);
drop(file2);
drop(file3);
dir.close().unwrap();
}
}
#[test]
fn test_render_to_write() {
let mut r = Registry::new();
assert!(r.register_template_string("index", "<h1></h1>").is_ok());
let mut sw = StringWriter::new();
{
r.render_to_write("index", &(), &mut sw).ok().unwrap();
}
assert_eq!("<h1></h1>".to_string(), sw.into_string());
}
#[test]
fn test_escape_fn() {
let mut r = Registry::new();
let input = String::from("\"<>&");
r.register_template_string("test", String::from("{{this}}"))
.unwrap();
assert_eq!(""<>&", r.render("test", &input).unwrap());
r.register_escape_fn(|s| s.into());
assert_eq!("\"<>&", r.render("test", &input).unwrap());
r.unregister_escape_fn();
assert_eq!(""<>&", r.render("test", &input).unwrap());
}
#[test]
fn test_escape() {
let r = Registry::new();
let data = json!({"hello": "world"});
assert_eq!(
"{{hello}}",
r.render_template(r"\{{hello}}", &data).unwrap()
);
assert_eq!(
" {{hello}}",
r.render_template(r" \{{hello}}", &data).unwrap()
);
assert_eq!(r"\world", r.render_template(r"\\{{hello}}", &data).unwrap());
}
#[test]
fn test_strict_mode() {
let mut r = Registry::new();
assert!(!r.strict_mode());
r.set_strict_mode(true);
assert!(r.strict_mode());
let data = json!({
"the_only_key": "the_only_value"
});
assert!(
r.render_template("accessing the_only_key {{the_only_key}}", &data)
.is_ok()
);
assert!(
r.render_template("accessing non-exists key {{the_key_never_exists}}", &data)
.is_err()
);
let render_error = r
.render_template("accessing non-exists key {{the_key_never_exists}}", &data)
.unwrap_err();
assert_eq!(
render_error.as_render_error().unwrap().column_no.unwrap(),
26
);
let data2 = json!([1, 2, 3]);
assert!(
r.render_template("accessing valid array index {{this.[2]}}", &data2)
.is_ok()
);
assert!(
r.render_template("accessing invalid array index {{this.[3]}}", &data2)
.is_err()
);
let render_error2 = r
.render_template("accessing invalid array index {{this.[3]}}", &data2)
.unwrap_err();
assert_eq!(
render_error2.as_render_error().unwrap().column_no.unwrap(),
31
);
}
}