entities rework, allow "inline" documentation, merge config with cli

1 files changed, 62 insertions, 142 deletions

diff --git a/src/pandoc.rs b/src/pandoc.rs
index 5ca84e7..8477f28 100644
--- a/src/pandoc.rs
+++ b/src/pandoc.rs
@@ -1,186 +1,106 @@
-//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())],
-        }
-    }
-}
+pub(crate) fn into_pandoc<'e>(
+    entity: &'e dyn Entity,
+    description: &Description,
+    descriptions: &HashMap<Usr, Description>,
+) -> (Pandoc, HashMap<&'e Usr, &'e DynEntity>) {
+    let mut meta = Meta::null();
 
-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),
-        }
-    }
+    let title = vec![Inline::Code(Attr::null(), description.name.clone())];
 
-    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),
-        }
-    }
+    meta.0.insert(
+        "title".to_string(),
+        MetaValue::MetaString(description.name.clone()),
+    );
 
-    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(),
-        }
-    }
-}
+    let mut content = Vec::new();
 
-impl PandocDisplay for NameSpace {
-    fn content_after(&self, descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
-        let mut content = Vec::new();
+    content.push(Block::Header(1, Attr::null(), title));
 
+    if !description.detailed.is_empty() {
         content.push(Block::Header(
             2,
             Attr::null(),
-            vec![Inline::Str("Members".to_string())],
+            vec![Inline::Str(String::from("Description"))],
         ));
 
-        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()
+        content.push(Block::Div(
+            Attr(String::new(), vec![String::from("doc")], vec![]),
+            vec![raw_markdown(description.detailed.clone())],
+        ));
     }
-}
 
-impl PandocDisplay for Class {
-    fn content_after(&self, descriptions: &HashMap<Usr, Description>) -> Vec<Block> {
-        let mut content = Vec::new();
+    let separate_children = entity.separate_children();
+    let embeddable_children = entity.embeddable_children();
 
-        if let Some(member_types) = member_list(&self.member_types, descriptions) {
+    for section in &separate_children {
+        if let Some(members_list) = member_list(
+            section.children.iter().map(|&(usr, _child)| usr),
+            descriptions,
+        ) {
             content.push(Block::Header(
                 2,
                 Attr::null(),
-                vec![Inline::Str("Member Types".to_string())],
+                vec![Inline::Str(String::from(section.name))],
             ));
 
-            content.push(member_types);
+            content.push(members_list);
         }
+    }
+
+    let mut embedded_documentation = Vec::new();
 
-        if let Some(member_functions) = member_list(self.member_functions.keys(), descriptions) {
+    for section in &embeddable_children {
+        if let Some(members_list) = member_list(
+            section.children.iter().map(|&(usr, _child)| usr),
+            descriptions,
+        ) {
             content.push(Block::Header(
                 2,
                 Attr::null(),
-                vec![Inline::Str("Member Functions".to_string())],
+                vec![Inline::Str(String::from(section.name))],
             ));
 
-            content.push(member_functions);
-        }
+            content.push(members_list);
 
-        if let Some(member_variables) = member_list(self.member_variables.keys(), descriptions) {
-            content.push(Block::Header(
+            embedded_documentation.push(Block::Header(
                 2,
                 Attr::null(),
-                vec![Inline::Str("Member Variables".to_string())],
+                vec![Inline::Str(String::from(section.name) + " Documentation")],
             ));
 
-            content.push(member_variables);
-        }
+            for (usr, _child) in &section.children {
+                let child_doc = descriptions.get(usr).unwrap();
 
-        content
-    }
+                embedded_documentation.push(Block::Header(
+                    3,
+                    Attr::null(),
+                    vec![Inline::Code(Attr::null(), String::from(&child_doc.name))],
+                ));
 
-    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()
+                embedded_documentation.push(Block::Div(
+                    Attr(String::new(), vec![String::from("doc")], vec![]),
+                    vec![raw_markdown(child_doc.detailed.clone())],
+                ));
+            }
+        }
     }
-}
 
-impl PandocDisplay for Variable {}
+    content.append(&mut embedded_documentation);
 
-impl PandocDisplay for Function {}
+    let leftovers = separate_children
+        .iter()
+        .map(|section| section.children.clone())
+        .flatten()
+        .collect();
+
+    (Pandoc(meta, content), leftovers)
+}
 
 fn str_block(content: String) -> Block {
     Block::Plain(vec![Inline::Str(content)])