Add CompactStr for Debug Lines and Timestamp text

nullstalgia · nullstalgia · commit 8aede30b6f8f · 2025-05-05T16:13:38.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,6 +17,7 @@ arc-swap = "1.7.1"
 better-panic = "0.3.0"
 chrono = "0.4.39"
 color-eyre = "0.6.3"
+compact_str = "0.9.0"
 crokey = { version = "1.1.2", features = ["serde"] }
 # crokey = { path = "../crokey", features = ["serde"] }
 derivative = "2.2.0"
diff --git a/src/tui/buffer/buf_line.rs b/src/tui/buffer/buf_line.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use ansi_to_tui::IntoText;
 use chrono::{DateTime, Local};
+use compact_str::{CompactString, ToCompactString, format_compact};
 use memchr::memmem::Finder;
 use ratatui::{
     layout::Size,
@@ -20,42 +21,42 @@ use crate::traits::{ByteSuffixCheck, FirstChars, LineHelpers};
 #[derive(Debug)]
 pub struct BufLine {
     pub timestamp: DateTime<Local>,
-    timestamp_str: String,
+    timestamp_str: CompactString,
 
     #[cfg(debug_assertions)]
-    debug_info: String,
+    debug_info: CompactString,
 
     value: Line<'static>,
-    // maybe? depends on whats easier to chain bytes from, for the hex view later
-    // raw_value: Vec<u8>,
+
     /// How many vertical lines are needed in the terminal to fully show this line.
-    rendered_line_height: usize,
-    // Might not be exactly accurate, but would be enough to place user input lines in proper space if needing to
-    pub(super) raw_buffer_index: usize,
+    // Truncated from usize, since even the ratatui sizes are capped there.
+    rendered_line_height: u16,
 
+    pub(super) raw_buffer_index: usize,
+    // TODO turn into enum
     pub(super) is_bytes: bool,
     pub(super) is_macro: bool,
 }
 
-impl PartialEq for BufLine {
-    fn eq(&self, other: &Self) -> bool {
-        self.timestamp == other.timestamp
-    }
-}
+// impl PartialEq for BufLine {
+//     fn eq(&self, other: &Self) -> bool {
+//         self.timestamp == other.timestamp
+//     }
+// }
 
-impl Eq for BufLine {}
+// impl Eq for BufLine {}
 
-impl PartialOrd for BufLine {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.timestamp.partial_cmp(&other.timestamp)
-    }
-}
+// impl PartialOrd for BufLine {
+//     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+//         self.timestamp.partial_cmp(&other.timestamp)
+//     }
+// }
 
-impl Ord for BufLine {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.timestamp.cmp(&other.timestamp)
-    }
-}
+// impl Ord for BufLine {
+//     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+//         self.timestamp.cmp(&other.timestamp)
+//     }
+// }
 
 // Many changes needed, esp. in regards to current app-state things (index, width, color, showing timestamp)
 impl BufLine {
@@ -80,15 +81,15 @@ impl BufLine {
         }
 
         #[cfg(debug_assertions)]
-        let debug_info = format!(
+        let debug_info = format_compact!(
             "({start}..{end}, {len}) ",
             start = raw_buffer_index,
             end = raw_buffer_index + raw_value.len(),
             len = raw_value.len(),
         );
 
         let mut bufline = Self {
-            timestamp_str: now.format(time_format).to_string(),
+            timestamp_str: now.format(time_format).to_compact_string(),
             timestamp: now,
             #[cfg(debug_assertions)]
             debug_info,
@@ -120,7 +121,7 @@ impl BufLine {
         }
         #[cfg(debug_assertions)]
         {
-            let debug_info = format!(
+            let debug_info = format_compact!(
                 "({start}..{end}, {len}) ",
                 start = self.raw_buffer_index,
                 end = self.raw_buffer_index + raw_value.len(),
@@ -182,11 +183,11 @@ impl BufLine {
         // Paragraph::line_count comes from an unstable ratatui feature (unstable-rendered-line-info)
         // which may be changed/removed in the future. If so, I'll need to roll my own wrapping/find someone's to steal.
         let height = para.line_count(area_width.saturating_sub(1));
-        self.rendered_line_height = height;
+        self.rendered_line_height = (height as u16);
         height
     }
 
-    pub fn get_line_height(&self) -> usize {
+    pub fn get_line_height(&self) -> u16 {
         self.rendered_line_height
     }
 
@@ -223,9 +224,9 @@ impl BufLine {
         self.raw_buffer_index
     }
 
-    pub fn timestamp(&self) -> (DateTime<Local>, &str) {
-        (self.timestamp, &self.timestamp_str)
-    }
+    // pub fn timestamp(&self) -> (DateTime<Local>, &str) {
+    //     (self.timestamp, &self.timestamp_str)
+    // }
 
     // pub fn is_bytes(&self) -> bool {}
 
diff --git a/src/tui/buffer/mod.rs b/src/tui/buffer/mod.rs
@@ -55,7 +55,7 @@ pub struct Buffer {
     raw_buffer: Vec<u8>,
     // Time-tagged indexes into `raw_buffer`, from each input from the port.
     buffer_timestamps: Vec<(usize, DateTime<Local>)>,
-    lines: Vec<BufLine>,
+    port_lines: Vec<BufLine>,
     user_lines: Vec<BufLine>,
     last_line_completed: bool,
 
@@ -106,7 +106,7 @@ impl Buffer {
         Self {
             raw_buffer: Vec::with_capacity(1024),
             buffer_timestamps: Vec::with_capacity(1024),
-            lines: Vec::with_capacity(1024),
+            port_lines: Vec::with_capacity(1024),
             user_lines: Vec::with_capacity(1024),
             last_terminal_size: Size::default(),
             state: BufferState {
@@ -215,7 +215,7 @@ impl Buffer {
         }
 
         if append_to_last {
-            let last_line = self.lines.last_mut().expect("can't append to nothing");
+            let last_line = self.port_lines.last_mut().expect("can't append to nothing");
             let last_index = last_line.index_in_buffer();
 
             let slice = &self.raw_buffer[last_index..start_index + trunc.len()];
@@ -267,7 +267,7 @@ impl Buffer {
             //         .join("")
             //         .escape_default()
             // );
-            self.lines.push(BufLine::new_with_line(
+            self.port_lines.push(BufLine::new_with_line(
                 line,
                 #[cfg(debug_assertions)]
                 orig,
@@ -313,7 +313,7 @@ impl Buffer {
         }
 
         // let _ = std::mem::take(&mut self.lines);
-        self.lines.clear();
+        self.port_lines.clear();
 
         // Taking these variables out of `self` temporarily to allow running &mut self methods while holding
         // references to these.
@@ -341,8 +341,9 @@ impl Buffer {
                 // If a user line isn't visible, ignore it when taking external new-lines into account.
                 .filter(|b| user_echo.filter_user_line(b))
                 .map(|b| (b.raw_buffer_index, b.timestamp, true)),
-            |device, user| match device.0.cmp(&user.0) {
-                Ordering::Equal => device.1 <= user.1,
+            // Interleaving by sorting in order of raw_buffer_index, if they're equal, then whichever has a sooner timestamp.
+            |port, user| match port.0.cmp(&user.0) {
+                Ordering::Equal => port.1 <= user.1,
                 Ordering::Less => true,
                 Ordering::Greater => false,
             },
@@ -418,7 +419,7 @@ impl Buffer {
 
     /// Updates each BufLine's render height with the new terminal width, returning the sum total at the end
     pub fn update_wrapped_line_heights(&mut self) -> usize {
-        self.lines.iter_mut().fold(0, |total, l| {
+        self.port_lines.iter_mut().fold(0, |total, l| {
             let new_height = l.update_line_height(
                 self.last_terminal_size.width,
                 self.state.timestamps_visible,
@@ -448,13 +449,18 @@ impl Buffer {
     }
     fn buflines_iter(&self) -> impl Iterator<Item = &BufLine> {
         if self.state.user_echo_input == UserEcho::None {
-            Either::Left(self.lines.iter())
+            Either::Left(self.port_lines.iter())
         } else {
-            Either::Right(interleave(
-                self.lines.iter(),
+            Either::Right(interleave_by(
+                self.port_lines.iter(),
                 self.user_lines
                     .iter()
                     .filter(|l| self.state.user_echo_input.filter_user_line(l)),
+                |port, user| match port.raw_buffer_index.cmp(&user.raw_buffer_index) {
+                    Ordering::Equal => port.timestamp <= user.timestamp,
+                    Ordering::Less => true,
+                    Ordering::Greater => false,
+                },
             ))
         }
     }
@@ -488,9 +494,9 @@ impl Buffer {
                         .enumerate()
                     {
                         current_line_index = index;
-                        current_line_height = entries_lines;
+                        current_line_height = entries_lines as usize;
 
-                        lines_from_top += entries_lines;
+                        lines_from_top += entries_lines as usize;
                         if lines_from_top > vert_scroll {
                             break;
                         }
@@ -578,7 +584,7 @@ impl Buffer {
         }
     }
     pub fn clear(&mut self) {
-        self.lines.clear();
+        self.port_lines.clear();
         self.buffer_timestamps.clear();
         self.user_lines.clear();
         self.raw_buffer.clear();
@@ -650,14 +656,16 @@ impl Buffer {
     /// taking into account if text wrapping is enabled or not.
     pub fn combined_height(&self) -> usize {
         if self.state.text_wrapping {
-            self.buflines_iter().map(|l| l.get_line_height()).sum()
+            self.buflines_iter()
+                .map(|l| l.get_line_height() as usize)
+                .sum()
         } else {
             self.buflines_iter().count()
         }
     }
 
     pub fn port_lines_len(&self) -> usize {
-        self.lines.len()
+        self.port_lines.len()
     }
 
     pub fn update_terminal_size(
