use std::collections::HashMap;
use crate::frecency::Frecency;
use crate::model::{Item, Source};
const PER_SOURCE_CAP: usize = 6;
const FILE_SCORE_CEILING: f32 = 4.0;
pub fn merge(mut items: Vec<Item>, query: &str, frecency: &Frecency) -> Vec<Item> {
if items.is_empty() {
return items;
}
let tokens: Vec<String> = query
.split_whitespace()
.map(str::to_lowercase)
.filter(|token| !token.is_empty())
.collect();
let mut seen_per_source: HashMap<u8, usize> = HashMap::new();
for item in &mut items {
let kind = source_kind(&item.source);
let position = seen_per_source.entry(kind).or_default();
let rank_penalty = (*position as f32) * 0.03;
*position += 1;
item.score = base_score(item, &tokens) - rank_penalty;
}
frecency.boost(&mut items);
items.sort_by(|a, b| {
b.score
.partial_cmp(&a.score)
.unwrap_or(std::cmp::Ordering::Equal)
});
cap_per_source(items)
}
fn source_kind(source: &Source) -> u8 {
match source {
Source::Window { .. } => 0,
Source::Launcher => 1,
Source::File { .. } => 2,
Source::Plugin { .. } => 3,
Source::Clipboard { .. } => 4,
Source::System { .. } => 5,
Source::Process { .. } => 6,
Source::Url { .. } => 7,
Source::Calc { .. } => 8,
Source::Emoji { .. } => 9,
}
}
fn base_score(item: &Item, tokens: &[String]) -> f32 {
let title = item.title.to_lowercase();
match &item.source {
Source::Window { .. } => 1.05,
Source::Plugin { .. } => 0.95,
Source::Clipboard { .. } => 1.1,
Source::File { .. } => (item.score / FILE_SCORE_CEILING).clamp(0.0, 1.0) * 0.9,
Source::Launcher => title_match(&title, tokens),
Source::System { .. } => item.score.clamp(0.0, 1.0),
Source::Process { .. } => 1.0,
Source::Calc { .. } | Source::Emoji { .. } => 1.0,
Source::Url { .. } => item.score.clamp(0.0, 1.0),
}
}
fn title_match(title: &str, tokens: &[String]) -> f32 {
if tokens.is_empty() {
return 0.5;
}
let matched = tokens
.iter()
.filter(|token| title.contains(token.as_str()))
.count();
if matched == 0 {
return 0.15;
}
let coverage = matched as f32 / tokens.len() as f32;
let longest = tokens
.iter()
.max_by_key(|token| token.len())
.map_or("", String::as_str);
let placement = if title == longest {
1.0
} else if title.starts_with(longest) {
0.9
} else if title.contains(longest) {
0.75
} else {
0.6
};
coverage * placement
}
pub fn promote_pinned(items: &mut Vec<Item>, is_pinned: impl Fn(&crate::model::ItemKey) -> bool) {
let (pinned, rest): (Vec<Item>, Vec<Item>) = std::mem::take(items)
.into_iter()
.partition(|item| is_pinned(&item.key));
*items = pinned;
items.extend(rest);
}
fn cap_per_source(items: Vec<Item>) -> Vec<Item> {
let mut counts: HashMap<u8, usize> = HashMap::new();
items
.into_iter()
.filter(|item| {
let count = counts.entry(source_kind(&item.source)).or_default();
*count += 1;
*count <= PER_SOURCE_CAP
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::ItemKey;
use std::path::PathBuf;
fn item(title: &str, source: Source, score: f32) -> Item {
Item {
key: ItemKey(format!("{title}:{}", source_kind(&source))),
id: 0,
title: title.to_owned(),
subtitle: String::new(),
icon: None,
category_icon: None,
window: None,
source,
autocomplete: None,
score,
}
}
#[test]
fn strong_file_match_beats_unrelated_application() {
let items = vec![
item("Alpha Protocol", Source::Launcher, 0.0),
item("pwvucontrol", Source::Launcher, 0.0),
item(
"Cargo.toml",
Source::File {
path: PathBuf::from("/home/u/project/Cargo.toml"),
},
3.5,
),
];
let ranked = merge(items, "cargo.toml", &Frecency::default());
assert_eq!(ranked[0].title, "Cargo.toml");
}
#[test]
fn name_match_beats_keyword_match() {
let items = vec![
item("Garuda Toolbox", Source::Launcher, 0.0),
item("Firefox", Source::Launcher, 0.0),
];
let ranked = merge(items, "firefox", &Frecency::default());
assert_eq!(ranked[0].title, "Firefox");
}
#[test]
fn windows_outrank_launchables() {
let items = vec![
item("Firefox", Source::Launcher, 0.0),
item(
"Firefox — report.pdf",
Source::Window {
identifier: "1".to_owned(),
},
0.0,
),
];
let ranked = merge(items, "firefox", &Frecency::default());
assert!(matches!(ranked[0].source, Source::Window { .. }));
}
#[test]
fn one_source_cannot_fill_the_list() {
let mut items: Vec<Item> = (0..20)
.map(|i| {
item(
&format!("file{i}.txt"),
Source::File {
path: PathBuf::from(format!("/home/u/file{i}.txt")),
},
3.0,
)
})
.collect();
items.push(item("Files", Source::Launcher, 0.0));
let ranked = merge(items, "files", &Frecency::default());
let files = ranked
.iter()
.filter(|item| matches!(item.source, Source::File { .. }))
.count();
assert_eq!(files, PER_SOURCE_CAP);
assert!(ranked.iter().any(|item| item.source == Source::Launcher));
}
#[test]
fn pinned_items_rise_but_only_when_present() {
let mut items = vec![
item("Alpha", Source::Launcher, 0.9),
item("Beta", Source::Launcher, 0.8),
item("Gamma", Source::Launcher, 0.7),
];
let pinned: std::collections::HashSet<&str> = ["Gamma:1", "Beta:1", "absent:1"].into();
promote_pinned(&mut items, |key| pinned.contains(key.as_str()));
let titles: Vec<&str> = items.iter().map(|item| item.title.as_str()).collect();
assert_eq!(titles, ["Beta", "Gamma", "Alpha"]);
}
#[test]
fn earlier_results_within_a_source_keep_their_edge() {
let items = vec![
item("Firefox", Source::Launcher, 0.0),
item("Firefox Developer Edition", Source::Launcher, 0.0),
];
let ranked = merge(items, "firefox", &Frecency::default());
assert_eq!(ranked[0].title, "Firefox");
}
}