Struct ramhorns::Ramhorns

pub struct Ramhorns<H = FnvBuildHasher> { /* private fields */ }

Aggregator for Templates, that allows them to be loaded from the file system and use partials: {{>partial}}

For faster or DOS-resistant hashes, it is recommended to use aHash RandomState as hasher.

Implementations

impl<H: BuildHasher + Default> Ramhorns<H>

pub fn from_folder<P: AsRef<Path>>(dir: P) -> Result<Self, Error>

Loads all the .html files as templates from the given folder, making them accessible via their path, joining partials as required. If a custom extension is wanted, see [from_folder_with_extension]

let tpls: Ramhorns = Ramhorns::from_folder("./templates").unwrap();
let content = "I am the content";
let rendered = tpls.get("hello.html").unwrap().render(&content);

pub fn from_folder_with_extension<P: AsRef<Path>>( dir: P, extension: &str ) -> Result<Self, Error>

Loads all files with the extension given in the extension parameter as templates from the given folder, making them accessible via their path, joining partials as required.

let tpls: Ramhorns = Ramhorns::from_folder_with_extension("./templates", "mustache").unwrap();
let content = "I am the content";
let rendered = tpls.get("hello.mustache").unwrap().render(&content);

pub fn extend_from_folder<P: AsRef<Path>>( &mut self, dir: P ) -> Result<(), Error>

Extends the template collection with files with .html extension from the given folder, making them accessible via their path, joining partials as required. If there is a file with the same name as a previously loaded template or partial, it will not be loaded.

pub fn extend_from_folder_with_extension<P: AsRef<Path>>( &mut self, dir: P, extension: &str ) -> Result<(), Error>

Extends the template collection with files with extension from the given folder, making them accessible via their path, joining partials as required. If there is a file with the same name as a previously loaded template or partial, it will not be loaded.

pub fn lazy<P: AsRef<Path>>(dir: P) -> Result<Self, Error>

Create a new empty aggregator for a given folder. This won’t do anything until a template has been added using from_file.

let mut tpls: Ramhorns = Ramhorns::lazy("./templates").unwrap();
let content = "I am the content";
let rendered = tpls.from_file("hello.html").unwrap().render(&content);

pub fn get(&self, name: &str) -> Option<&Template<'static>>

Get the template with the given name, if it exists.

pub fn from_file(&mut self, name: &str) -> Result<&Template<'static>, Error>

Get the template with the given name. If the template doesn’t exist, it will be loaded from file and parsed first.

Use this method in tandem with lazy.

pub fn insert<S, T>(&mut self, src: S, name: T) -> Result<(), Error>

where S: Into<Cow<'static, str>>, T: Into<Cow<'static, str>>,

Insert a template parsed from src with the name name. If a template with this name is present, it gets replaced.

Warning

This can load partials from an arbitrary path. Use only with trusted source.

Trait Implementations

impl<H> Debug for Ramhorns<H>

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

Formats the value using the given formatter.