Prune commentary and stale Rust port notes

app-rust/src/client/text_cap.rs

@@ -1,50 +1,17 @@
-//! How much of a long thing a transcript draws before offering the rest
-//! behind a tap.
-//!
-//! One rule, four surfaces: a tool call's input, its output, and a user or
-//! assistant message. It lives here rather than at any one of them because
-//! four copies would eventually disagree about what "too long" is, and
-//! because the Compose app has to answer the same question the same way --
-//! `TextCap.kt` is the Kotlin half, and the two are checked against the
-//! same numbers so a benchmark comparing the apps is comparing renderers
-//! rather than policies.
-//!
-//! **Lines and bytes both, whichever runs out first**, because they run
-//! out on different things: a diff is thousands of short lines, a minified
-//! file or a base64 blob is one enormous one, and a cap that only counted
-//! one of them draws the whole of the other.
-//!
-//! **Cut at the head, keeping the beginning.** A tool's output is read
-//! from the top and the line saying what went wrong is nearly always the
-//! first; a message is read from the top for the obvious reason. (A path
-//! is identified by its other end -- none of these is a path.)
-
 /// The default bound on a verbatim block -- a tool call's input or its
 /// output. Short, because this text is a machine's and the reader is
 /// looking for one line of it.
 pub const VERBATIM_LINES: usize = 80;
 pub const VERBATIM_BYTES: usize = 4096;
 
-/// The bound on a message, a person's or the model's. Larger than a
-/// verbatim block's in bytes and smaller in lines: prose is read whole and
-/// wraps, so a screenful of it is far fewer lines than a screenful of a
-/// log, and cutting a reply at 80 lines would cut most long answers that
-/// nobody would call long.
 pub const MESSAGE_LINES: usize = 200;
 pub const MESSAGE_BYTES: usize = 16 * 1024;
 
-/// A cap of nothing would draw an empty panel and a "Show all" for
-/// everything there is, which reads as a rendering fault rather than as a
-/// cap. Checked at compile time, since all four are constants.
 const _: () = assert!(VERBATIM_LINES > 0 && VERBATIM_BYTES > 0);
 const _: () = assert!(MESSAGE_LINES > 0 && MESSAGE_BYTES > 0);
 
 /// `text` cut to `max_lines` lines and `max_bytes` bytes, with the line
 /// count it was cut *from*; `None` when the whole of it fits.
-///
-/// The count is the whole text's, not the shown part's -- it is what the
-/// "Show all N lines" offer says, and a reader deciding whether to ask for
-/// the rest wants to know how much the rest is.
 pub fn cut(text: &str, max_lines: usize, max_bytes: usize) -> Option<(&str, usize)> {
     debug_assert!(
         max_lines > 0 && max_bytes > 0,
@@ -72,8 +39,6 @@ pub fn cut(text: &str, max_lines: usize, max_bytes: usize) -> Option<(&str, usiz
     Some((&text[..cut], text.lines().count()))
 }
 
-/// What a "Show all" offer says, so the wording is one string rather than
-/// one per surface.
 pub fn show_all_label(lines: usize) -> String {
     format!("Show all {lines} lines")
 }
@@ -98,8 +63,6 @@ mod tests {
         );
     }
 
-    /// The half the line bound cannot catch: one enormous line, which is
-    /// what a minified file or an embedded image arrives as.
     #[test]
     fn the_byte_bound_cuts_one_long_line() {
         let text = "x".repeat(5000);
@@ -108,7 +71,6 @@ mod tests {
         assert_eq!(lines, 1);
     }
 
-    /// Whichever bites first, rather than whichever was checked first.
     #[test]
     fn the_tighter_of_the_two_bounds_wins() {
         let text = "aaaa\n".repeat(100);
@@ -118,9 +80,6 @@ mod tests {
         assert_eq!(shown, "aaaa\naaaa\naaaa\naaaa");
     }
 
-    /// A cut that lands inside a multi-byte character has to back up to
-    /// the boundary; slicing there would panic, and a transcript carries
-    /// em dashes and box drawing in every other line.
     #[test]
     fn a_cut_inside_a_multibyte_character_backs_up_to_the_boundary() {
         let text = "é".repeat(100);