use crate::{
data::catalog::{
document::{
CatalogEntry,
EntryKind,
},
error::{
CatalogRule,
catalog_error,
},
name::CatalogName,
stack::{
BunsenCatalogStack,
EntryRef,
},
},
errors::BunsenResult,
};
pub const SEARCHABLE: [EntryKind; 9] = [
EntryKind::Build,
EntryKind::TemplateClass,
EntryKind::Namespace,
EntryKind::Release,
EntryKind::Tag,
EntryKind::Axis,
EntryKind::Facet,
EntryKind::Resource,
EntryKind::Type,
];
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LeafMatch {
Exact,
Prefix,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DisplayName {
pub short: String,
pub full: CatalogName,
}
impl CatalogName {
pub fn matches_query(
&self,
query: &str,
leaf: LeafMatch,
) -> bool {
let parts: Vec<&str> = query.split('/').collect();
self.matches_query_segments(&parts, leaf)
}
}
impl CatalogName {
fn matches_query_segments(
&self,
query: &[&str],
leaf: LeafMatch,
) -> bool {
let segments = self.segments();
let (Some((last, init)), Some((name_last, name_init))) =
(query.split_last(), segments.split_last())
else {
return false;
};
let leaf_ok = match leaf {
LeafMatch::Exact => name_last.eq_ignore_ascii_case(last),
LeafMatch::Prefix => name_last
.get(..last.len())
.is_some_and(|head| head.eq_ignore_ascii_case(last)),
};
if !leaf_ok {
return false;
}
let mut rest = name_init.iter();
init.iter().all(|q| rest.any(|s| s.eq_ignore_ascii_case(q)))
}
}
impl BunsenCatalogStack {
pub fn matches(
&self,
query: &str,
kinds: &[EntryKind],
leaf: LeafMatch,
) -> Vec<CatalogName> {
let parts: Vec<&str> = query.split('/').collect();
let mut found: Vec<CatalogName> = Vec::new();
for name in self
.declarations()
.filter(|e| e.name().matches_query_segments(&parts, leaf))
.filter_map(|e| self.as_found(e, kinds))
{
if !found.contains(&name) {
found.push(name);
}
}
found
}
fn as_found(
&self,
entry: EntryRef<'_>,
kinds: &[EntryKind],
) -> Option<CatalogName> {
match entry.body() {
CatalogEntry::Alias(alias) if kinds.contains(&alias.target.kind) => self
.resolve_ref(entry.name(), &alias.target.path)
.map(|target| target.name().clone()),
_ if kinds.contains(&entry.kind()) => Some(entry.name().clone()),
_ => None,
}
}
pub fn named_as(
&self,
name: &CatalogName,
kinds: &[EntryKind],
) -> Option<CatalogName> {
self.declaration(name)
.and_then(|entry| self.as_found(entry, kinds))
}
pub fn cased(
&self,
name: &CatalogName,
) -> Option<CatalogName> {
if self.declaration(name).is_some() {
return Some(name.clone());
}
let wanted = name.to_string();
self.declarations()
.map(|d| d.name())
.find(|n| n.to_string().eq_ignore_ascii_case(&wanted))
.cloned()
}
pub fn aliases_of(
&self,
name: &CatalogName,
) -> Vec<CatalogName> {
self.of_kind(EntryKind::Alias)
.into_iter()
.filter(|alias| {
let CatalogEntry::Alias(a) = alias.body() else {
return false;
};
self.resolve_ref(alias.name(), &a.target.path)
.is_some_and(|t| t.name() == name)
})
.map(|alias| alias.name().clone())
.collect()
}
pub fn find(
&self,
query: &str,
kinds: &[EntryKind],
leaf: LeafMatch,
) -> BunsenResult<CatalogName> {
if let Ok(full) = CatalogName::parse(query)
&& let Some(found) = self
.cased(&full)
.and_then(|name| self.named_as(&name, kinds))
{
return Ok(found);
}
let mut found = self.matches(query, kinds, leaf);
match found.len() {
1 => Ok(found.pop().expect("one")),
0 => Err(catalog_error(
CatalogRule::Lookup,
format!("nothing matches `{query}`"),
)),
_ => Err(catalog_error(
CatalogRule::Lookup,
format!(
"`{query}` is ambiguous: {}",
found
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(", ")
),
)),
}
}
pub fn find_build(
&self,
query: &str,
) -> BunsenResult<CatalogName> {
self.find(query, &[EntryKind::Build], LeafMatch::Exact)
}
pub fn display_name(
&self,
name: &CatalogName,
) -> DisplayName {
let segments = name.segments();
let (leaf, scope) = segments.split_last().expect("a name has a segment");
let mut short = name.to_string();
'search: for size in 0..=scope.len() {
for picked in choose(scope.len(), size) {
let mut parts: Vec<&str> = picked.iter().map(|&i| scope[i].as_str()).collect();
parts.push(leaf);
let query = parts.join("/");
if self.matches(&query, &SEARCHABLE, LeafMatch::Exact) == [name.clone()] {
short = query;
break 'search;
}
}
}
DisplayName {
short,
full: name.clone(),
}
}
}
fn choose(
n: usize,
size: usize,
) -> Vec<Vec<usize>> {
fn go(
start: usize,
n: usize,
size: usize,
current: &mut Vec<usize>,
out: &mut Vec<Vec<usize>>,
) {
if current.len() == size {
out.push(current.clone());
return;
}
for i in start..n {
current.push(i);
go(i + 1, n, size, current, out);
current.pop();
}
}
let mut out = Vec::new();
go(0, n, size, &mut Vec::new(), &mut out);
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::catalog::{
error::CatalogErrorExt,
testing::fixtures,
};
#[test]
fn test_subsequences_match_in_order() {
let name = CatalogName::parse("openai/whisper/large/large-v3").unwrap();
let m = |q: &str| {
let parts: Vec<&str> = q.split('/').collect();
name.matches_query_segments(&parts, LeafMatch::Exact)
};
assert!(m("large-v3"));
assert!(m("whisper/large-v3"));
assert!(m("openai/large-v3"));
assert!(m("openai/whisper/large/large-v3"));
assert!(!m("whisper/openai/large-v3"));
assert!(!m("large"));
let parts = ["large"];
assert!(name.matches_query_segments(&parts, LeafMatch::Prefix));
}
#[test]
fn test_find_by_shorter_names() {
let stack = fixtures::example_stack().unwrap();
let v3 = CatalogName::parse("openai/whisper/large/large-v3").unwrap();
for query in [
"large-v3",
"whisper/large-v3",
"openai/large-v3",
"openai/whisper/large/large-v3",
] {
assert_eq!(stack.find_build(query).unwrap(), v3, "{query}");
}
let err = stack.find_build("large-v4").unwrap_err();
assert!(err.problem_message().contains("nothing matches"));
let err = stack
.find("checkpoint", &SEARCHABLE, LeafMatch::Exact)
.unwrap_err();
assert!(err.problem_message().contains("ambiguous"), "{err}");
assert_eq!(
stack
.find("qwen3-0.6b/checkpoint", &SEARCHABLE, LeafMatch::Exact)
.unwrap()
.to_string(),
"qwen/qwen3/qwen3-0.6b/checkpoint"
);
}
#[test]
fn test_prefix_mode() {
let stack = fixtures::example_stack().unwrap();
let turbo = stack
.find("large-v3-t", &[EntryKind::Build], LeafMatch::Prefix)
.unwrap();
assert_eq!(turbo.leaf(), "large-v3-turbo");
let err = stack
.find("large", &[EntryKind::Build], LeafMatch::Prefix)
.unwrap_err();
assert!(err.problem_message().contains("ambiguous"));
}
#[test]
fn test_template_classes_are_found_like_any_entry() {
let stack = fixtures::example_stack().unwrap();
let hybrid = stack
.find("hybrid", &[EntryKind::TemplateClass], LeafMatch::Exact)
.unwrap();
assert_eq!(hybrid.to_string(), "qwen/qwen3/hybrid");
assert_eq!(stack.display_name(&hybrid).short, "hybrid");
assert_eq!(
stack
.find("template_class_root", &SEARCHABLE, LeafMatch::Exact)
.unwrap()
.to_string(),
"template_class_root"
);
}
#[test]
fn test_display_names_lengthen_when_a_later_layer_collides() {
let mut stack = fixtures::example_stack().unwrap();
let vocabulary = CatalogName::parse("openai/whisper/vocabulary").unwrap();
assert_eq!(stack.display_name(&vocabulary).short, "vocabulary");
let tokenizer = CatalogName::parse("qwen/qwen3/qwen3-0.6b/tokenizer").unwrap();
assert_eq!(stack.display_name(&tokenizer).short, "qwen3-0.6b/tokenizer");
stack
.push_yaml(
"more",
r#"
local:
$kind: namespace
$description: "Local things."
vocabulary:
$kind: resource
$file: v.txt
$format: text
$sources: [{ $url: "https://x/v.txt" }]
"#,
)
.unwrap();
let shown = stack.display_name(&vocabulary);
assert_eq!(shown.short, "openai/vocabulary");
assert_eq!(shown.full, vocabulary);
}
#[test]
fn test_choose() {
assert_eq!(choose(3, 0), [Vec::<usize>::new()]);
assert_eq!(choose(3, 2), [vec![0, 1], vec![0, 2], vec![1, 2]]);
}
}