working on umpl support

Author: mendelsshop

git-function-history-lib/Cargo.toml

@@ -31,4 +31,4 @@ cached = {version = "0.42.0", optional = true}
 gitoxide-core = "0.22.0"
 git-repository = { version = "0.33.0", default-features = false, features = ["max-performance-safe"] }
 git-features = { version = "0.26.1", features = ["zlib", "once_cell"] }
-umpl = "1.0.2"
+umpl = "1.1.0"

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

@@ -338,7 +338,7 @@ make_file!(UMPLFile, UMPLFunction, UMPL);
 mod lang_tests {
     // macro that auto genertes the test parse_<lang>_file_time
     macro_rules! make_file_time_test {
-        ($name:ident, $extname:ident, $function:ident, $filetype:ident) => {
+        ($name:ident, $extname:ident, $function:ident, $filetype:ident, $fnname:literal) => {
             #[test]
             fn $name() {
                 let mut file = std::env::current_dir().unwrap();
@@ -347,7 +347,7 @@ mod lang_tests {
                 let files = std::fs::read_to_string(file.clone())
                     .expect(format!("could not read file {:?}", file).as_str());
                 let start = std::time::Instant::now();
-                let ok = $function::find_function_in_file(&files, "empty_test");
+                let ok = $function::find_function_in_file(&files, $fnname);
                 let end = std::time::Instant::now();
                 match &ok {
                     Ok(hist) => {
@@ -371,11 +371,13 @@ mod lang_tests {
     }
 
     use super::*;
-    make_file_time_test!(python_parses, py, python, PythonFile);
-    make_file_time_test!(rust_parses, rs, rust, RustFile);
+    make_file_time_test!(python_parses, py, python, PythonFile, "empty_test");
+    make_file_time_test!(rust_parses, rs, rust, RustFile, "empty_test");
     // #[cfg(feature = "c_lang")]
-    // make_file_time_test!(c_parses, c, c, CFile);
+    // make_file_time_test!(c_parses, c, c, CFile, "empty_test");
     #[cfg(feature = "unstable")]
-    make_file_time_test!(go_parses, go, go, GoFile);
-    make_file_time_test!(ruby_parses, rb, ruby, RubyFile);
+    make_file_time_test!(go_parses, go, go, GoFile, "empty_test");
+    make_file_time_test!(ruby_parses, rb, ruby, RubyFile, "empty_test");
+
+    make_file_time_test!(umpl_parses, umpl, umpl, UMPLFile, "😂");
 }

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

@@ -1,4 +1,4 @@
-use umpl;
+use umpl::{self, parser::Thing};
 
 use std::{error::Error, fmt};
 
@@ -10,6 +10,16 @@ pub struct UMPLFunction {
     pub(crate) lines: (usize, usize),
     pub(crate) name: String,
     pub(crate) body: String,
+    pub(crate) args_count: usize,
+    pub(crate) parents: Vec<UMPLParentFunction>,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UMPLParentFunction {
+    pub(crate) lines: (usize, usize),
+    pub(crate) name: String,
+    pub(crate) top: String,
+    pub(crate) bottom: String,
+    pub(crate) args_count: usize,
 }
 
 impl fmt::Display for UMPLFunction {
@@ -43,8 +53,55 @@ pub(crate) fn find_function_in_file(
     let tokens = lexed.scan_tokens();
     let mut parsed = umpl::parser::Parser::new(tokens);
     let ast = parsed.parse();
-    for node in ast {}
-    Err("")?
+    let res = find_function_recurse(name, ast, &vec![]);
+    if res.len() > 0 {
+        return Ok(res);
+    }
+    Err("no function found")?
+}
+
+fn find_function_recurse(name: &str, ast: Vec<Thing>, current: &Vec<UMPLParentFunction>) -> Vec<(UMPLFunction)> {
+    let mut results = Vec::new();
+    for node in ast {
+        match node {
+            Thing::Function(fns) => {
+                if fns.name.to_string() == name {
+                    let new_fn = UMPLFunction {
+                        lines: (fns.line as usize, fns.end_line as usize),
+                        name: fns.name.to_string(),
+                        // TODO: get the function body
+                        body: String::new(),
+                        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 pfn  = UMPLParentFunction {
+                        lines: (fns.line as usize, fns.end_line as usize),
+                        name: fns.name.to_string(),
+                        // TODO: get the top and bottom lines
+                        top: String::new(),
+                        bottom: String::new(),
+                        args_count: fns.num_arguments as usize
+                    };
+                    new_current.push(pfn);
+                    results.append(&mut find_function_recurse(name, fns.body, &new_current));
+                }
+            }
+            Thing::LoopStatement(loops) => {
+                results.append(&mut find_function_recurse(name, 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
+
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -54,4 +111,4 @@ impl UMPLFilter {
     pub fn matches(&self, function: &UMPLFunction) -> bool {
         false
     }
-}
+}

git-function-history-lib/src/test_functions.umpl

@@ -0,0 +1,17 @@
+potato 😀 2 ⧼ ! to create a custom function first we use the potato keyword to signify that we want to create a custom function.
+! then we add the name of the function and the number of arguments that the function will take.
+    (`HELLO`)> ! prints HELLO
+    ($1)> ! to acces function args we use $1 for the first args and so on
+    create z with ((plus 0xA.9 $1 $2))< ! new variable z with the value of the sum of the first two arguments and 169 (0xA9 in hex)
+    (z)> ! prints z
+    potato 😂 1 ⧼ ! to create a custom function first we use the potato keyword to signify that we want to create a custom function.
+        ! then we add the name of the function and the number of arguments that the function will take.
+        (`BYE`)> ! prints HELLO
+        create z with ((plus 0xFF $1))< ! new variable z with the value of the sum of the first two arguments and 169 (0xA9 in hex)
+        return z ! at the end we return z notice there is no colon b/c were returning something
+    ⧽
+    create z with ((new 😂 z))< ! to call custom function we must use the new keyword followed by the function name seperated argumentsaa
+    return z ! at the end we return z notice there is no colon b/c were returning something
+⧽
+((new 😀 1 0xA))> ! to call custom function we must use the new keyword followed by the function name seperated arguments
+! prints HELLO and on a new line 1 and on a new line 180