use std::fmt;
pub fn abbreviate(target: &str, depth: usize) -> String {
let normalized = target.replace("::", ".");
let segments: Vec<&str> = normalized.split('.').collect();
if segments.is_empty() {
return target.to_string();
}
if depth == 0 {
return segments.last().copied().unwrap_or("").to_string();
}
let keep_from = segments.len().saturating_sub(depth);
let mut out = String::new();
for (i, seg) in segments.iter().enumerate() {
if i > 0 {
out.push('.');
}
if i < keep_from {
if let Some(c) = seg.chars().next() {
out.push(c);
} else {
out.push_str(seg);
}
} else {
out.push_str(seg);
}
}
out
}
pub fn abbreviate_to_writer(
target: &str,
depth: usize,
writer: &mut dyn fmt::Write,
) -> fmt::Result {
if target.is_empty() {
return Ok(());
}
let segments: Vec<&str> = SegIter::new(target).collect();
if segments.is_empty() {
return writer.write_str(target);
}
if depth == 0 {
return writer.write_str(segments.last().copied().unwrap_or(""));
}
let keep_from = segments.len().saturating_sub(depth);
for (i, seg) in segments.iter().enumerate() {
if i > 0 {
writer.write_str(".")?;
}
if i < keep_from {
if let Some(c) = seg.chars().next() {
write!(writer, "{}", c)?;
} else {
writer.write_str(seg)?;
}
} else {
writer.write_str(seg)?;
}
}
Ok(())
}
struct SegIter<'a> {
remaining: &'a str,
}
impl<'a> SegIter<'a> {
fn new(s: &'a str) -> Self {
Self { remaining: s }
}
}
impl<'a> Iterator for SegIter<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<Self::Item> {
if self.remaining.is_empty() {
return None;
}
let pos = if let Some(p) = self.remaining.find("::") {
if let Some(dp) = self.remaining.find('.') {
if dp < p {
dp
} else {
p
}
} else {
p
}
} else if let Some(p) = self.remaining.find('.') {
p
} else {
let seg = self.remaining;
self.remaining = "";
return Some(seg);
};
let seg = &self.remaining[..pos];
if self.remaining[pos..].starts_with("::") {
self.remaining = &self.remaining[pos + 2..];
} else {
self.remaining = &self.remaining[pos + 1..];
}
Some(seg)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn depth_zero_returns_last_segment() {
assert_eq!(abbreviate("com.example.foo.Bar", 0), "Bar");
}
#[test]
fn depth_one_abbreviates_all_but_last() {
assert_eq!(abbreviate("com.example.foo.Bar", 1), "c.e.f.Bar");
}
#[test]
fn depth_two_keeps_last_two_segments() {
assert_eq!(abbreviate("com.example.foo.Bar", 2), "c.e.foo.Bar");
}
#[test]
fn single_segment_passes_through() {
assert_eq!(abbreviate("Bar", 1), "Bar");
assert_eq!(abbreviate("Bar", 0), "Bar");
}
#[test]
fn depth_larger_than_segments_keeps_everything() {
assert_eq!(abbreviate("a.b.c", 10), "a.b.c");
}
#[test]
fn rust_module_path_uses_dot_output() {
assert_eq!(abbreviate("my::app::service", 1), "m.a.service");
}
#[test]
fn empty_segment_is_preserved() {
assert_eq!(abbreviate("a..b", 0), "b");
assert_eq!(abbreviate("a..b", 1), "a..b");
}
}