most result errors are strings

mendelsshop · mendelsshop · commit 6515454a8619 · 2023-01-12T23:27:35.000-05:00
diff --git a/git-function-history-lib/src/languages/c.rs b/git-function-history-lib/src/languages/c.rs
@@ -68,7 +68,7 @@ pub struct ParentFunction {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<CFunction>, Box<dyn Error>> {
+) -> Result<Vec<CFunction>, String> {
     println!("Finding function {} in commit {}", name, file_contents);
 
     todo!("find_function_in_commit")
diff --git a/git-function-history-lib/src/languages/go.rs b/git-function-history-lib/src/languages/go.rs
@@ -1,5 +1,5 @@
 use crate::impl_function_trait;
-use std::{collections::HashMap, error::Error, fmt};
+use std::{collections::HashMap, fmt};
 
 use super::FunctionTrait;
 
@@ -77,7 +77,7 @@ impl FunctionTrait for GoFunction {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<GoFunction>, Box<dyn Error>> {
+) -> Result<Vec<GoFunction>, String> {
     let parsed_file = gosyn::parse_source(file_contents)
         .map_err(|e| format!("{e:?}"))?
         .decl;
diff --git a/git-function-history-lib/src/languages/java.rs b/git-function-history-lib/src/languages/java.rs
@@ -72,7 +72,7 @@ pub enum JavaBlockType {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<JavaFunction>, String> {
+) -> Result<Vec<JavaFunction>, &str> {
     let file = javaparser::parse::apply(file_contents, "<stdin>").map_err(|_| "Parse error")?;
     let parsed = file.unit.clone().items;
     let mut functions = Vec::new();
@@ -85,7 +85,7 @@ pub(crate) fn find_function_in_file(
 fn extract_methods_from_compilation_unit(
     unit: &CompilationUnitItem<'_>,
     name: &str,
-) -> Result<Vec<JavaFunction>, String> {
+) -> Result<Vec<JavaFunction>, &str> {
     // recursively search for items with type Method
     let mut methods = Vec::new();
 
@@ -128,7 +128,7 @@ fn extract_methods_from_compilation_unit(
 fn extract_methods_from_class_item(
     item: &javaparser::parse::tree::ClassBodyItem<'_>,
     name: &str,
-) -> Result<Vec<JavaFunction>, String> {
+) -> Result<Vec<JavaFunction>, &str> {
     let mut methods = Vec::new();
     match item {
         javaparser::parse::tree::ClassBodyItem::Method(method) => {
@@ -241,7 +241,7 @@ fn extract_methods_from_class_item(
 fn extract_methods_from_annotation_item(
     item: &javaparser::parse::tree::AnnotationBodyItem<'_>,
     name: &str,
-) -> Result<Vec<JavaFunction>, String> {
+) -> Result<Vec<JavaFunction>, &str> {
     let mut methods = Vec::new();
     match item {
         javaparser::parse::tree::AnnotationBodyItem::Annotation(annotation) => {
diff --git a/git-function-history-lib/src/languages/mod.rs b/git-function-history-lib/src/languages/mod.rs
@@ -1,7 +1,6 @@
 use crate::{Filter, UnwrapToError};
 use std::{
     collections::HashMap,
-    error::Error,
     fmt::{self},
 };
 // TODO: lisp/scheme js, java?(https://github.com/tanin47/javaparser.rs) php?(https://docs.rs/tagua-parser/0.1.0/tagua_parser/)
@@ -55,7 +54,7 @@ impl Language {
     /// # Errors
     ///
     /// `Err` will be returned if the string is not a valid language
-    pub fn from_string(s: &str) -> Result<Self, Box<dyn Error>> {
+    pub fn from_string(s: &str) -> Result<Self, String> {
         match s {
             "python" => Ok(Self::Python),
             "rust" => Ok(Self::Rust),
@@ -193,13 +192,13 @@ pub trait FileTrait: fmt::Debug + fmt::Display {
     ///
     /// returns `Err` if the wrong filter is given, only `PLFilter` and `FunctionInLines` variants of `Filter` are valid.
     /// with `PLFilter` it will return `Err` if you mismatch the file type with the filter Ie: using `RustFile` and `PythonFilter` will return `Err`.
-    fn filter_by(&self, filter: &Filter) -> Result<Self, Box<dyn Error>>
+    fn filter_by(&self, filter: &Filter) -> Result<Self, String>
     where
         Self: Sized;
     fn get_current(&self) -> Option<Box<dyn FunctionTrait>>;
 }
 
-fn turn_into_index(snippet: &str) -> Result<HashMap<usize, Vec<usize>>, Box<dyn Error>> {
+fn turn_into_index(snippet: &str) -> Result<HashMap<usize, Vec<usize>>, String> {
     // turn snippet into a hashmap of line number to char index
     // so line 1 is 0 to 10, line 2 is 11 to 20, etc
     let mut index = HashMap::new();
@@ -279,7 +278,7 @@ macro_rules! make_file {
                     .map(|x| Box::new(x) as Box<dyn FunctionTrait>)
                     .collect()
             }
-            fn filter_by(&self, filter: &Filter) -> Result<Self, Box<dyn Error>> {
+            fn filter_by(&self, filter: &Filter) -> Result<Self, String> {
                 let mut filtered_functions = Vec::new();
                 if let Filter::PLFilter(LanguageFilter::$filtername(_))
                 | Filter::FunctionInLines(..) = filter
diff --git a/git-function-history-lib/src/languages/python.rs b/git-function-history-lib/src/languages/python.rs
@@ -101,11 +101,14 @@ pub struct PythonParentFunction {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<PythonFunction>, Box<dyn std::error::Error>> {
-    let ast = parser::parse_program(file_contents, "<stdin>")?;
+) -> Result<Vec<PythonFunction>, String> {
+    let ast = match parser::parse_program(file_contents, "<stdin>") {
+        Ok(ast) => ast,
+        Err(e) => return Err(format!("error parsing file: {e}")),
+    };
     let mut functions = vec![];
     if ast.is_empty() {
-        return Err("No code found")?;
+        return Err("no code found".to_string());
     }
     let mut starts = file_contents
         .match_indices('\n')
@@ -244,7 +247,7 @@ pub(crate) fn find_function_in_file(
         }
     }
     if new.is_empty() {
-        Err("No function found")?;
+        return Err("no functions found".to_string());
     }
     Ok(new)
 }
diff --git a/git-function-history-lib/src/languages/ruby.rs b/git-function-history-lib/src/languages/ruby.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, error::Error, fmt};
+use std::{collections::HashMap, fmt};
 
 use lib_ruby_parser::{
     nodes::{Class, Def},
@@ -115,7 +115,7 @@ impl Default for RubyParams {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<RubyFunction>, Box<dyn Error>> {
+) -> Result<Vec<RubyFunction>, String> {
     let mut starts = file_contents
         .match_indices('\n')
         .map(|x| x.0)
@@ -128,6 +128,11 @@ pub(crate) fn find_function_in_file(
         .collect::<HashMap<usize, &usize>>();
     let parser = Parser::new(file_contents, ParserOptions::default());
     let parsed = parser.do_parse();
+    for d in parsed.diagnostics {
+        if d.is_error() {
+            return Err(d.message.render())?;
+        }
+    }
     // POSSBLE TODO check if there is any error dianostics parsed.dadnostices and return error is so
     let ast = parsed.ast.unwrap_to_error("Failed to parse file")?;
     let fns = get_functions_from_node(&ast, &vec![], name);
@@ -175,7 +180,7 @@ pub(crate) fn find_function_in_file(
             let end_line = super::get_from_index(&index, f.expression_l.end)
                 .unwrap_to_error("Failed to get end line")?;
             let starts = start_line + 1;
-            Ok::<RubyFunction, Box<dyn Error>>(RubyFunction {
+            Ok::<RubyFunction, String>(RubyFunction {
                 name: f.name.clone(),
                 lines: (start_line, end_line),
                 class,
diff --git a/git-function-history-lib/src/languages/rust.rs b/git-function-history-lib/src/languages/rust.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, error::Error, fmt};
+use std::{collections::HashMap, fmt};
 
 use ra_ap_syntax::{
     ast::{self, HasDocComments, HasGenericParams, HasName},
@@ -207,7 +207,7 @@ impl fmt::Display for BlockType {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<RustFunction>, Box<dyn Error>> {
+) -> Result<Vec<RustFunction>, String> {
     let mut functions = Vec::new();
     get_function_asts(name, file_contents, &mut functions);
     let mut starts = file_contents
diff --git a/git-function-history-lib/src/languages/umpl.rs b/git-function-history-lib/src/languages/umpl.rs
@@ -1,6 +1,6 @@
 use umpl::{self, parser::Thing};
 
-use std::{error::Error, fmt};
+use std::{fmt};
 
 use crate::impl_function_trait;
 
@@ -68,7 +68,7 @@ impl FunctionTrait for UMPLFunction {
 pub(crate) fn find_function_in_file(
     file_contents: &str,
     name: &str,
-) -> Result<Vec<UMPLFunction>, Box<dyn Error>> {
+) -> Result<Vec<UMPLFunction>, String> {
     // parse the file contents
     let lexed = umpl::lexer::Lexer::new(file_contents.to_string());
     let tokens = lexed.scan_tokens();
@@ -78,7 +78,7 @@ pub(crate) fn find_function_in_file(
     if !res.is_empty() {
         return Ok(res);
     }
-    Err("no function found")?
+    Err(String::from("Function not found"))
 }
 
 fn find_function_recurse(
diff --git a/git-function-history-lib/src/lib.rs b/git-function-history-lib/src/lib.rs
@@ -20,8 +20,8 @@ macro_rules! get_item_from {
     ($oid:expr, $repo:expr, $typs:ident) => {
         git_repository::hash::ObjectId::from($oid)
             .attach(&$repo)
-            .object()?
-            .$typs()?
+            .object().map_err(|_| "Could not find object")?
+            .$typs().map_err(|_| format!("Could not find {} from object", stringify!($typs)))?
     };
 }
 
@@ -170,7 +170,7 @@ pub fn get_function_history(
                     // elem.0.signed_duration_since(date)
                 })
                 .map(|elem| elem.hash.clone())
-                .unwrap_to_error_sync("no commits found")?
+                .unwrap_to_error("no commits found")?
         }
         Filter::Author(_)
         | Filter::AuthorEmail(_)
@@ -310,9 +310,9 @@ fn sender(
     name: &str,
     langs: Language,
     file: &FileFilterType,
-) -> Result<Vec<FileType>, Box<dyn std::error::Error>> {
-    let object = repo.find_object(id)?;
-    let tree = object.try_into_tree()?;
+) -> Result<Vec<FileType>, String> {
+    let object = repo.find_object(id).map_err(|_| "failed to find object")?;
+    let tree = object.try_into_tree().map_err(|_| "failed to find tree")?;
     traverse_tree(&tree, repo, name, "", langs, file)
 }
 
@@ -323,12 +323,12 @@ fn traverse_tree(
     path: &str,
     langs: Language,
     filetype: &FileFilterType,
-) -> Result<Vec<FileType>, Box<dyn std::error::Error>> {
+) -> Result<Vec<FileType>, String> {
     let treee_iter = tree.iter();
     let mut files: Vec<(String, String)> = Vec::new();
     let mut ret = Vec::new();
     for i in treee_iter {
-        let i = i?;
+        let i = i.map_err(|_| "failed to get tree entry")?;
         match &i.mode() {
             objs::tree::EntryMode::Tree => {
                 let new = get_item_from!(i.oid(), &repo, try_into_tree);
@@ -414,8 +414,8 @@ fn traverse_tree(
                         }
                     },
                 }
-                let obh = repo.find_object(i.oid())?;
-                let objref = objs::ObjectRef::from_bytes(obh.kind, &obh.data)?;
+                let obh = repo.find_object(i.oid()).map_err(|_| "failed to find object")?;
+                let objref = objs::ObjectRef::from_bytes(obh.kind, &obh.data).map_err(|_| "failed to get object ref")?;
                 let blob = objref.into_blob();
                 if let Some(blob) = blob {
                     files.push((file, String::from_utf8_lossy(blob.data).to_string()));
@@ -531,10 +531,10 @@ fn find_function_in_file_with_commit(
     fc: &str,
     name: &str,
     langs: Language,
-) -> Result<FileType, Box<dyn Error>> {
+) -> Result<FileType, String> {
     let file = match langs {
         Language::Rust => {
-            let functions = rust::find_function_in_file(fc, name)?;
+            let functions =  rust::find_function_in_file(fc, name)?;
             FileType::Rust(RustFile::new(file_path.to_string(), functions))
         }
         // #[cfg(feature = "c_lang")]
@@ -544,24 +544,25 @@ fn find_function_in_file_with_commit(
         // }
         #[cfg(feature = "unstable")]
         Language::Go => {
-            let functions = languages::go::find_function_in_file(fc, name)?;
+            let functions =  languages::go::find_function_in_file(fc, name)?;
             FileType::Go(GoFile::new(file_path.to_string(), functions))
         }
         Language::Python => {
-            let functions = languages::python::find_function_in_file(fc, name)?;
+            let functions =  languages::python::find_function_in_file(fc, name)?;
             FileType::Python(PythonFile::new(file_path.to_string(), functions))
         }
         Language::Ruby => {
-            let functions = languages::ruby::find_function_in_file(fc, name)?;
+            let functions =  languages::ruby::find_function_in_file(fc, name)?;
             FileType::Ruby(RubyFile::new(file_path.to_string(), functions))
         }
         Language::UMPL => {
-            let functions = languages::umpl::find_function_in_file(fc, name)?;
+            let functions =  languages::umpl::find_function_in_file(fc, name)?;
             FileType::UMPL(UMPLFile::new(file_path.to_string(), functions))
         }
         Language::All => match file_path.split('.').last() {
             Some("rs") => {
-                let functions = rust::find_function_in_file(fc, name)?;
+                
+                let functions =  rust::find_function_in_file(fc, name)?;
                 FileType::Rust(RustFile::new(file_path.to_string(), functions))
             }
             // #[cfg(feature = "c_lang")]
@@ -570,16 +571,16 @@ fn find_function_in_file_with_commit(
             //     FileType::C(CFile::new(file_path.to_string(), functions))
             // }
             Some("py" | "pyw") => {
-                let functions = languages::python::find_function_in_file(fc, name)?;
+                let functions =  languages::python::find_function_in_file(fc, name)?;
                 FileType::Python(PythonFile::new(file_path.to_string(), functions))
             }
             #[cfg(feature = "unstable")]
             Some("go") => {
-                let functions = languages::go::find_function_in_file(fc, name)?;
+                let functions =  languages::go::find_function_in_file(fc, name)?;
                 FileType::Go(GoFile::new(file_path.to_string(), functions))
             }
             Some("rb") => {
-                let functions = languages::ruby::find_function_in_file(fc, name)?;
+                let functions =  languages::ruby::find_function_in_file(fc, name)?;
                 FileType::Ruby(RubyFile::new(file_path.to_string(), functions))
             }
             _ => Err("unknown file type")?,
@@ -613,16 +614,13 @@ fn ends_with_cmp_no_case(filename: &str, file_ext: &str) -> bool {
 }
 
 trait UnwrapToError<T> {
-    fn unwrap_to_error_sync(self, message: &str) -> Result<T, Box<dyn Error + Send + Sync>>;
-    fn unwrap_to_error(self, message: &str) -> Result<T, Box<dyn Error>>;
+    fn unwrap_to_error(self, message: &str) -> Result<T, String>;
 }
 
 impl<T> UnwrapToError<T> for Option<T> {
-    fn unwrap_to_error_sync(self, message: &str) -> Result<T, Box<dyn Error + Send + Sync>> {
-        self.map_or_else(|| Err(message)?, |val| Ok(val))
-    }
-    fn unwrap_to_error(self, message: &str) -> Result<T, Box<dyn Error>> {
-        self.map_or_else(|| Err(message)?, |val| Ok(val))
+
+    fn unwrap_to_error(self, message: &str) -> Result<T, String> {
+        self.map_or_else(|| Err(message.to_string()), |val| Ok(val))
     }
 }
 
diff --git a/git-function-history-lib/src/types.rs b/git-function-history-lib/src/types.rs

Original file line number	Diff line number	Diff line change
`@@ -101,11 +101,14 @@ pub struct PythonParentFunction {`
`101`	`101`	`pub(crate) fn find_function_in_file(`
`102`	`102`	`file_contents: &str,`
`103`	`103`	`name: &str,`
`104`		`-) -> Result<Vec<PythonFunction>, Box<dyn std::error::Error>> {`
`105`		`- let ast = parser::parse_program(file_contents, "<stdin>")?;`
	`104`	`+) -> Result<Vec<PythonFunction>, String> {`
	`105`	`+ let ast = match parser::parse_program(file_contents, "<stdin>") {`
	`106`	`+ Ok(ast) => ast,`
	`107`	`+ Err(e) => return Err(format!("error parsing file: {e}")),`
	`108`	`+ };`
`106`	`109`	`let mut functions = vec![];`
`107`	`110`	`if ast.is_empty() {`
`108`		`- return Err("No code found")?;`
	`111`	`+ return Err("no code found".to_string());`
`109`	`112`	`}`
`110`	`113`	`let mut starts = file_contents`
`111`	`114`	`.match_indices('\n')`
`@@ -244,7 +247,7 @@ pub(crate) fn find_function_in_file(`
`244`	`247`	`}`
`245`	`248`	`}`
`246`	`249`	`if new.is_empty() {`
`247`		`- Err("No function found")?;`
	`250`	`+ return Err("no functions found".to_string());`
`248`	`251`	`}`
`249`	`252`	`Ok(new)`
`250`	`253`	`}`