use std::fmt;
pub fn abbreviate(name: &str, max_length: usize) -> String {
if name.is_empty() {
return String::new();
}
let segments: Vec<&str> = name.split("::").collect();
if segments.len() == 1 {
return if max_length == 0 {
name.to_string()
} else {
truncate_right(name, max_length)
};
}
if max_length == 0 {
return segments.last().unwrap_or(&"").to_string();
}
let last = *segments.last().unwrap();
let prefix_segments = &segments[..segments.len() - 1];
let last_len = last.len();
if last_len >= max_length {
return truncate_right(last, max_length);
}
let available = max_length.saturating_sub(last_len + 1); let mut result = String::new();
let mut remaining = available;
for (i, seg) in prefix_segments.iter().enumerate() {
if seg.is_empty() {
continue;
}
if remaining == 0 {
break;
}
let seg_len = seg.len();
if seg_len <= remaining {
if i > 0 && remaining >= 1 {
result.push('.');
remaining -= 1;
}
result.push_str(seg);
remaining -= seg_len;
} else if remaining >= 1 {
if i > 0 && remaining >= 1 {
result.push('.');
remaining -= 1;
}
if remaining >= 1 {
if let Some(c) = seg.chars().next() {
result.push(c);
remaining = 0;
}
}
} else {
break;
}
}
format!("{}.{}", result, last)
}
pub fn abbreviate_to_writer(
name: &str,
max_length: usize,
writer: &mut dyn fmt::Write,
) -> fmt::Result {
if name.is_empty() {
return Ok(());
}
let last = name.rsplit("::").next().unwrap_or(name);
let has_separator = name.contains("::");
if !has_separator {
if max_length == 0 {
return writer.write_str(name);
}
return truncate_right_write(name, max_length, writer);
}
if max_length == 0 {
return writer.write_str(last);
}
let last_len = last.len();
if last_len >= max_length {
return truncate_right_write(last, max_length, writer);
}
let prefix_end = name.len() - last.len() - 2; let prefix = &name[..prefix_end];
let available = max_length.saturating_sub(last_len + 1);
let mut remaining = available;
let mut first = true;
for seg in prefix.split("::") {
if seg.is_empty() {
continue;
}
if remaining == 0 {
break;
}
let seg_len = seg.len();
if seg_len <= remaining {
if !first && remaining >= 1 {
writer.write_str(".")?;
remaining -= 1;
}
writer.write_str(seg)?;
remaining -= seg_len;
} else if remaining >= 1 {
if !first && remaining >= 1 {
writer.write_str(".")?;
remaining -= 1;
}
if remaining >= 1 {
if let Some(c) = seg.chars().next() {
write!(writer, "{}", c)?;
remaining = 0;
}
}
} else {
break;
}
first = false;
}
write!(writer, ".{}", last)
}
fn truncate_right(s: &str, max_length: usize) -> String {
if s.len() <= max_length {
return s.to_string();
}
s.chars().take(max_length).collect()
}
fn truncate_right_write(s: &str, max_length: usize, writer: &mut dyn fmt::Write) -> fmt::Result {
if s.len() <= max_length {
return writer.write_str(s);
}
for c in s.chars().take(max_length) {
writer.write_char(c)?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_no_abbreviation() {
let name = "INFO";
assert_eq!(abbreviate(name, 20), "INFO");
}
#[test]
fn test_max_zero_returns_last_segment() {
let name = "my_app::db::pool";
assert_eq!(abbreviate(name, 0), "pool");
}
#[test]
fn test_simple_segment() {
let name = "my_app";
assert_eq!(abbreviate(name, 10), "my_app");
}
#[test]
fn test_logback_example() {
let name = "my_app::service::user_handler";
let result = abbreviate(name, 20);
assert!(
result.ends_with("user_handler"),
"expected ending with user_handler, got: {}",
result
);
assert!(!result.is_empty());
}
#[test]
fn test_empty_name() {
assert_eq!(abbreviate("", 20), "");
}
#[test]
fn test_single_long_segment() {
let name = "very_long_segment_name_here";
let result = abbreviate(name, 10);
assert_eq!(result.len(), 10);
}
#[test]
fn test_exact_length() {
let name = "INFO";
assert_eq!(abbreviate(name, 4), "INFO");
}
#[test]
fn test_logback_example_deterministic() {
let name = "my_app::service::user_handler";
let result = abbreviate(name, 20);
assert!(
result.ends_with("user_handler"),
"expected ending with user_handler, got: {}",
result
);
assert!(result.len() <= 20);
assert!(result.contains('.'));
}
#[test]
fn test_abbreviate_multiple_segments() {
let name = "com::example::my_app::handler";
let result = abbreviate(name, 15);
assert!(result.ends_with("handler"));
assert!(result.len() <= 15);
}
#[test]
fn test_no_colon_separator() {
let name = "single_logger";
let result = abbreviate(name, 10);
assert_eq!(result.len(), 10);
}
#[test]
fn test_last_segment_only_if_max_zero() {
let name = "com::example::my_app";
assert_eq!(abbreviate(name, 0), "my_app");
}
}