natter/src/intermediate/page.rs

use std::path::PathBuf;

use crate::error::CustomError;

use super::footnote_definition::IRealFootnoteDefinition;

use super::IDocumentElement;
use super::IHeading;
use super::ISection;
use super::RefRegistry;

#[derive(Debug)]
pub(crate) struct BlogPostPage {
    /// Relative path from the root of the blog post.
    pub(crate) path: PathBuf,

    pub(crate) title: Option<String>,

    pub(crate) children: Vec<IDocumentElement>,

    pub(crate) footnotes: Vec<IRealFootnoteDefinition>,
}

impl BlogPostPage {
    // TODO: Move path into the registry so I can give this a standard interface like the others.
    pub(crate) async fn new<'a, 'b, 'parse, P: Into<PathBuf>>(
        path: P,
        registry: RefRegistry<'b, 'parse>,
        document: &'b organic::types::Document<'parse>,
    ) -> Result<BlogPostPage, CustomError> {
        let path = path.into();
        let mut children = Vec::new();
        if let Some(section) = document.zeroth_section.as_ref() {
            children.push(IDocumentElement::Section(
                ISection::new(registry.clone(), section).await?,
            ));
        }
        for heading in document.children.iter() {
            children.push(IDocumentElement::Heading(
                IHeading::new(registry.clone(), heading).await?,
            ));
        }

        let footnotes = {
            let footnote_definitions: Vec<_> = {
                let registry = registry.lock().unwrap();
                let ret = registry
                    .get_footnote_ids()
                    .map(|(id, def)| (id, def.clone()))
                    .collect();
                ret
            };
            let mut ret = Vec::new();
            for (id, def) in footnote_definitions.into_iter() {
                ret.push(IRealFootnoteDefinition::new(registry.clone(), id, def).await?);
            }
            ret
        };

        Ok(BlogPostPage {
            path,
            title: get_title(&document),
            children,
            footnotes,
        })
    }

    /// Get the output path relative to the post directory.
    pub(crate) fn get_output_path(&self) -> PathBuf {
        let mut ret = self.path.clone();
        ret.set_extension("html");
        ret
    }
}

fn get_title(document: &organic::types::Document<'_>) -> Option<String> {
    organic::types::AstNode::from(document)
        .iter_all_ast_nodes()
        .filter_map(|node| match node {
            organic::types::AstNode::Keyword(kw) if kw.key.eq_ignore_ascii_case("title") => {
                Some(kw)
            }
            _ => None,
        })
        .last()
        .map(|kw| kw.value.to_owned())
}