Big refactoring

- entities should be more coherent when parsing multiple files
- well defined, language agnostic entity tree
- each module has its own configuration
- less dead code

1 files changed, 0 insertions, 216 deletions

diff --git a/src/entities.rs b/src/entities.rs
deleted file mode 100644
index 89905c6..0000000
--- a/src/entities.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-use std::collections::HashMap;
-
-pub(crate) type DynEntity = dyn Entity + Sync + Send;
-
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub(crate) struct Usr(pub(crate) String);
-
-pub(crate) struct EntitiesManager {
-    toplevel_entities: HashMap<Usr, Box<DynEntity>>,
-    descriptions: HashMap<Usr, Description>,
-}
-
-pub(crate) struct EntitiesManagerComponents {
-    pub(crate) toplevel_entities: HashMap<Usr, Box<DynEntity>>,
-    pub(crate) descriptions: HashMap<Usr, Description>,
-}
-
-impl EntitiesManager {
-    pub fn new() -> Self {
-        EntitiesManager {
-            toplevel_entities: HashMap::new(),
-            descriptions: HashMap::new(),
-        }
-    }
-
-    pub fn insert(&mut self, usr: Usr, description: Description) {
-        info!("Found entity {:?}", description.name);
-        self.descriptions.insert(usr, description);
-    }
-
-    pub fn insert_toplevel(&mut self, usr: Usr, entity: Box<DynEntity>) {
-        self.toplevel_entities.insert(usr, entity);
-    }
-
-    pub fn decompose(self) -> EntitiesManagerComponents {
-        EntitiesManagerComponents {
-            toplevel_entities: self.toplevel_entities,
-            descriptions: self.descriptions,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub(crate) struct Description {
-    pub(crate) name: String,
-    pub(crate) brief: String,
-    pub(crate) detailed: String,
-}
-
-impl Description {
-    pub(crate) fn with_name(name: String) -> Self {
-        Description {
-            name,
-            ..Default::default()
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Described<T> {
-    pub(crate) description: Description,
-    pub(crate) entity: T,
-}
-
-pub(crate) struct ChildGroup<'a> {
-    pub(crate) name: &'static str,
-    pub(crate) children: Vec<(&'a Usr, &'a DynEntity)>,
-}
-
-pub(crate) trait Entity {
-    fn kind_name(&self) -> &'static str;
-    fn embeddable_children(&self) -> Vec<ChildGroup> {
-        Vec::new()
-    }
-    fn separate_children(&self) -> Vec<ChildGroup> {
-        Vec::new()
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct NameSpace {
-    // TODO: replace with Vec to keep order
-    pub(crate) members: HashMap<Usr, NameSpaceChild>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum NameSpaceChild {
-    NameSpace(NameSpace),
-    Class(Class),
-    Variable(Variable),
-    Function(Function),
-}
-
-impl Entity for NameSpace {
-    fn kind_name(&self) -> &'static str {
-        "namespace"
-    }
-
-    fn embeddable_children(&self) -> Vec<ChildGroup> {
-        let mut variables = Vec::new();
-        let mut functions = Vec::new();
-        for (usr, member) in &self.members {
-            match member {
-                NameSpaceChild::NameSpace(_) => {}
-                NameSpaceChild::Class(_) => {}
-                NameSpaceChild::Variable(variable) => variables.push((usr, variable as &DynEntity)),
-                NameSpaceChild::Function(function) => functions.push((usr, function as &DynEntity)),
-            }
-        }
-
-        vec![
-            ChildGroup {
-                name: "Variables",
-                children: variables,
-            },
-            ChildGroup {
-                name: "Functions",
-                children: functions,
-            },
-        ]
-    }
-
-    fn separate_children(&self) -> Vec<ChildGroup> {
-        let mut namespaces = Vec::new();
-        let mut classes = Vec::new();
-        for (usr, member) in &self.members {
-            match member {
-                NameSpaceChild::NameSpace(namespace) => {
-                    namespaces.push((usr, namespace as &DynEntity))
-                }
-                NameSpaceChild::Class(class) => classes.push((usr, class as &DynEntity)),
-                NameSpaceChild::Variable(_) => {}
-                NameSpaceChild::Function(_) => {}
-            }
-        }
-
-        vec![
-            ChildGroup {
-                name: "Namespaces",
-                children: namespaces,
-            },
-            ChildGroup {
-                name: "Classes",
-                children: classes,
-            },
-        ]
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Variable {
-    pub(crate) r#type: String,
-}
-
-impl Entity for Variable {
-    fn kind_name(&self) -> &'static str {
-        "variable"
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Function {
-    pub(crate) arguments: Vec<FunctionArgument>,
-    pub(crate) return_type: String,
-}
-
-impl Entity for Function {
-    fn kind_name(&self) -> &'static str {
-        "function"
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct FunctionArgument {
-    pub(crate) name: String,
-    pub(crate) r#type: String,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Class {
-    //pub(crate) member_types: Vec<Usr>,
-    // TODO: replace with Vec to keep order
-    pub(crate) member_functions: HashMap<Usr, Function>,
-    pub(crate) member_variables: HashMap<Usr, Variable>,
-}
-
-impl Entity for Class {
-    fn kind_name(&self) -> &'static str {
-        "class"
-    }
-
-    fn embeddable_children(&self) -> Vec<ChildGroup> {
-        vec![
-            ChildGroup {
-                name: "Functions",
-                children: self
-                    .member_functions
-                    .iter()
-                    .map(|(usr, func)| (usr, func as &DynEntity))
-                    .collect(),
-            },
-            ChildGroup {
-                name: "Variables",
-                children: self
-                    .member_variables
-                    .iter()
-                    .map(|(usr, var)| (usr, var as &DynEntity))
-                    .collect(),
-            },
-        ]
-    }
-
-    fn separate_children(&self) -> Vec<ChildGroup> {
-        Vec::new()
-    }
-}