[function-grep] made filter mutable so now we can use tree sitter query

effeciently as a generic filter
but this means everything else related to filters needs to be mutable,
so we loose paralelization for filtering

Author: mendelsshop

function-grep/src/filter.rs

@@ -1,5 +1,6 @@
 use general_filters::{
     FunctionInImpl, FunctionInLines, FunctionWithParameterPython, FunctionWithParameterRust,
+    TreeSitterQueryFilter,
 };
 use std::{
     collections::{hash_map, HashMap},
@@ -126,7 +127,7 @@ pub trait HasFilterInformation {
         }
     }
 }
-type FilterFunction = Box<dyn Fn(&Node<'_>, &str) -> bool + Send + Sync>;
+type FilterFunction = Box<dyn FnMut(&Node<'_>, &str) -> bool + Send + Sync>;
 
 // TODO: make our own FromStr that also requires the proggramer to sepcify that attributes each
 // filter has and their type so that we can make macro that creates parser, and also so that we can
@@ -163,7 +164,7 @@ impl<Supports: std::fmt::Debug> std::fmt::Debug for InstantiatedFilter<Supports>
 
 impl<Supports> InstantiatedFilter<Supports> {
     #[must_use]
-    pub fn filter(&self, node: &Node<'_>, code: &str) -> bool {
+    pub fn filter(&mut self, node: &Node<'_>, code: &str) -> bool {
         (self.filter_function)(node, code)
     }
 
@@ -319,6 +320,15 @@ impl Filters<'static> {
                     FunctionInLines.filter_info().filter_name().to_string(),
                     SingleOrMany::All(&FunctionInLines as &'static dyn Filter<Supports = All>),
                 ),
+                (
+                    TreeSitterQueryFilter
+                        .filter_info()
+                        .filter_name()
+                        .to_string(),
+                    SingleOrMany::All(
+                        &TreeSitterQueryFilter as &'static dyn Filter<Supports = All>,
+                    ),
+                ),
                 (
                     FunctionInImpl.filter_info().filter_name().to_string(),
                     SingleOrMany::Many(Many {

function-grep/src/filter/general_filters.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use tree_sitter::{Node, Query, QueryCursor};
 
@@ -113,6 +113,62 @@ impl HasFilterInformation for FunctionInImpl {
     }
 }
 
+pub struct TreeSitterQueryFilter;
+impl HasFilterInformation for TreeSitterQueryFilter {
+    fn filter_name(&self) -> String {
+        "tree_sitter_query".to_string()
+    }
+
+    fn description(&self) -> String {
+        "filter using an arbritrary tree sitter query".to_string()
+    }
+
+    fn supports(&self) -> Self::Supports {
+        All
+    }
+
+    fn attributes(&self) -> Attributes {
+        HashMap::from([(Attribute("query".to_string()), AttributeType::String)])
+    }
+
+    type Supports = All;
+}
+impl Filter for TreeSitterQueryFilter {
+    fn parse_filter(&self, s: &str) -> Result<FilterFunction, String> {
+        let mut languages: HashMap<tree_sitter::Language, Result<Query, ()>> = HashMap::new();
+        let query: String = {
+            let mut substring = s.split(' ').filter(|s| *s != " ").peekable();
+            let fst = substring.peek().ok_or(
+                "invalid options for tree_sitter_query filter\nexpected [string] or name: [string]",
+            )?;
+            match *fst {
+                "query:" => {
+                    substring.next();
+                    substring.collect::<Vec<_>>().join(" ")
+                }
+
+                _ => substring.collect::<Vec<_>>().join(" "),
+            }
+        };
+        Ok(Box::new(move |node: &Node<'_>, code| {
+            let language = node.language();
+            let language: &tree_sitter::Language = &language;
+            let mut cursor = QueryCursor::new();
+            cursor.set_max_start_depth(Some(0));
+            let text_provider = code.as_bytes();
+            match languages
+                .entry(language.clone())
+                .or_insert(Query::new(language, &query).map_err(|_| ()))
+            {
+                Ok(query) => cursor
+                    .matches(&query, *node, text_provider)
+                    .next()
+                    .is_some(),
+                Err(_) => false,
+            }
+        }))
+    }
+}
 pub struct FunctionWithParameterRust;
 pub struct FunctionWithParameterPython;
 
@@ -223,3 +279,50 @@ fn parse_with_param(s: &str) -> Result<String, String> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        filter::Filter,
+        supported_languages::{Rust, SupportedLanguage},
+        ParsedFile,
+    };
+
+    use super::TreeSitterQueryFilter;
+
+    #[test]
+    fn tree_sitter_query() {
+        let file = ParsedFile::search_file(
+            include_str!("../../../git-function-history-lib/src/test_functions.rs"),
+            &Rust.to_language("empty_test").unwrap(),
+        )
+        .unwrap();
+        println!("original:\n{file}");
+        let mut filter = TreeSitterQueryFilter
+            .to_filter(" (function_item type_parameters: (type_parameters))")
+            .unwrap();
+
+        let filtered = file.filter_inner(&mut filter);
+        assert!(filtered.is_ok());
+        let filtered = filtered.unwrap();
+        println!("filtered:\n{filtered}");
+    }
+    #[test]
+    fn tree_sitter_query_with_predicate() {
+        let file = ParsedFile::search_file(
+            include_str!("../../../git-function-history-lib/src/test_functions.rs"),
+            &Rust.to_language("empty_test").unwrap(),
+        )
+        .unwrap();
+        println!("original:\n{file}");
+        let mut filter = TreeSitterQueryFilter
+            .to_filter(" (function_item type_parameters: (type_parameters (type_identifier) @type)   (#eq? @type \"T\")
+)")
+            .unwrap();
+
+        let filtered = file.filter_inner(&mut filter);
+        assert!(filtered.is_ok());
+        let filtered = filtered.unwrap();
+        println!("filtered:\n{filtered}");
+    }
+}

function-grep/src/lib.rs

@@ -140,11 +140,11 @@ impl ParsedFile {
     ///
     /// # Errors
     /// If the filter [`f`] filters out all the results of this file
-    pub fn filter(&self, f: &InstantiatedFilterType) -> Result<Self, Error> {
+    pub fn filter(&self, f: &mut InstantiatedFilterType) -> Result<Self, Error> {
         match f {
             InstantiatedFilterType::Many(supported_language) => {
                 let lang = self.language();
-                let filter = supported_language.filters.get(lang);
+                let filter = supported_language.filters.get_mut(lang);
                 let filter = filter.ok_or(Error::FilterLangaugeMismatch);
                 filter.and_then(|f| self.filter_inner(f))
             }
@@ -153,7 +153,7 @@ impl ParsedFile {
         }
     }
 
-    fn filter_inner<T>(&self, f: &InstantiatedFilter<T>) -> Result<Self, Error> {
+    fn filter_inner<T>(&self, f: &mut InstantiatedFilter<T>) -> Result<Self, Error> {
         let root = self.tree.root_node();
         let ranges: Box<[Range]> = self
             .ranges()

function_history_backend_thread/src/lib.rs

@@ -125,12 +125,12 @@ pub fn command_thread(
                             ),
                         }
                     }
-                    FullCommand::Filter(filter) => {
+                    FullCommand::Filter(mut filter) => {
                         if let CommandResult::History(hist) = filter.thing {
                             if log {
                                 log::info!("Filtering history with filter {:?}", filter.filter);
                             }
-                            match hist.filter_by(&filter.filter) {
+                            match hist.filter_by(&mut filter.filter) {
                                 Ok(hist) => {
                                     if log {
                                         log::info!("Filtered history");

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

@@ -314,8 +314,7 @@ pub fn get_function_history(
     if commits.is_empty() {
         Err("no history found")?;
     }
-    let fh = FunctionHistory::new(name.to_string(), commits);
-    Ok(fh)
+    Ok(FunctionHistory::new(name.to_string(), commits))
 }
 
 fn sender(

git-function-history-lib/src/types.rs

@@ -119,7 +119,7 @@ impl Commit {
     /// # Errors
     ///
     /// Will result in an `Err` if a non-valid filter is given, or if no results are found for the given filter
-    pub fn filter_by(&self, filter: &Filter) -> Result<Self, ErrorReason> {
+    pub fn filter_by(&self, filter: &mut Filter) -> Result<Self, ErrorReason> {
         match filter {
             Filter::FileAbsolute(_)
             | Filter::FileRelative(_)
@@ -142,14 +142,14 @@ impl Commit {
                         None
                     }
                 }
-                Filter::FileRelative(file) => {
+                Filter::FileRelative(ref file) => {
                     if f.file_name()?.ends_with(file) {
                         Some(f.clone())
                     } else {
                         None
                     }
                 }
-                Filter::Directory(dir) => {
+                Filter::Directory(ref dir) => {
                     if f.file_name()?.contains(dir) {
                         Some(f.clone())
                     } else {
@@ -324,10 +324,10 @@ impl FunctionHistory {
     /// # Errors
     ///
     /// returns `Err` if no files or commits are match the filter specified
-    pub fn filter_by(&self, filter: &Filter) -> Result<Self, ErrorReason> {
+    pub fn filter_by(&self, filter: &mut Filter) -> Result<Self, ErrorReason> {
         #[cfg(feature = "parallel")]
         let t = self.commit_history.par_iter();
-        #[cfg(not(feature = "parallel"))]
+        // #[cfg(not(feature = "parallel"))]
         let t = self.commit_history.iter();
         let vec: Vec<Commit> = t
             .filter_map(|f| match filter {
@@ -378,7 +378,7 @@ impl FunctionHistory {
                         None
                     }
                 }
-                Filter::Message(message) => {
+                Filter::Message(ref message) => {
                     if f.message.contains(message) {
                         Some(f.clone())
                     } else {