[function-grep] made some more filters work, added source code input to filter function to work with tree sitter querry

Author: mendelsshop

function-grep/src/filter.rs

@@ -127,7 +127,7 @@ pub trait HasFilterInformation {
         }
     }
 }
-type FilterFunction = Box<dyn Fn(&Node<'_>) -> bool + Send + Sync>;
+type FilterFunction = Box<dyn Fn(&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
@@ -164,8 +164,8 @@ impl<Supports: std::fmt::Debug> std::fmt::Debug for InstantiatedFilter<Supports>
 
 impl<Supports> InstantiatedFilter<Supports> {
     #[must_use]
-    pub fn filter(&self, node: &Node<'_>) -> bool {
-        (self.filter_function)(node)
+    pub fn filter(&self, node: &Node<'_>, code: &str) -> bool {
+        (self.filter_function)(node, code)
     }
 
     #[must_use]

function-grep/src/filter/filter_parsers.rs

@@ -27,3 +27,11 @@ pub fn label<'a>(
                 }
         )
 }
+
+pub fn string<'a>(
+    substring: &mut impl Iterator<Item = &'a str>,
+    format: &str,
+    position: &str,
+) -> Result<String, String> {
+    substring.next().map(ToOwned::to_owned).ok_or_else(||format! ("invalid options for function_in_lines filter\nexpected {format}\n missing {position} [number]"))
+}

function-grep/src/filter/general_filters.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 
-use tree_sitter::Node;
+use tree_sitter::{Node, Query, QueryCursor};
 
 use super::{
-    filter_parsers::{extra, label, number},
+    filter_parsers::{extra, label, number, string},
     All, Attribute, AttributeType, Attributes, Filter, FilterFunction, HasFilterInformation,
     Language,
 };
@@ -45,7 +45,7 @@ impl FunctionInLines {
 impl Filter for FunctionInLines {
     fn parse_filter(&self, s: &str) -> Result<FilterFunction, String> {
         let (start, end) = Self::from_str(s)?;
-        Ok(Box::new(move |node: &Node<'_>| {
+        Ok(Box::new(move |node: &Node<'_>, _| {
             node.range().start_point.row >= start && node.range().end_point.row <= end
         }))
     }
@@ -83,7 +83,7 @@ impl Filter for FunctionInImpl {
             return Err(format!("invalid options for function_in_impl, this filter accepts not options, but got {s}"));
         }
 
-        Ok(Box::new(move |node: &Node<'_>| {
+        Ok(Box::new(move |node: &Node<'_>, _| {
             node.parent().is_some_and(|parent| {
                 parent
                     .parent()
@@ -129,7 +129,7 @@ impl HasFilterInformation for FunctionWithParameterRust {
     }
 
     fn attributes(&self) -> Attributes {
-        HashMap::from([(Attribute("Name".to_string()), AttributeType::String)])
+        HashMap::from([(Attribute("name".to_string()), AttributeType::String)])
     }
 
     type Supports = Language;
@@ -155,14 +155,69 @@ impl HasFilterInformation for FunctionWithParameterPython {
     }
 
     fn attributes(&self) -> Attributes {
-        HashMap::from([(Attribute("Name".to_string()), AttributeType::String)])
+        HashMap::from([(Attribute("name".to_string()), AttributeType::String)])
     }
 
     type Supports = Language;
 }
 
 impl Filter for FunctionWithParameterPython {
     fn parse_filter(&self, s: &str) -> Result<FilterFunction, String> {
-        todo!()
+        let query = Query::new(
+            &tree_sitter_rust::LANGUAGE.into(),
+            "((function_item
+  parameters: (parameters (parameter pattern: (identifier) @param)))
+)
+((let_declaration
+  value: (closure_expression
+  parameters: (closure_parameters [((identifier) @param)
+                                   (parameter pattern: (identifier) @param)])
+  ))
+)
+((const_item
+  value: (closure_expression
+  (closure_parameters [((identifier) @param)
+                                   (parameter pattern: (identifier) @param)])
+  )) 
+)
+((static_item
+  value: (closure_expression
+  (closure_parameters [((identifier) @param)
+                                   (parameter pattern: (identifier) @param)])
+  )) 
+)",
+        )
+        .map_err(|_| String::from("Could not create tree sitter filter"))?;
+        let name = parse_with_param(s)?;
+        Ok(Box::new(move |node: &Node<'_>, code| {
+            let mut cursor = QueryCursor::new();
+            cursor.set_max_start_depth(Some(0));
+            let text_provider = code.as_bytes();
+            cursor.matches(&query, *node, text_provider).any(|c| {
+                c.captures
+                    .iter()
+                    .any(|c| c.node.utf8_text(text_provider).unwrap() == name)
+            })
+        }))
+    }
+}
+
+fn parse_with_param(s: &str) -> Result<String, String> {
+    let mut substring = s.split(' ').filter(|s| *s != " ");
+    let fst = substring.next().ok_or(
+        "invalid options for function_in_lines filter\nexpected [string] or name: [string]",
+    )?;
+    match fst {
+        "start:" => {
+            let format = "name: [string]";
+            let name = string(&mut substring, format, "name:")?;
+            extra(&mut substring, format)?;
+            Ok(name)
+        }
+
+        name => {
+            extra(&mut substring, "[string]")?;
+            Ok(name.to_string())
+        }
     }
 }

function-grep/src/lib.rs

@@ -158,7 +158,7 @@ impl ParsedFile {
         let ranges: Box<[Range]> = self
             .ranges()
             .filter_map(|range| root.descendant_for_point_range(range.start_point, range.end_point))
-            .filter(|n| f.filter(n))
+            .filter(|n| f.filter(n, &self.file))
             .map(|n| n.range())
             .collect();
         if ranges.is_empty() {