use streaming_iterator::StreamingIterator;
use tree_sitter::{Parser, Query, QueryCursor};
use super::grammar_spec;
use crate::errors::{Error, Result};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Capture {
pub name: String,
pub text: String,
pub start_line: usize,
pub end_line: usize,
}
pub fn run_query(source: &str, language: &str, query_src: &str) -> Result<Vec<Capture>> {
let spec =
grammar_spec(language).ok_or_else(|| Error::UnsupportedLanguage(language.to_string()))?;
let lang = (spec.language)();
let query = Query::new(&lang, query_src)
.map_err(|e| Error::Parse(format!("tree-sitter query: {e}")))?;
let mut parser = Parser::new();
parser
.set_language(&lang)
.map_err(|e| Error::Parse(e.to_string()))?;
let tree = parser
.parse(source, None)
.ok_or_else(|| Error::Parse("tree-sitter produced no tree".to_string()))?;
let bytes = source.as_bytes();
let names = query.capture_names();
let mut cursor = QueryCursor::new();
let mut captures = Vec::new();
let mut matches = cursor.matches(&query, tree.root_node(), bytes);
while let Some(matched) = matches.next() {
for capture in matched.captures {
let text = capture
.node
.utf8_text(bytes)
.unwrap_or_default()
.to_string();
captures.push(Capture {
name: names
.get(capture.index as usize)
.copied()
.unwrap_or_default()
.to_string(),
text,
start_line: capture.node.start_position().row + 1,
end_line: capture.node.end_position().row + 1,
});
}
}
Ok(captures)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn captures_line_comments_with_their_text() {
let source = "\
// TODO: wire this up
fn f() {}
// see ABC-123
";
let captures = run_query(source, "rust", "(line_comment) @c").unwrap();
let texts: Vec<&str> = captures.iter().map(|c| c.text.as_str()).collect();
assert!(texts.contains(&"// TODO: wire this up"));
assert!(texts.contains(&"// see ABC-123"));
let todo = captures.iter().find(|c| c.text.contains("TODO")).unwrap();
assert_eq!(todo.name, "c");
assert_eq!(todo.start_line, 1);
}
#[test]
fn a_malformed_query_is_an_error_not_an_empty_match() {
let err = run_query("fn f() {}", "rust", "(nonexistent_node) @x").unwrap_err();
assert!(matches!(err, Error::Parse(_)));
}
#[test]
fn an_unsupported_language_is_distinguished() {
let err = run_query("", "cobol", "(comment) @c").unwrap_err();
assert!(matches!(err, Error::UnsupportedLanguage(_)));
}
#[test]
fn no_captures_is_an_empty_vec_not_an_error() {
let captures = run_query("fn f() {}", "rust", "(line_comment) @c").unwrap();
assert!(captures.is_empty());
}
}