use crate::analyzer::{Definition, Method, query_definition, query_methods};
use crate::error::Result;
#[must_use]
pub fn filter_methods<'a>(methods: &'a [Method], query: &str) -> Vec<&'a Method> {
if query.is_empty() {
return methods.iter().collect();
}
let mut scored: Vec<(u8, &Method)> = methods
.iter()
.filter_map(|m| {
let score = if m.name == query {
3
} else if m.name.starts_with(query) {
2
} else if m.name.contains(query) {
1
} else {
return None;
};
Some((score, m))
})
.collect();
scored.sort_by_key(|a| std::cmp::Reverse(a.0));
scored.into_iter().map(|(_, m)| m).collect()
}
pub struct MethodResult {
pub method: Method,
pub definition: Option<Definition>,
}
pub fn query_definition_for_methods(
methods: &[Method],
type_name: &str,
deps: Option<&str>,
ra_path: &std::path::Path,
) -> Result<Vec<MethodResult>> {
methods
.iter()
.map(|method| {
let definition = query_definition(type_name, &method.name, ra_path, deps)?;
Ok(MethodResult {
method: Method {
name: method.name.clone(),
detail: method.detail.clone(),
documentation: method.documentation.clone(),
},
definition,
})
})
.collect()
}
pub struct MethodQuery<'a> {
type_name: &'a str,
deps: Option<&'a str>,
filter: Option<&'a str>,
limit: Option<usize>,
}
impl<'a> MethodQuery<'a> {
#[must_use]
pub const fn new(type_name: &'a str) -> Self {
Self {
type_name,
deps: None,
filter: None,
limit: None,
}
}
#[must_use]
pub const fn deps(mut self, deps: &'a str) -> Self {
self.deps = Some(deps);
self
}
#[must_use]
pub const fn filter(mut self, query: &'a str) -> Self {
self.filter = Some(query);
self
}
pub fn run(self, ra_path: &std::path::Path) -> Result<Vec<Method>> {
let methods = query_methods(self.type_name, ra_path, self.deps)?;
let mut filtered = match self.filter {
Some(q) => filter_methods(&methods, q).into_iter().cloned().collect(),
None => methods,
};
if let Some(l) = self.limit {
filtered.truncate(l);
}
Ok(filtered)
}
pub fn run_with_definitions(self, ra_path: &std::path::Path) -> Result<Vec<MethodResult>> {
let type_name = self.type_name;
let deps = self.deps;
let methods = self.run(ra_path)?;
query_definition_for_methods(&methods, type_name, deps, ra_path)
}
#[must_use]
pub const fn limit(mut self, limit: usize) -> Self {
self.limit = Some(limit);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::analyzer::Method;
fn make_methods(names: &[&str]) -> Vec<Method> {
names
.iter()
.map(|&name| Method {
name: name.to_string(),
detail: None,
documentation: None,
})
.collect()
}
#[test]
fn filter_empty_query_returns_all() {
let methods = make_methods(&["push", "pop", "len"]);
let result = filter_methods(&methods, "");
assert_eq!(result.len(), 3);
}
#[test]
fn filter_exact_match_scores_highest() {
let methods = make_methods(&["get_mut", "get", "get_key_value"]);
let result = filter_methods(&methods, "get");
assert_eq!(result[0].name, "get", "exact match should be first");
}
#[test]
fn filter_prefix_before_substring() {
let methods = make_methods(&["forget", "get_mut", "get"]);
let result = filter_methods(&methods, "get");
let names: Vec<&str> = result.iter().map(|m| m.name.as_str()).collect();
assert_eq!(names, ["get", "get_mut", "forget"]);
}
#[test]
fn filter_no_match_returns_empty() {
let methods = make_methods(&["push", "pop", "len"]);
let result = filter_methods(&methods, "zzz");
assert!(result.is_empty());
}
#[test]
fn filter_excludes_non_matching() {
let methods = make_methods(&["push", "pop", "get", "len"]);
let result = filter_methods(&methods, "get");
assert_eq!(result.len(), 1);
assert_eq!(result[0].name, "get");
}
#[test]
fn limit_truncates_results() {
let methods = make_methods(&["push", "pop", "len", "get", "insert"]);
let result = filter_methods(&methods, "");
let limited: Vec<&str> = result
.into_iter()
.take(3)
.map(|m| m.name.as_str())
.collect();
assert_eq!(limited, ["push", "pop", "len"]);
}
#[test]
fn limit_larger_than_results_returns_all() {
let methods = make_methods(&["push", "pop"]);
let result = filter_methods(&methods, "");
assert_eq!(result.len(), 2); }
#[test]
fn builder_limit_truncates_after_filter() {
let methods = make_methods(&["get", "get_mut", "get_key_value", "get_unchecked"]);
let filtered: Vec<&Method> = filter_methods(&methods, "get")
.into_iter()
.take(2)
.collect();
assert_eq!(filtered.len(), 2);
assert_eq!(filtered[0].name, "get"); }
}