use std::collections::BTreeMap;
use sealmap_model::{Codebase, ContentHash, DescriptorKind, DescriptorView, IdView, SymbolId};
const MAX_LEVEL: u8 = 5;
#[derive(Debug, Clone)]
pub(crate) struct ShortNames<'a> {
by_id: BTreeMap<&'a SymbolId, String>,
by_short: BTreeMap<String, &'a SymbolId>,
}
impl<'a> ShortNames<'a> {
pub(crate) fn new(cb: &'a Codebase) -> Self {
let ids: Vec<&'a SymbolId> = cb.symbols.keys().collect();
let mut level = vec![0u8; ids.len()];
let mut names: Vec<String> = ids.iter().map(|id| candidate(id, 0)).collect();
loop {
let groups = collisions(&names);
if groups.is_empty() {
break;
}
let mut progressed = false;
for i in groups.into_iter().flatten() {
while level[i] < MAX_LEVEL {
level[i] += 1;
let next = candidate(ids[i], level[i]);
if next != names[i] {
names[i] = next;
progressed = true;
break;
}
}
}
if !progressed {
for group in collisions(&names) {
for (k, i) in group.into_iter().enumerate().skip(1) {
names[i] = format!("{}'{k}", names[i]);
}
}
break;
}
}
let mut by_id = BTreeMap::new();
let mut by_short = BTreeMap::new();
for (id, name) in ids.into_iter().zip(names) {
by_short.insert(name.clone(), id);
by_id.insert(id, name);
}
debug_assert_eq!(by_id.len(), by_short.len(), "short names must be unique");
Self { by_id, by_short }
}
pub(crate) fn get(&self, id: &SymbolId) -> Option<&str> {
self.by_id.get(id).map(String::as_str)
}
pub(crate) fn resolve(&self, short: &str) -> Option<&'a SymbolId> {
self.by_short.get(short).copied()
}
pub(crate) fn iter(&self) -> impl Iterator<Item = (&str, &'a SymbolId)> + '_ {
self.by_short.iter().map(|(s, id)| (s.as_str(), *id))
}
}
fn collisions(names: &[String]) -> Vec<Vec<usize>> {
let mut seen: BTreeMap<&str, Vec<usize>> = BTreeMap::new();
for (i, n) in names.iter().enumerate() {
seen.entry(n.as_str()).or_default().push(i);
}
seen.into_values().filter(|g| g.len() > 1).collect()
}
pub(crate) fn candidate(id: &SymbolId, level: u8) -> String {
let mut out = match id.view() {
IdView::Global(g) => {
let split = g.descriptors.iter().position(|d| d.kind != DescriptorKind::Namespace);
let (ns, items) = g.descriptors.split_at(split.unwrap_or(g.descriptors.len()));
let module = || match ns.last() {
Some(last) => format!("{}/", last.name),
None => format!("{}/", g.package),
};
let qualified = || {
let mut s: String = ns.iter().map(|d| format!("{}/", d.name)).collect();
s.push_str(&render(items));
if s.is_empty() { format!("{}/", g.package) } else { s }
};
match level {
0 | 1 if items.is_empty() => module(),
0 => render(tail(items, false)),
1 => render(tail(items, true)),
2 => qualified(),
_ => format!("{}:{}", g.package, qualified()),
}
}
IdView::Path(_) | IdView::Unresolved(_) => id.display_path(),
};
out.retain(|c| !c.is_whitespace());
if out.is_empty() {
out.push('_');
}
if level >= 4 {
let hash = ContentHash::of_text(id.as_str());
out.push('\'');
out.push_str(hash.short(if level == 4 { 8 } else { 64 }));
}
out
}
fn tail<'v, 'a>(items: &'v [DescriptorView<'a>], blocks: bool) -> Vec<&'v DescriptorView<'a>> {
let real: Vec<usize> =
items.iter().enumerate().filter(|(_, d)| d.kind != DescriptorKind::TypeParameter).map(|(i, _)| i).collect();
let from = real.len().saturating_sub(2);
match real.get(from) {
Some(&start) => items[start..].iter().filter(|d| blocks || d.kind != DescriptorKind::TypeParameter).collect(),
None => items.iter().collect(),
}
}
fn render<'v, 'a: 'v, I>(items: I) -> String
where
I: IntoIterator<Item = &'v DescriptorView<'a>>,
{
let mut s = String::new();
let mut after_namespace = true;
for d in items {
if !s.is_empty() && !after_namespace && d.kind != DescriptorKind::TypeParameter {
s.push('.');
}
after_namespace = false;
match d.kind {
DescriptorKind::TypeParameter => {
s.push('[');
s.push_str(&d.name);
s.push(']');
}
DescriptorKind::Parameter => {
s.push('(');
s.push_str(&d.name);
s.push(')');
}
DescriptorKind::Macro => {
s.push_str(&d.name);
s.push('!');
}
DescriptorKind::Meta => {
s.push_str(&d.name);
s.push(':');
}
DescriptorKind::Namespace => {
s.push_str(&d.name);
s.push('/');
after_namespace = true;
}
DescriptorKind::Type | DescriptorKind::Method | DescriptorKind::Term => s.push_str(&d.name),
}
}
s
}
#[cfg(test)]
mod tests {
use super::*;
fn id(s: &str) -> SymbolId {
SymbolId::parse(s).unwrap()
}
#[test]
fn levels_grow_one_qualifier_at_a_time() {
let put = id("sym:cargo shop . db/Db#[Store]put().");
let names: Vec<String> = (0..=3).map(|l| candidate(&put, l)).collect();
assert_eq!(names, ["Db.put", "Db[Store].put", "db/Db[Store].put", "shop:db/Db[Store].put"]);
assert!(candidate(&put, 4).starts_with("shop:db/Db[Store].put'"));
assert_eq!(candidate(&put, 4).len(), "shop:db/Db[Store].put'".len() + 8);
}
#[test]
fn modules_and_roots_end_in_a_slash() {
assert_eq!(candidate(&id("sym:cargo shop . db/"), 0), "db/");
assert_eq!(candidate(&id("sym:cargo shop . a/b/"), 2), "a/b/");
assert_eq!(candidate(&id("sym:cargo shop ."), 0), "shop/");
assert_eq!(candidate(&id("sym:cargo shop ."), 3), "shop:shop/");
}
#[test]
fn kinds_keep_their_marks_and_whitespace_goes() {
assert_eq!(candidate(&id("sym:cargo shop . log!"), 0), "log!");
assert_eq!(candidate(&id("sym:cargo shop . MAX."), 0), "MAX");
let from = id("sym:cargo shop . Db#[`Iterator<Item = u8>`]next().");
assert_eq!(candidate(&from, 1), "Db[Iterator<Item=u8>].next");
}
}