#![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
use crate::node::Node;
use crate::error::MetricsError;
use crate::traits::{ParserTrait, Search};
#[allow(clippy::unnecessary_wraps)]
pub fn find<'a, T: ParserTrait>(
parser: &'a T,
filters: &[String],
) -> Result<Vec<Node<'a>>, MetricsError> {
let filters = parser.filters(filters);
let mut good = Vec::new();
parser.root().act_on_node(&mut |node, ancestors| {
if filters.any(node, ancestors) {
good.push(*node);
}
});
Ok(good)
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use super::find;
use crate::count::count;
use crate::langs::RustParser;
use crate::node::Node;
use crate::traits::ParserTrait;
#[cfg(feature = "rust")]
#[test]
fn the_error_filter_matches_the_path_to_a_parse_error_and_nothing_else() {
let error = ["error".to_owned()];
let parse = |source: &str| {
RustParser::new(source.as_bytes().to_vec(), &PathBuf::from("t.rs"), None)
};
let kind_and_row = |node: &Node| (node.kind(), node.start_row());
let clean = parse("fn ok() {}\nfn also() {}\n");
let found = find(&clean, &error).expect("`find` is infallible");
assert_eq!(found.iter().map(kind_and_row).collect::<Vec<_>>(), []);
let (good, total) = count(&clean, &error);
assert_eq!(good, 0);
assert!(total > 1, "the clean fixture parsed to {total} nodes");
let broken = parse("fn ok() {}\nfn broken() { let = ; }\n");
let errors: Vec<_> = broken.root().preorder().filter(Node::is_error).collect();
let [error_node] = errors[..] else {
panic!("the fixture must recover into one `ERROR`, got {errors:?}");
};
assert!(broken.root().preorder().all(|node| !node.is_missing()));
let mut path: Vec<_> = std::iter::successors(Some(error_node), Node::parent)
.map(|node| kind_and_row(&node))
.collect();
path.reverse();
assert_eq!(
path,
[
("source_file", 0),
("function_item", 1),
("block", 1),
("ERROR", 1)
]
);
let found = find(&broken, &error).expect("`find` is infallible");
assert_eq!(found.iter().map(kind_and_row).collect::<Vec<_>>(), path);
assert_eq!(count(&broken, &error).0, path.len());
}
}