smart_format/combinator/

truncate.rs

use core::fmt;

use smart_string::DisplayExt;

/// Truncates formatted output to at most `max_chars` Unicode scalar values.
///
/// # Mechanism
///
/// Uses `DisplayExt::format_with` to intercept output chunks as they stream through
/// `fmt::Write::write_str`. A char counter tracks how many characters have been written.
/// When the limit is reached mid-chunk, the chunk is sliced at the char boundary before
/// the limit. After the limit, subsequent chunks are silently discarded (the counting
/// wrapper returns `Ok(())` without writing, so the inner `Display::fmt` runs to
/// completion without error).
pub struct Truncate<T> {
    inner: T,
    max_chars: usize,
}

impl<T> Truncate<T> {
    pub(crate) fn new(inner: T, max_chars: usize) -> Self {
        Truncate { inner, max_chars }
    }
}

impl<T: fmt::Display> fmt::Display for Truncate<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let max = self.max_chars;
        let mut remaining = max;

        self.inner.format_with(|s: Option<&str>| {
            let Some(s) = s else { return Ok(()) };
            if remaining == 0 {
                return Ok(());
            }

            let char_count = s.chars().count();
            if char_count <= remaining {
                remaining -= char_count;
                f.write_str(s)
            } else {
                // Slice at the char boundary before the limit.
                let byte_end = s
                    .char_indices()
                    .nth(remaining)
                    .map(|(i, _)| i)
                    .unwrap_or(s.len());
                remaining = 0;
                f.write_str(&s[..byte_end])
            }
        })
    }
}

/// Truncates with a tail indicator (e.g., "...").
///
/// `max_chars` is the **total output budget** including the tail. If the inner content
/// fits within the budget, it passes through unchanged (no tail shown). If it exceeds
/// the budget, inner content is truncated at `max_chars - tail_chars` and the tail is
/// appended. Total output is always `<= max_chars`.
pub struct TruncateWith<T> {
    inner: T,
    max_chars: usize,
    tail: &'static str,
}

impl<T> TruncateWith<T> {
    pub(crate) fn new(inner: T, max_chars: usize, tail: &'static str) -> Self {
        TruncateWith {
            inner,
            max_chars,
            tail,
        }
    }
}

impl<T: fmt::Display> fmt::Display for TruncateWith<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.max_chars == 0 {
            return Ok(());
        }

        let tail_chars = self.tail.chars().count();

        // If the tail alone exceeds the budget, fall back to plain truncation
        // (no tail appended) to honor the <= max_chars guarantee.
        if tail_chars >= self.max_chars {
            return Truncate::new(&self.inner, self.max_chars).fmt(f);
        }

        let content_budget = self.max_chars - tail_chars;

        // First pass: count total chars to decide whether truncation is needed.
        let mut total_chars: usize = 0;
        self.inner.format_with(|s: Option<&str>| {
            if let Some(s) = s {
                total_chars += s.chars().count();
            }
            Ok(())
        })?;

        if total_chars <= self.max_chars {
            // Fits without truncation — no tail needed.
            self.inner.fmt(f)
        } else {
            // Truncate inner to content_budget, then append tail.
            let mut remaining = content_budget;
            self.inner.format_with(|s: Option<&str>| {
                let Some(s) = s else { return Ok(()) };
                if remaining == 0 {
                    return Ok(());
                }

                let char_count = s.chars().count();
                if char_count <= remaining {
                    remaining -= char_count;
                    f.write_str(s)
                } else {
                    let byte_end = s
                        .char_indices()
                        .nth(remaining)
                        .map(|(i, _)| i)
                        .unwrap_or(s.len());
                    remaining = 0;
                    f.write_str(&s[..byte_end])
                }
            })?;
            f.write_str(self.tail)
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::combinator::SmartFormat;

    #[test]
    fn truncate_shorter_than_limit() {
        assert_eq!("hello", "hello".display_truncate(10).to_string());
    }

    #[test]
    fn truncate_exact_limit() {
        assert_eq!("hello", "hello".display_truncate(5).to_string());
    }

    #[test]
    fn truncate_over_limit() {
        assert_eq!("hel", "hello".display_truncate(3).to_string());
    }

    #[test]
    fn truncate_zero() {
        assert_eq!("", "hello".display_truncate(0).to_string());
    }

    #[test]
    fn truncate_empty() {
        assert_eq!("", "".display_truncate(5).to_string());
    }

    #[test]
    fn truncate_unicode() {
        // "АБВ" = 3 chars, each 2 bytes
        assert_eq!("АБ", "АБВ".display_truncate(2).to_string());
    }

    #[test]
    fn truncate_unicode_exact() {
        assert_eq!("АБВ", "АБВ".display_truncate(3).to_string());
    }

    #[test]
    fn truncate_with_no_truncation() {
        assert_eq!("hi", "hi".display_truncate_with(10, "...").to_string());
    }

    #[test]
    fn truncate_with_truncation() {
        assert_eq!(
            "hel...",
            "hello world".display_truncate_with(6, "...").to_string()
        );
    }

    #[test]
    fn truncate_with_exact_fit() {
        // "hello" = 5 chars, budget = 5 → no truncation
        assert_eq!("hello", "hello".display_truncate_with(5, "...").to_string());
    }

    #[test]
    fn truncate_with_tail_fills_budget() {
        // budget = 3, tail = "..." (3 chars) → tail >= budget, fall back to
        // plain truncation (no tail) to honor <= max_chars guarantee.
        assert_eq!("hel", "hello".display_truncate_with(3, "...").to_string());
    }

    #[test]
    fn truncate_with_tail_exceeds_budget() {
        // budget = 2, tail = "..." (3 chars) → tail > budget, plain truncation
        assert_eq!("he", "hello".display_truncate_with(2, "...").to_string());
    }

    #[test]
    fn truncate_with_zero_budget() {
        assert_eq!("", "hello".display_truncate_with(0, "...").to_string());
    }

    #[test]
    fn truncate_with_unicode() {
        // "Привіт" = 6 chars; budget 4, tail "…" (1 char) → 3 content chars + "…"
        assert_eq!("При…", "Привіт".display_truncate_with(4, "…").to_string());
    }

    #[test]
    fn truncate_with_number() {
        assert_eq!(
            "123...",
            123456789.display_truncate_with(6, "...").to_string()
        );
    }
}