umpl support is basically done

Author: mendelsshop

git-function-history-lib/src/languages/python.rs

@@ -252,11 +252,7 @@ pub(crate) fn find_function_in_file(
 fn get_functions_recurisve(
     body: Vec<Located<StmtKind>>,
     map: &HashMap<usize, &usize>,
-    functions: &mut Vec<(
-        Located<StmtKind>,
-        Vec<Located<StmtKind>>,
-        Vec<Located<StmtKind>>,
-    )>,
+    functions: &mut FnState,
     current_parent: &mut Vec<Located<StmtKind>>,
     current_class: &mut Vec<Located<StmtKind>>,
     lookup_name: &str,
@@ -277,15 +273,15 @@ fn get_functions_recurisve(
         );
     }
 }
-
+type FnState = Vec<(
+    Located<StmtKind>,
+    Vec<Located<StmtKind>>,
+    Vec<Located<StmtKind>>,
+)>;
 fn get_functions(
     stmt: Located<StmtKind>,
     map: &HashMap<usize, &usize>,
-    functions: &mut Vec<(
-        Located<StmtKind>,
-        Vec<Located<StmtKind>>,
-        Vec<Located<StmtKind>>,
-    )>,
+    functions: &mut FnState,
     current_parent: &mut Vec<Located<StmtKind>>,
     current_class: &mut Vec<Located<StmtKind>>,
     lookup_name: &str,

git-function-history-lib/src/languages/umpl.rs

@@ -24,23 +24,44 @@ pub struct UMPLParentFunction {
 
 impl fmt::Display for UMPLFunction {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        todo!()
+        for i in &self.parents {
+            write!(f, "{}\n...\n", i.top)?;
+        }
+        write!(f, "{}", self.body)?;
+        for i in &self.parents {
+            write!(f, "\n...\n{}", i.bottom)?;
+        }
+        Ok(())
     }
 }
 
 impl FunctionTrait for UMPLFunction {
     impl_function_trait!(UMPLFunction);
 
     fn get_total_lines(&self) -> (usize, usize) {
-        todo!()
+        let mut start = self.lines.0;
+        let mut end = self.lines.1;
+        for parent in &self.parents {
+            if parent.lines.0 < start {
+                start = parent.lines.0;
+                end = parent.lines.1;
+            }
+        }
+        (start, end)
     }
 
     fn get_tops(&self) -> Vec<(String, usize)> {
-        todo!()
+        self.parents
+            .iter()
+            .map(|f| (f.top.clone(), f.lines.0))
+            .collect()
     }
 
     fn get_bottoms(&self) -> Vec<(String, usize)> {
-        todo!()
+        self.parents
+            .iter()
+            .map(|f| (f.bottom.clone(), f.lines.1))
+            .collect()
     }
 }
 
@@ -53,53 +74,104 @@ pub(crate) fn find_function_in_file(
     let tokens = lexed.scan_tokens();
     let mut parsed = umpl::parser::Parser::new(tokens);
     let ast = parsed.parse();
-    let res = find_function_recurse(name, ast, &vec![]);
-    if res.len() > 0 {
+    let res = find_function_recurse(name, file_contents, ast, &vec![]);
+    if !res.is_empty() {
         return Ok(res);
     }
     Err("no function found")?
 }
 
 fn find_function_recurse(
     name: &str,
+    file_contents: &str,
     ast: Vec<Thing>,
     current: &Vec<UMPLParentFunction>,
-) -> Vec<(UMPLFunction)> {
+) -> Vec<UMPLFunction> {
     let mut results = Vec::new();
     for node in ast {
         match node {
             Thing::Function(fns) => {
                 if fns.name.to_string() == name {
+                    let lines = (fns.line as usize, fns.end_line as usize);
+                    let body = file_contents
+                        .lines()
+                        .enumerate()
+                        .filter(|line| line.0 >= lines.0 - 1 && line.0 < lines.1)
+                        .map(|line| format!("{}\n", line.1))
+                        .collect::<String>();
                     let new_fn = UMPLFunction {
-                        lines: (fns.line as usize, fns.end_line as usize),
+                        lines,
                         name: fns.name.to_string(),
-                        // TODO: get the function body
-                        body: String::new(),
+                        body: super::make_lined(&body, lines.0),
                         args_count: fns.num_arguments as usize,
                         parents: current.clone(),
                     };
                     results.push(new_fn);
                 } else {
                     let mut new_current = current.clone();
                     // turn into a parent function
+                    let lines = (fns.line as usize, fns.end_line as usize);
+                    let bottom = if let Some(line) = file_contents.lines().nth(lines.1 - 1) {
+                        super::make_lined(line, lines.1)
+                    } else {
+                        results.append(&mut find_function_recurse(
+                            name,
+                            file_contents,
+                            fns.body,
+                            &new_current,
+                        ));
+                        continue;
+                    };
+                    // FIXME: this should find the last line of the `top` by looking at its first element of is ast instead of finding the the first `⧼` (which could be commented out)
+                    let Some(top_end) = file_contents.lines().enumerate().skip(lines.0 -1).find_map(|line| {
+                        line.1.contains('⧼').then_some(line.0)
+                    }) else {
+                        results.append(&mut find_function_recurse(name, file_contents, fns.body, &new_current));
+                        continue;
+                    };
+                    let top = file_contents
+                        .lines()
+                        .enumerate()
+                        .filter(|line| line.0 >= lines.0 - 1 && line.0 <= top_end)
+                        .map(|line| format!("{}\n", line.1))
+                        .collect::<String>();
                     let pfn = UMPLParentFunction {
-                        lines: (fns.line as usize, fns.end_line as usize),
+                        lines,
                         name: fns.name.to_string(),
-                        // TODO: get the top and bottom lines
-                        top: String::new(),
-                        bottom: String::new(),
+                        top: super::make_lined(&top, lines.0),
+                        bottom,
                         args_count: fns.num_arguments as usize,
                     };
                     new_current.push(pfn);
-                    results.append(&mut find_function_recurse(name, fns.body, &new_current));
+                    results.append(&mut find_function_recurse(
+                        name,
+                        file_contents,
+                        fns.body,
+                        &new_current,
+                    ));
                 }
             }
             Thing::LoopStatement(loops) => {
-                results.append(&mut find_function_recurse(name, loops.body, current));
+                results.append(&mut find_function_recurse(
+                    name,
+                    file_contents,
+                    loops.body,
+                    current,
+                ));
             }
             Thing::IfStatement(ifs) => {
-                results.append(&mut find_function_recurse(name, ifs.body_true, current));
-                results.append(&mut find_function_recurse(name, ifs.body_false, current));
+                results.append(&mut find_function_recurse(
+                    name,
+                    file_contents,
+                    ifs.body_true,
+                    current,
+                ));
+                results.append(&mut find_function_recurse(
+                    name,
+                    file_contents,
+                    ifs.body_false,
+                    current,
+                ));
             }
             _ => {}
         }
@@ -108,10 +180,22 @@ fn find_function_recurse(
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum UMPLFilter {}
+pub enum UMPLFilter {
+    HasParameterCount(usize),
+    HasParentWithParamCount(usize),
+    HasParentWithName(String),
+    HasParents,
+}
 
 impl UMPLFilter {
     pub fn matches(&self, function: &UMPLFunction) -> bool {
-        false
+        match self {
+            Self::HasParameterCount(count) => function.args_count == *count,
+            Self::HasParentWithParamCount(count) => {
+                function.parents.iter().any(|p| p.args_count == *count)
+            }
+            Self::HasParentWithName(name) => function.parents.iter().any(|p| p.name == *name),
+            Self::HasParents => !function.parents.is_empty(),
+        }
     }
 }