lssg_lib/renderer/modules/

default_module.rs

use std::collections::{HashMap, HashSet};

use lazy_static::lazy_static;
use log::warn;

use serde_extensions::Overwrite;

use crate::{
    html,
    html::{to_attributes, DomNodeKind, Html},
    lmarkdown::Token,
    lssg_error::LssgError,
    sitetree::{Page, Relation, SiteNode, SiteNodeKind, SiteTree, Stylesheet},
    tree::{Node, DFS},
};

use crate::renderer::{RenderContext, RendererModule, TokenRenderer};

const DEFAULT_STYLESHEET: &[u8] = include_bytes!("./default_stylesheet.css");

lazy_static! {
    static ref WATERMARK: Html = html!(
        r#"<footer id="watermark">Generated by <a href="https://github.com/lyr-7D1h/lssg">LSSG</a></footer>"#
    );
}

#[derive(Debug, Clone, Overwrite)]
struct PropegatedOptions {
    /// Add extra resources
    pub title: String,
    /// Translates to meta tags <https://www.w3schools.com/tags/tag_meta.asp>
    pub meta: HashMap<String, String>,
    /// Lang attribute ("en") <https://www.w3schools.com/tags/ref_language_codes.asp>
    pub language: String,
}
impl Default for PropegatedOptions {
    fn default() -> Self {
        Self {
            // favicon: None,
            // stylesheets: vec![],
            meta: HashMap::new(),
            title: String::new(),
            language: "en".into(),
        }
    }
}

#[derive(Debug, Clone, Overwrite)]
pub struct SinglePageOptions {
    pub disable_parent_resources: bool,
}
impl Default for SinglePageOptions {
    fn default() -> Self {
        Self {
            disable_parent_resources: false,
        }
    }
}

fn create_options_map(
    module: &DefaultModule,
    site_tree: &SiteTree,
) -> Result<HashMap<usize, PropegatedOptions>, LssgError> {
    let mut options_map: HashMap<usize, PropegatedOptions> = HashMap::new();
    for id in DFS::new(site_tree) {
        if let SiteNodeKind::Page(page) = &site_tree[id].kind {
            if let Some(parent) = site_tree.page_parent(id) {
                if let Some(parent_options) = options_map.get(&parent) {
                    let parent_options = parent_options.clone();
                    let options: PropegatedOptions =
                        module.options_with_default(page, parent_options);
                    options_map.insert(id, options.clone());
                    continue;
                }
            }

            let options: PropegatedOptions = module.options(page);
            options_map.insert(id, options.clone());
        }
    }
    Ok(options_map)
}

/// Implements all basic default behavior, like rendering all tokens and adding meta tags and title to head
pub struct DefaultModule {
    /// Map of all site pages to options
    options_map: HashMap<usize, PropegatedOptions>,
}

impl DefaultModule {
    pub fn new() -> Self {
        Self {
            options_map: HashMap::new(),
        }
    }
}

impl RendererModule for DefaultModule {
    fn id(&self) -> &'static str {
        return "default";
    }

    /// Add all resources from ResourceOptions to SiteTree
    fn init(&mut self, site_tree: &mut SiteTree) -> Result<(), LssgError> {
        let mut relation_map = HashMap::new();

        let pages: Vec<usize> = DFS::new(site_tree)
            .filter(|id| site_tree[*id].kind.is_page())
            .collect();

        let default_stylesheet = site_tree.add(SiteNode::stylesheet(
            "default.css",
            site_tree.root(),
            Stylesheet::from_readable(DEFAULT_STYLESHEET)?,
        ))?;

        // propegate relations to stylesheets and favicon from parent to child
        for id in pages {
            site_tree.add_link(id, default_stylesheet);

            // skip page if disabled
            if let SiteNodeKind::Page(page) = &site_tree[id].kind {
                let opts: SinglePageOptions = self.options(page);
                if opts.disable_parent_resources {
                    continue;
                }
            }

            // get the set of links to favicon and stylesheets
            let mut set: HashSet<usize> = site_tree
                .links_from(id)
                .into_iter()
                .filter_map(|link| match link.relation {
                    Relation::External | Relation::Discovered { .. } => {
                        let node = &site_tree[link.to];
                        match node.kind {
                            SiteNodeKind::Stylesheet { .. } => Some(link.to),
                            SiteNodeKind::Resource { .. } if node.name == "favicon.ico" => {
                                Some(link.to)
                            }
                            _ => None,
                        }
                    }
                    _ => None,
                })
                .collect();

            // update set with parent and add any links from parent
            if let Some(parent) = site_tree.page_parent(id) {
                if let Some(parent_set) = relation_map.get(&parent) {
                    // add links from parent_set without the ones it already has
                    for to in (parent_set - &set).iter() {
                        site_tree.add_link(id, *to);
                    }
                    set = set.union(parent_set).cloned().collect();
                }
            }
            relation_map.insert(id, set);
        }

        Ok(())
    }

    fn after_init(&mut self, site_tree: &SiteTree) -> Result<(), LssgError> {
        // save options map after site tree has been created to get all pages
        self.options_map = create_options_map(&self, site_tree)?;
        Ok(())
    }

    fn render_page<'n>(&mut self, dom: &mut crate::html::DomTree, context: &RenderContext<'n>) {
        let site_id = context.site_id;
        let site_tree = context.site_tree;

        let options = self
            .options_map
            .get(&site_id)
            .expect("expected options map to contain all page ids");

        // Add language to html tag
        let html = dom.get_elements_by_tag_name("html")[0];
        if let DomNodeKind::Element { attributes, .. } = &mut dom.get_mut(html).kind {
            attributes.insert("lang".to_owned(), options.language.clone());
        }

        // fill head
        let head = dom.get_elements_by_tag_name("head")[0];

        let title = dom.add_element(head, "title");
        dom.add_text(title, options.title.clone());

        for link in site_tree.links_from(site_id) {
            match link.relation {
                Relation::External | Relation::Discovered { .. } => match site_tree[link.to].kind {
                    SiteNodeKind::Resource { .. } if site_tree[link.to].name == "favicon.ico" => {
                        dom.add_element_with_attributes(
                            head,
                            "link",
                            to_attributes([
                                ("rel", "icon"),
                                ("type", "image/x-icon"),
                                ("href", &site_tree.path(link.to)),
                            ]),
                        );
                    }
                    SiteNodeKind::Stylesheet { .. } => {
                        dom.add_element_with_attributes(
                            head,
                            "link",
                            to_attributes([
                                ("rel", "stylesheet"),
                                ("href", &site_tree.path(link.to)),
                            ]),
                        );
                    }
                    _ => {}
                },
                _ => {}
            }
        }
        dom.add_element_with_attributes(
            head,
            "meta",
            to_attributes([
                ("name", "viewport"),
                ("content", r#"width=device-width, initial-scale=1"#),
            ]),
        );
        dom.add_element_with_attributes(head, "meta", to_attributes([("charset", "utf-8")]));
        for (key, value) in &options.meta {
            dom.add_element_with_attributes(
                head,
                "meta",
                to_attributes([("name", key), ("content", value)]),
            );
        }
    }

    fn render_body<'n>(
        &mut self,
        dom: &mut crate::html::DomTree,
        context: &super::RenderContext<'n>,
        parent_id: usize,
        token: &crate::lmarkdown::Token,
        tr: &mut TokenRenderer,
    ) -> bool {
        match token {
            Token::Attributes { .. } | Token::Comment { .. } | Token::EOF | Token::Space=> {}
            Token::Break { raw: _ } => {
                dom.add_element(parent_id, "br");
            }
            Token::Heading { depth, tokens } => {
                let parent_id = dom.add_element(parent_id, format!("h{depth}"));
                tr.render(dom, context, parent_id, tokens);
            }
            Token::Paragraph { tokens } => {
                let parent_id = dom.add_element(parent_id, "p");
                tr.render(dom, context, parent_id, tokens);
            }
            Token::Bold { text } => {
                let parent_id = dom.add_element(parent_id, "b");
                dom.add_text(parent_id, text);
            }
            Token::Italic { text } => {
                let parent_id = dom.add_element(parent_id, "i");
                dom.add_text(parent_id, text);
            }
            Token::Code { code, language: _ } => {
                let parent_id = dom.add_element(parent_id, "code");
                dom.add_text(parent_id, code);
            }
            Token::Link { tokens: text, href } => {
                if text.len() == 0 {
                    return true;
                }

                // external link
                if is_href_external(href) {
                    let a = dom.add_element_with_attributes(
                        parent_id,
                        "a",
                        to_attributes([("href", href)]),
                    );

                    tr.render(dom, context, a, text);

                    dom.add_html(parent_id, html!(r##"<svg width="1em" height="1em" viewBox="0 0 24 24" style="cursor:pointer"><g stroke-width="2.1" stroke="#666" fill="none" stroke-linecap="round" stroke-linejoin="round"><polyline points="17 13.5 17 19.5 5 19.5 5 7.5 11 7.5"></polyline><path d="M14,4.5 L20,4.5 L20,10.5 M20,4.5 L11,13.5"></path></g></svg>"##));
                    return true;
                }

                if Page::is_href_to_page(href) {
                    let to_id = context
                        .site_tree
                        .links_from(context.site_id)
                        .into_iter()
                        .find_map(|l| {
                            if let Relation::Discovered { raw_path: path } = &l.relation {
                                if path == href {
                                    return Some(l.to);
                                }
                            }
                            None
                        });
                    if let Some(to_id) = to_id {
                        let rel_path = context.site_tree.path(to_id);
                        let parent_id = dom.add_element_with_attributes(
                            parent_id,
                            "a",
                            to_attributes([("href", rel_path)]),
                        );
                        tr.render(dom, context, parent_id, text);
                        return true;
                    }
                    warn!("Could not find node where {href:?} points to");
                }

                let parent_id = dom.add_element_with_attributes(
                    parent_id,
                    "a",
                    to_attributes([("href", href)]),
                );
                tr.render(dom, context, parent_id, text);
            }
            Token::Text { text } => {
                dom.add_text(parent_id, text);
            }
            Token::Html {
                tag,
                attributes,
                tokens,
            } => match tag.as_str() {
                "links" if attributes.contains_key("boxes") => {
                    let parent_id = dom
                        .add_html(parent_id, html!(r#"<nav class="links"></nav>"#))
                        .unwrap();
                    for t in tokens {
                        match t {
                            Token::Link { tokens, href } => {
                                let href = if Page::is_href_to_page(href) {
                                    let to_id = context
                                        .site_tree
                                        .links_from(context.site_id)
                                        .into_iter()
                                        .find_map(|l| {
                                            if let Relation::Discovered { raw_path: path } =
                                                &l.relation
                                            {
                                                if path == href {
                                                    return Some(l.to);
                                                }
                                            }
                                            None
                                        });

                                    match to_id {
                                        Some(to_id) => context.site_tree.path(to_id),
                                        None => {
                                            warn!("Could not find node where {href:?} points to");
                                            return true;
                                        }
                                    }
                                } else {
                                    href.into()
                                };

                                let a = dom
                                    .add_html(
                                        parent_id,
                                        html!(r#"<a href="{href}"><div class="box"></div></a>"#),
                                    )
                                    .unwrap();
                                let div = dom[a].children()[0];
                                tr.render(dom, context, div, tokens);
                            }
                            _ => {}
                        }
                    }
                }
                _ => {
                    let parent_id =
                        dom.add_element_with_attributes(parent_id, tag, attributes.clone());
                    tr.render(dom, context, parent_id, tokens);
                }
            },
        };
        true
    }

    fn after_render<'n>(&mut self, dom: &mut crate::html::DomTree, _: &RenderContext<'n>) {
        let body = dom.body();
        // move all dom elements to under #content
        let children = dom[body].children().clone();
        let content =
            dom.add_element_with_attributes(body, "div", to_attributes([("id", "content")]));
        for child in children.into_iter() {
            dom.set_parent(child, content);
        }

        // add watermark
        dom.add_html(body, WATERMARK.clone());
    }
}

pub fn is_href_external(href: &str) -> bool {
    return href.starts_with("http") || href.starts_with("mailto:");
}