Crate-level API changes for tree-sitter-lint

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "tree-sitter-grep"
+name = "tree_sitter_lint_tree-sitter-grep"
 version = "0.1.0"
 edition = "2021"
 license = "Unlicense OR MIT"
@@ -8,6 +8,7 @@ authors = [
   "Peter Stuart <peter@peterstuart.org>"
 ]
 description = """
+(not-yet-landed version used by tree-sitter-lint)
 tree-sitter-grep is a grep-like search tool that
 recursively searches the current directory for a
 tree-sitter query pattern. Like ripgrep, it respects

examples/filter_before_line_number.rs

@@ -5,7 +5,7 @@ use std::{
 
 use libc::c_char;
 use tree_sitter::Node;
-use tree_sitter_grep::PluginInitializeReturn;
+use tree_sitter_lint_tree_sitter_grep::PluginInitializeReturn;
 
 static ROW_NUMBER: AtomicUsize = AtomicUsize::new(0);
 

examples/print_match_text.rs

@@ -1,12 +1,12 @@
 use clap::Parser;
-use tree_sitter_grep::{run_with_callback, Args};
+use tree_sitter_lint_tree_sitter_grep::{run_with_callback, Args};
 
 fn main() {
     let args = Args::parse_from(["tree_sitter_grep", "-q", "(function_item) @f"]);
-    run_with_callback(args, |node, file_contents, path| {
+    run_with_callback(args, |capture_info, file_contents, path| {
         println!(
             "Found match in {path:?}: {}",
-            std::str::from_utf8(&file_contents[node.byte_range()]).unwrap(),
+            std::str::from_utf8(&file_contents[capture_info.node.byte_range()]).unwrap(),
         );
     })
     .unwrap();

src/args.rs

@@ -23,7 +23,7 @@ use crate::{
 
 const ALL_NODES_QUERY: &str = "(_) @node";
 
-#[derive(Parser)]
+#[derive(Clone, Parser)]
 #[clap(group(
     ArgGroup::new("query_or_filter")
         .multiple(true)

src/bin/tree-sitter-grep.rs

@@ -1,7 +1,7 @@
 use std::process;
 
 use clap::Parser;
-use tree_sitter_grep::{run_print, Args, RunStatus};
+use tree_sitter_lint_tree_sitter_grep::{run_print, Args, RunStatus};
 
 pub fn main() {
     let args = Args::parse();

src/lib.rs

@@ -32,7 +32,8 @@ mod use_printer;
 mod use_searcher;
 
 pub use args::Args;
-use language::{BySupportedLanguage, SupportedLanguage};
+use language::BySupportedLanguage;
+pub use language::SupportedLanguage;
 pub use plugin::PluginInitializeReturn;
 use query_context::QueryContext;
 use treesitter::maybe_get_query;
@@ -74,6 +75,8 @@ pub enum Error {
     FilterPluginExpectedArgument,
     #[error("plugin couldn't parse argument {filter_arg:?}")]
     FilterPluginCouldntParseArgument { filter_arg: String },
+    #[error("language is required when passing a slice")]
+    LanguageMissingForSlice,
 }
 
 #[derive(Clone, Debug, Error)]
@@ -290,9 +293,14 @@ pub fn run_print(args: Args) -> Result<RunStatus, Error> {
     )
 }
 
+pub struct CaptureInfo<'node> {
+    pub node: Node<'node>,
+    pub pattern_index: usize,
+}
+
 pub fn run_with_callback(
     args: Args,
-    callback: impl Fn(Node, &[u8], &Path) + Sync,
+    callback: impl Fn(CaptureInfo, &[u8], &Path) + Sync,
 ) -> Result<RunStatus, Error> {
     run_for_context(
         args,
@@ -307,8 +315,8 @@ pub fn run_with_callback(
                 .search_path_callback::<_, io::Error>(
                     query_context,
                     path,
-                    |node: Node, file_contents: &[u8], path: &Path| {
-                        callback(node, file_contents, path);
+                    |capture_info: CaptureInfo, file_contents: &[u8], path: &Path| {
+                        callback(capture_info, file_contents, path);
                         matched.store(true, Ordering::SeqCst);
                     },
                 )
@@ -412,6 +420,160 @@ fn run_for_context<TContext: Sync>(
     })
 }
 
+pub fn run_for_slice_with_callback(
+    slice: &[u8],
+    args: Args,
+    mut callback: impl FnMut(CaptureInfo) + Sync,
+) -> Result<RunStatus, Error> {
+    let language = args.language.ok_or(Error::LanguageMissingForSlice)?;
+    let query_text = args.get_loaded_query_text()?;
+    let filter = args.get_loaded_filter()?;
+    let cached_queries: CachedQueries = Default::default();
+    let capture_index = CaptureIndex::default();
+    let matched = AtomicBool::new(false);
+    let non_fatal_errors: Arc<Mutex<Vec<NonFatalError>>> = Default::default();
+
+    let query = match cached_queries.get_and_cache_query_for_language(&query_text, language) {
+        Some(query) => query,
+        None => {
+            return Err(cached_queries
+                .error_if_no_successful_query_parsing()
+                .unwrap_err())
+        }
+    };
+    let capture_index = capture_index.get_or_init(&query, args.capture_name.as_deref())?;
+
+    let query_context = QueryContext::new(query, capture_index, language.language(), filter);
+
+    get_searcher(&args)
+        .borrow_mut()
+        .search_slice_callback_no_path(query_context, slice, |capture_info: CaptureInfo| {
+            callback(capture_info);
+            matched.store(true, Ordering::SeqCst);
+        })
+        .unwrap();
+
+    let non_fatal_errors = non_fatal_errors.lock().unwrap().clone();
+    if non_fatal_errors.is_empty() {
+        cached_queries.error_if_no_successful_query_parsing()?;
+    }
+
+    Ok(RunStatus {
+        matched: matched.load(Ordering::SeqCst),
+        non_fatal_errors,
+    })
+}
+
+pub fn run_with_per_file_callback(
+    args: Args,
+    per_file_callback: impl Fn(&DirEntry, Box<dyn FnMut(Box<dyn FnMut(CaptureInfo, &[u8], &Path) + '_>) + '_>)
+        + Sync,
+) -> Result<RunStatus, Error> {
+    let query_text = args.get_loaded_query_text()?;
+    let filter = args.get_loaded_filter()?;
+    let cached_queries: CachedQueries = Default::default();
+    let capture_index = CaptureIndex::default();
+    let matched = AtomicBool::new(false);
+    let searched = AtomicBool::new(false);
+    let non_fatal_errors: Arc<Mutex<Vec<NonFatalError>>> = Default::default();
+
+    for_each_project_file(
+        &args,
+        non_fatal_errors.clone(),
+        |project_file_dir_entry, matched_languages| {
+            searched.store(true, Ordering::SeqCst);
+            let language = match args.language {
+                Some(specified_language) => {
+                    if !matched_languages.contains(&specified_language) {
+                        return NonFatalError::ExplicitPathArgumentNotOfSpecifiedType {
+                            path: project_file_dir_entry.path().to_owned(),
+                            specified_language,
+                        }
+                        .into();
+                    }
+                    specified_language
+                }
+                None => match matched_languages.len() {
+                    0 => {
+                        return NonFatalError::ExplicitPathArgumentNotOfKnownType {
+                            path: project_file_dir_entry.path().to_owned(),
+                        }
+                        .into();
+                    }
+                    1 => matched_languages[0],
+                    _ => {
+                        let successfully_parsed_query_languages = matched_languages
+                            .iter()
+                            .filter_map(|&matched_language| {
+                                cached_queries
+                                    .get_and_cache_query_for_language(&query_text, matched_language)
+                                    .map(|_| matched_language)
+                            })
+                            .collect::<Vec<_>>();
+                        match successfully_parsed_query_languages.len() {
+                            0 => {
+                                return Ok(SingleFileSearchNonFailure::QueryNotParseableForFile);
+                            }
+                            1 => successfully_parsed_query_languages[0],
+                            _ => {
+                                return NonFatalError::AmbiguousLanguageForFile {
+                                    path: project_file_dir_entry.path().to_owned(),
+                                    languages: successfully_parsed_query_languages,
+                                }
+                                .into();
+                            }
+                        }
+                    }
+                },
+            };
+            let query = match cached_queries.get_and_cache_query_for_language(&query_text, language)
+            {
+                Some(query) => query,
+                None => return Ok(SingleFileSearchNonFailure::QueryNotParseableForFile),
+            };
+            let capture_index = capture_index.get_or_init(&query, args.capture_name.as_deref())?;
+            let path =
+                format_relative_path(project_file_dir_entry.path(), args.is_using_default_paths());
+
+            let query_context =
+                QueryContext::new(query, capture_index, language.language(), filter.clone());
+
+            per_file_callback(
+                &project_file_dir_entry,
+                Box::new(|mut per_match_callback| {
+                    get_searcher(&args)
+                        .borrow_mut()
+                        .search_path_callback::<_, io::Error>(
+                            query_context.clone(),
+                            path,
+                            |capture_info: CaptureInfo, file_contents: &[u8], path: &Path| {
+                                per_match_callback(capture_info, file_contents, path);
+                                matched.store(true, Ordering::SeqCst);
+                            },
+                        )
+                        .unwrap();
+                }),
+            );
+
+            Ok(SingleFileSearchNonFailure::RanQuery)
+        },
+    )?;
+
+    let mut non_fatal_errors = non_fatal_errors.lock().unwrap().clone();
+    if non_fatal_errors.is_empty() {
+        if !searched.load(Ordering::SeqCst) {
+            non_fatal_errors.push(NonFatalError::NothingSearched);
+        } else {
+            cached_queries.error_if_no_successful_query_parsing()?;
+        }
+    }
+
+    Ok(RunStatus {
+        matched: matched.load(Ordering::SeqCst),
+        non_fatal_errors,
+    })
+}
+
 fn for_each_project_file(
     args: &Args,
     non_fatal_errors: Arc<Mutex<Vec<NonFatalError>>>,

src/query_context.rs

@@ -4,6 +4,7 @@ use tree_sitter::{Language, Query};
 
 use crate::plugin::Filterer;
 
+#[derive(Clone)]
 pub struct QueryContext {
     pub query: Arc<Query>,
     pub capture_index: u32,