renderer.rs

use crate::content::{ ContentDatabase };
use crate::errors::{ Error, Result };
use axum_messages::{ Level, Messages };
use serde::{ Serialize };
use tera::{ Context, Tera };
use std::path::{ Path, PathBuf };

#[derive(Debug)]
pub struct Renderer {
  site_context: SiteContext,
  _theme_path: PathBuf,
  tera: Tera,
}

impl Renderer {
  pub fn new(site_title: &str, theme_path: &Path) -> Result<Renderer> {
    let site_context = SiteContext {
      title: site_title.to_string(),
      version: env!("CARGO_PKG_VERSION").to_string(),
    };

    let theme_glob = theme_path
      .join("templates")
      .join("**")
      .join("*.tera.*")
      .to_str()
      .expect("Theme path should be valid UTF-8")
      .to_string();

    let renderer = Renderer {
      site_context,
      _theme_path: theme_path.to_path_buf(),
      tera: Tera::new(&theme_glob)?,
    };

    Ok(renderer)
  }

  pub fn render_authenticate(&self, messages: Messages) -> Result<String> {
    let context = self.default_context(messages);
    let rendered = self.tera.render("authenticate.tera.html", &context)?;
    Ok(rendered)
  }

  pub fn render_new_page(&self, messages: Messages) -> Result<String> {
    let context = self.default_context(messages);
    let rendered = self.tera.render("new_page.tera.html", &context)?;
    Ok(rendered)
  }

  pub fn render_view_page(&self, database: &ContentDatabase, messages: Messages, slug: &str) -> Result<String> {
    let context = self.view_page_context(database, messages, slug)?;
    let rendered = self.tera.render("view_page.tera.html", &context)?;
    Ok(rendered)
  }

  pub fn render_edit_page(&self, database: &ContentDatabase, messages: Messages, slug: &str) -> Result<String> {
    let context = self.edit_page_context(database, messages, slug)?;
    let rendered = self.tera.render("edit_page.tera.html", &context)?;
    Ok(rendered)
  }

  pub fn render_all_tags(&self, database: &ContentDatabase, messages: Messages) -> Result<String> {
    let tags = database
      .find_all_tags()
      .into_iter()
      .collect::<Vec<_>>();

    let context = self.tags_context(database, messages, &tags)?;
    let rendered = self.tera.render("tags.tera.html", &context)?;
    Ok(rendered)
  }

  pub fn render_in_tags(&self, database: &ContentDatabase, messages: Messages, tags: &[String]) -> Result<String> {
    let context = self.tags_context(database, messages, tags)?;
    let rendered = self.tera.render("tags.tera.html", &context)?;
    Ok(rendered)
  }

  fn default_context(&self, messages: Messages) -> Context {
    let mut context = Context::new();
    context.insert("site", &self.site_context);
    context.insert("messages", &self.messages_context(messages));
    context
  }

  fn view_page_context(&self, database: &ContentDatabase, messages: Messages, slug: &str) -> Result<Context> {
    let Some(page) = database.find_page(slug) else {
      return Err(Error::PageNotFound(slug.to_string()));
    };

    let page_context = PageContext {
      slug: slug.to_string(),
      title: page.title().to_string(),
      content: database.load_page_content_html(slug)?,
      tags: page.tags().to_vec(),
    };

    let mut context = Context::new();
    context.insert("site", &self.site_context);
    context.insert("messages", &self.messages_context(messages));
    context.insert("page", &page_context);
    Ok(context)
  }

  fn edit_page_context(&self, database: &ContentDatabase, messages: Messages, slug: &str) -> Result<Context> {
    let Some(page) = database.find_page(slug) else {
      return Err(Error::PageNotFound(slug.to_string()));
    };

    let page_context = PageContext {
      slug: slug.to_string(),
      title: page.title().to_string(),
      content: database.load_page_content_markdown(slug)?,
      tags: page.tags().to_vec(),
    };

    let mut context = Context::new();
    context.insert("site", &self.site_context);
    context.insert("messages", &self.messages_context(messages));
    context.insert("page", &page_context);
    Ok(context)
  }

  fn tags_context(&self, database: &ContentDatabase, messages: Messages, tags: &[String]) -> Result<Context> {
    let links = database
      .iter_pages_tagged(tags)
      .map(|page| LinkContext {
        slug: page.slug().to_string(),
        title: page.title().to_string(),
      })
      .collect();

    let tags_context = TagsContext {
      tags: tags.to_vec(),
      links,
    };

    let mut context = Context::new();
    context.insert("site", &self.site_context);
    context.insert("messages", &self.messages_context(messages));
    context.insert("tags", &tags_context);
    Ok(context)
  }

  fn messages_context(&self, messages: Messages) -> Vec<MessageContext> {
    messages
      .into_iter()
      .map(|m| MessageContext {
        level: match m.level {
          Level::Error => String::from("error"),
          Level::Warning => String::from("warning"),
          _ => String::from("message"),
        },
        content: m.message.clone(),
      })
      .collect()
  }
}

#[derive(Debug, Serialize)]
struct SiteContext {
  title: String,
  version: String,
}

#[derive(Debug, Serialize)]
struct MessageContext {
  level: String,
  content: String,
}

#[derive(Debug, Serialize)]
struct PageContext {
  slug: String,
  title: String,
  content: String,
  tags: Vec<String>,
}

#[derive(Debug, Serialize)]
struct TagsContext {
  tags: Vec<String>,
  links: Vec<LinkContext>,
}

#[derive(Debug, Serialize)]
struct LinkContext {
  slug: String,
  title: String,
}