use second_brain_core::sqlite_store::SqliteStore;
use second_brain_core::store::StoreAdmin;
const MAX_NEAR_NAMES: usize = 5;
pub(super) fn refuse_unknown_project(
sqlite: &SqliteStore,
project: &str,
) -> anyhow::Result<Option<String>> {
if sqlite.scoped_count(None, None, Some(project))? > 0 {
return Ok(None);
}
let stored = sqlite.distinct_project_paths()?;
Ok(Some(unknown_project_message(project, &stored)))
}
fn unknown_project_message(name: &str, stored: &[(String, u64)]) -> String {
let near = near_names(name, stored);
if near.is_empty() {
format!(
"project \"{name}\" matches no stored project, and no stored project name is close; list_projects shows them all"
)
} else {
format!(
"project \"{name}\" matches no stored project; near names: {}",
near.join(", ")
)
}
}
fn near_names(name: &str, stored: &[(String, u64)]) -> Vec<String> {
let key = encode(name);
if key.is_empty() {
return Vec::new();
}
let allowed = (key.chars().count() / 3).max(1);
let mut near: Vec<(usize, u64, &str)> = stored
.iter()
.filter_map(|(slug, count)| {
let lowered = slug.to_ascii_lowercase();
let distance = if key.len() >= 3 && lowered.contains(&key) {
0
} else {
tails(&lowered)
.map(|tail| levenshtein(&key, tail))
.min()
.unwrap_or(usize::MAX)
};
(distance <= allowed).then_some((distance, *count, slug.as_str()))
})
.collect();
near.sort_by(|a, b| a.0.cmp(&b.0).then(b.1.cmp(&a.1)).then(a.2.cmp(b.2)));
near.into_iter()
.take(MAX_NEAR_NAMES)
.map(|(_, _, slug)| slug.to_string())
.collect()
}
fn encode(name: &str) -> String {
name.trim()
.chars()
.map(|c| {
if c.is_ascii_alphanumeric() {
c.to_ascii_lowercase()
} else {
'-'
}
})
.collect::<String>()
.trim_matches('-')
.to_string()
}
fn tails(slug: &str) -> impl Iterator<Item = &str> {
std::iter::once(slug).chain(
slug.match_indices('-')
.map(move |(i, _)| &slug[i + 1..])
.filter(|tail| !tail.is_empty()),
)
}
fn levenshtein(a: &str, b: &str) -> usize {
let b: Vec<char> = b.chars().collect();
let mut row: Vec<usize> = (0..=b.len()).collect();
for (i, ca) in a.chars().enumerate() {
let mut previous = row[0];
row[0] = i + 1;
for (j, cb) in b.iter().enumerate() {
let substituted = previous + usize::from(ca != *cb);
previous = row[j + 1];
row[j + 1] = substituted.min(row[j] + 1).min(row[j + 1] + 1);
}
}
row[b.len()]
}
#[cfg(test)]
mod tests {
use super::*;
fn stored(slugs: &[(&str, u64)]) -> Vec<(String, u64)> {
slugs.iter().map(|(s, c)| (s.to_string(), *c)).collect()
}
#[test]
fn a_typo_of_the_last_path_component_is_near() {
let stored = stored(&[("-srv-garden", 40), ("-srv-orchard", 30), ("-srv-notes", 5)]);
assert_eq!(near_names("gardn", &stored), vec!["-srv-garden"]);
assert_eq!(near_names("orhcard", &stored), vec!["-srv-orchard"]);
}
#[test]
fn a_slug_containing_the_name_ranks_before_a_typo_and_ties_go_to_the_bigger_project() {
let stored = stored(&[
("-srv-my-orchard", 3),
("-srv-orchard", 30),
("-srv-orcharx", 50),
]);
assert_eq!(
near_names("orchard", &stored),
vec!["-srv-orchard", "-srv-my-orchard", "-srv-orcharx"]
);
}
#[test]
fn an_unrelated_name_has_no_near_names() {
let stored = stored(&[("-srv-garden", 40), ("-srv-orchard", 30)]);
assert!(near_names("kubernetes", &stored).is_empty());
assert!(near_names(" ", &stored).is_empty());
}
#[test]
fn at_most_five_near_names_are_listed() {
let slugs: Vec<(String, u64)> = (0..8).map(|i| (format!("-p{i}-app"), i)).collect();
assert_eq!(near_names("app", &slugs).len(), 5);
}
#[test]
fn the_message_lists_near_names_or_points_at_list_projects() {
let stored = stored(&[("-srv-garden", 40)]);
assert_eq!(
unknown_project_message("gardn", &stored),
"project \"gardn\" matches no stored project; near names: -srv-garden"
);
let none = unknown_project_message("kubernetes", &stored);
assert!(none.contains("no stored project name is close"), "{none}");
assert!(none.contains("list_projects"), "{none}");
}
#[test]
fn levenshtein_counts_single_edits() {
assert_eq!(levenshtein("kitten", "sitting"), 3);
assert_eq!(levenshtein("", "abc"), 3);
assert_eq!(levenshtein("same", "same"), 0);
}
}