First version

1 files changed, 246 insertions, 0 deletions

diff --git a/src/pandoc.rs b/src/pandoc.rs
new file mode 100644
index 0000000..5ca84e7
--- /dev/null
+++ b/src/pandoc.rs
@@ -0,0 +1,246 @@
+//mod types;
+
+use crate::entities::*;
+
+use pandoc_types::definition::{Attr, Block, Inline, Meta, MetaValue, Pandoc};
+
+use std::collections::HashMap;
+
+impl Described<Entity> {
+    pub fn into_pandoc(
+        self,
+        descriptions: &HashMap<Usr, Description>,
+    ) -> (Pandoc, HashMap<Usr, Entity>) {
+        let mut meta = Meta::null();
+
+        let title = self.title();
+        let mut content_before = self.content_before(&descriptions);
+        let mut content_after = self.content_after(&descriptions);
+        let leftovers = self.leftovers();
+
+        meta.0.insert(
+            "title".to_string(),
+            MetaValue::MetaString(self.description.name),
+        );
+
+        let mut content = Vec::new();
+
+        content.push(Block::Header(1, Attr::null(), title));
+
+        content.append(&mut content_before);
+
+        if !self.description.detailed.is_empty() {
+            content.push(Block::Header(
+                2,
+                Attr::null(),
+                vec![Inline::Str(String::from("Description"))],
+            ));
+
+            content.push(Block::Div(
+                Attr(String::new(), vec![String::from("doc")], vec![]),
+                vec![raw_markdown(self.description.detailed)],
+            ));
+        }
+
+        content.append(&mut content_after);
+
+        (Pandoc(meta, content), leftovers)
+    }
+}
+
+// TODO: replace with single function so we can move out, and remove all of those clones
+trait PandocDisplay {
+    fn content_before(&self, _descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
+        vec![]
+    }
+
+    fn content_after(&self, _descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
+        vec![]
+    }
+
+    fn leftovers(&self) -> HashMap<Usr, Entity> {
+        HashMap::new()
+    }
+}
+
+impl Described<Entity> {
+    fn title(&self) -> Vec<Inline> {
+        match &self.entity {
+            Entity::Variable(variable) => vec![Inline::Code(
+                Attr(String::new(), vec![String::from("cpp")], vec![]),
+                variable.r#type.clone() + " " + &self.description.name,
+            )],
+            _ => vec![Inline::Code(Attr::null(), self.description.name.clone())],
+        }
+    }
+}
+
+impl PandocDisplay for Described<Entity> {
+    fn content_before(&self, descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
+        match &self.entity {
+            Entity::NameSpace(ns) => ns.content_before(descriptions),
+            Entity::Variable(var) => var.content_before(descriptions),
+            Entity::Function(func) => func.content_before(descriptions),
+            Entity::Class(class) => class.content_before(descriptions),
+        }
+    }
+
+    fn content_after(&self, descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
+        match &self.entity {
+            Entity::NameSpace(ns) => ns.content_after(descriptions),
+            Entity::Variable(var) => var.content_after(descriptions),
+            Entity::Function(func) => func.content_after(descriptions),
+            Entity::Class(class) => class.content_after(descriptions),
+        }
+    }
+
+    fn leftovers(&self) -> HashMap<Usr, Entity> {
+        match &self.entity {
+            Entity::NameSpace(ns) => ns.leftovers(),
+            Entity::Variable(var) => var.leftovers(),
+            Entity::Function(func) => func.leftovers(),
+            Entity::Class(class) => class.leftovers(),
+        }
+    }
+}
+
+impl PandocDisplay for NameSpace {
+    fn content_after(&self, descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
+        let mut content = Vec::new();
+
+        content.push(Block::Header(
+            2,
+            Attr::null(),
+            vec![Inline::Str("Members".to_string())],
+        ));
+
+        if let Some(member_list) = member_list(self.members.keys(), descriptions) {
+            content.push(member_list);
+        } else {
+            content.push(str_block(String::from("None")));
+        }
+
+        content
+    }
+
+    fn leftovers(&self) -> HashMap<Usr, Entity> {
+        self.members.clone()
+    }
+}
+
+impl PandocDisplay for Class {
+    fn content_after(&self, descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
+        let mut content = Vec::new();
+
+        if let Some(member_types) = member_list(&self.member_types, descriptions) {
+            content.push(Block::Header(
+                2,
+                Attr::null(),
+                vec![Inline::Str("Member Types".to_string())],
+            ));
+
+            content.push(member_types);
+        }
+
+        if let Some(member_functions) = member_list(self.member_functions.keys(), descriptions) {
+            content.push(Block::Header(
+                2,
+                Attr::null(),
+                vec![Inline::Str("Member Functions".to_string())],
+            ));
+
+            content.push(member_functions);
+        }
+
+        if let Some(member_variables) = member_list(self.member_variables.keys(), descriptions) {
+            content.push(Block::Header(
+                2,
+                Attr::null(),
+                vec![Inline::Str("Member Variables".to_string())],
+            ));
+
+            content.push(member_variables);
+        }
+
+        content
+    }
+
+    fn leftovers(&self) -> HashMap<Usr, Entity> {
+        self.member_functions
+            .iter()
+            .map(|(usr, func)| (usr.clone(), Entity::from(func.clone())))
+            .chain(
+                self.member_variables
+                    .iter()
+                    .map(|(usr, var)| (usr.clone(), Entity::from(var.clone()))),
+            )
+            .collect()
+    }
+}
+
+impl PandocDisplay for Variable {}
+
+impl PandocDisplay for Function {}
+
+fn str_block(content: String) -> Block {
+    Block::Plain(vec![Inline::Str(content)])
+}
+
+fn entity_link(usr: &Usr, name: String) -> Inline {
+    use pandoc_types::definition::Target;
+    use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
+
+    use std::iter::once;
+
+    // https://url.spec.whatwg.org/#fragment-percent-encode-set
+    const FRAGMENT: &AsciiSet = &CONTROLS
+        .add(b' ')
+        .add(b'"')
+        .add(b'<')
+        .add(b'>')
+        .add(b'`')
+        .add(b'#')
+        .add(b'?')
+        .add(b'{')
+        .add(b'}');
+
+    Inline::Link(
+        Attr::null(),
+        vec![Inline::Code(Attr::null(), name)],
+        Target(
+            once("./")
+                .chain(utf8_percent_encode(&usr.0, FRAGMENT))
+                .collect(),
+            String::new(),
+        ),
+    )
+}
+
+fn raw_markdown(text: String) -> Block {
+    use pandoc_types::definition::Format;
+    Block::RawBlock(Format(String::from("markdown")), text)
+}
+
+fn member_list<'a>(
+    members: impl IntoIterator<Item = &'a Usr>,
+    descriptions: &HashMap<Usr, Description>,
+) -> Option<Block> {
+    let definitions: Vec<(Vec<Inline>, Vec<Vec<Block>>)> = members
+        .into_iter()
+        .filter_map(|usr| {
+            let name = &descriptions.get(usr)?.name;
+            Some((
+                vec![entity_link(usr, name.clone())],
+                vec![vec![str_block(
+                    descriptions.get(usr).unwrap().brief.clone(),
+                )]],
+            ))
+        })
+        .collect();
+
+    if definitions.is_empty() {
+        None
+    } else {
+        Some(Block::DefinitionList(definitions))
+    }
+}