Struct lib::templates::template::TemplateRender

pub struct TemplateRender {
    pub path: PathBuf,
    pub filename: String,
    pub contents: String,
}

A struct representing a rendered template.

Fields

path: PathBuf

The path to where the template will be written to.

This path should be relative to the final output directory as this path is appended to it to determine the the full output path.

filename: String

The final output filename.

contents: String

The rendered content.

Implementations

impl TemplateRender

pub fn new(path: PathBuf, filename: String, contents: String) -> Self

Creates a new instance of TemplateRender.

Examples found in repository

src/lib/templates/manager.rs (line 380)

    fn render_book(
        &self,
        entry: &Entry,
        template: &TemplateRaw,
        names: &NamesRender,
        path: PathBuf,
    ) -> Result<TemplateRender> {
        let filename = names.book.clone();

        let context = TemplateContext::book(entry, names);

        let contents = self
            .registry
            .render(&template.id, &Context::from_serialize(context)?)?;

        Ok(TemplateRender::new(path, filename, contents))
    }

    /// Renders an [`Entry`]'s [`Annotation`]s to multiple [`TemplateRender`]s.
    ///
    /// # Arguments
    ///
    /// * `entry` - The [`Entry`] containing the [`Annotation`]s to render.
    /// * `template` - The [`TemplateRaw`] to render with.
    /// * `names` - A [`NamesRender`] instance generated from the [`Entry`] and
    /// a [`TemplateRaw`].
    /// * `path` - The path to where the template will be written to. This path
    /// should be relative to the final output directory.
    ///
    /// # Errors
    ///
    /// Will return `Err` if Tera encounters an error.
    fn render_annotations(
        &self,
        entry: &Entry,
        template: &TemplateRaw,
        names: &NamesRender,
        path: &Path,
    ) -> Result<Vec<TemplateRender>> {
        let mut renders = Vec::with_capacity(entry.annotations.len());

        for annotation in &entry.annotations {
            // This should theoretically never fail as the `NamesRender`
            // instance is created from the `Entry`. This means they contain
            // the same exact keys and it should therefore be safe to unwrap.
            // An error here would be critical and should fail.
            let filename = names
                .annotations
                .get(&annotation.metadata.id)
                .expect("`NamesRender` instance missing `Annotation` present in `Entry`")
                .filename
                .clone();

            let context = TemplateContext::annotation(&entry.book, annotation, names);

            let contents = self
                .registry
                .render(&template.id, &Context::from_serialize(context)?)?;

            renders.push(TemplateRender::new(path.to_owned(), filename, contents));
        }

        Ok(renders)
    }

Trait Implementations

impl Debug for TemplateRender

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

Formats the value using the given formatter.

impl Default for TemplateRender

fn default() -> TemplateRender

Returns the “default value” for a type.