Option to show line ending on received lines

nullstalgia · nullstalgia · commit ca3be18c753b · 2025-06-09T19:54:44.000-07:00
diff --git a/src/app.rs b/src/app.rs
@@ -315,25 +315,6 @@ impl App {
             Duration::from_secs(1),
         );
 
-        // let serial_signal_tick_handle = serial_handle.clone();
-        // let mut cache = arc_swap::Cache::new(std::sync::Arc::clone(
-        //     &serial_signal_tick_handle.port_status,
-        // ));
-        // event_carousel.add_repeating(
-        //     "SerialSignals",
-        //     Box::new(move || {
-        //         let port_status = cache.load();
-        //         if port_status.state.is_healthy() {
-        //             serial_signal_tick_handle
-        //                 .read_signals()
-        //                 .map_err(|e| e.to_string())
-        //         } else {
-        //             Ok(())
-        //         }
-        //     }),
-        //     Duration::from_millis(100),
-        // );
-
         let line_ending = settings.last_port_settings.rx_line_ending.as_bytes();
         let buffer = Buffer::new(
             line_ending,
diff --git a/src/buffer/buf_line.rs b/src/buffer/buf_line.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 
+use bstr::ByteSlice;
 use chrono::{DateTime, Local};
 use compact_str::{CompactString, ToCompactString, format_compact};
 use ratatui::{
@@ -11,6 +12,7 @@ use ratatui_macros::{line, span};
 use tracing::debug;
 
 use crate::{
+    buffer::LineEnding,
     settings::Rendering,
     traits::{ByteSuffixCheck, FirstChars, LineHelpers},
 };
@@ -60,7 +62,9 @@ pub struct BufLine {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) enum LineType {
-    Port,
+    Port {
+        escaped_line_ending: Option<CompactString>,
+    },
     User {
         is_bytes: bool,
         is_macro: bool,
@@ -92,6 +96,7 @@ impl BufLine {
         raw_buffer_index: usize,
         area_width: u16,
         rendering: &Rendering,
+        line_ending: &LineEnding,
         now: DateTime<Local>,
         line_type: LineType,
     ) -> Self {
@@ -115,20 +120,42 @@ impl BufLine {
             rendered_line_height: 0,
             line_type,
         };
+        bufline.populate_line_ending(raw_value, line_ending);
         bufline.update_line_height(area_width, rendering);
         bufline
     }
+    pub fn populate_line_ending(&mut self, full_line_slice: &[u8], line_ending: &LineEnding) {
+        match &mut self.line_type {
+            LineType::Port {
+                escaped_line_ending,
+            } => {
+                if escaped_line_ending.is_some() {
+                    unreachable!();
+                }
+                if full_line_slice.has_line_ending(line_ending) {
+                    _ = escaped_line_ending
+                        .insert(line_ending.as_bytes().escape_bytes().to_compact_string());
+                }
+            }
+            // TODO?
+            LineType::User { .. } => (),
+        }
+    }
     pub fn update_line(
         &mut self,
         line: Line<'static>,
         full_line_slice: &[u8],
         area_width: u16,
         rendering: &Rendering,
+        line_ending: &LineEnding,
     ) {
         self.index_info = make_index_info(full_line_slice, self.raw_buffer_index, &self.line_type);
 
         self.value = line;
         self.value.remove_unsavory_chars();
+
+        self.populate_line_ending(full_line_slice, line_ending);
+
         self.update_line_height(area_width, rendering);
     }
 
@@ -150,21 +177,36 @@ impl BufLine {
     pub fn as_line(&self, rendering: &Rendering) -> Line {
         let borrowed_spans = self.value.borrowed_spans_iter();
 
-        let indices_span_iter = std::iter::once(Span::styled(
+        let indices_and_len = std::iter::once(Span::styled(
             Cow::Borrowed(self.index_info.as_ref()),
             Style::new().dark_gray(),
         ))
         .filter(|_| rendering.show_indices);
 
-        let spans = std::iter::once(Span::styled(
+        let timestamp = std::iter::once(Span::styled(
             Cow::Borrowed(self.timestamp_str.as_ref()),
             Style::new().dark_gray(),
         ))
         .filter(|_| rendering.timestamps);
 
-        let spans = spans.chain(indices_span_iter);
-
-        let spans = spans.chain(borrowed_spans);
+        let line_ending = std::iter::once(&self.line_type).filter_map(|lt| match lt {
+            _ if !rendering.show_line_ending => None,
+            LineType::Port {
+                escaped_line_ending: Some(line_ending),
+            } => Some(Span::styled(
+                Cow::Borrowed(line_ending.as_str()),
+                Style::new().dark_gray(),
+            )),
+            LineType::Port {
+                escaped_line_ending: None,
+            } => None,
+            LineType::User { .. } => None,
+        });
+
+        let spans = timestamp
+            .chain(indices_and_len)
+            .chain(borrowed_spans)
+            .chain(line_ending);
 
         Line::from_iter(spans)
     }
diff --git a/src/buffer/mod.rs b/src/buffer/mod.rs
@@ -366,6 +366,7 @@ impl Buffer {
             self.raw.inner.len(), // .max(1)
             self.last_terminal_size.width,
             &self.rendering,
+            &self.line_ending,
             now,
             LineType::User {
                 is_bytes: true,
@@ -438,6 +439,7 @@ impl Buffer {
                 self.raw.inner.len(), // .max(1)
                 self.last_terminal_size.width,
                 &self.rendering,
+                &self.line_ending,
                 now,
                 LineType::User {
                     is_bytes: false,
@@ -484,6 +486,8 @@ impl Buffer {
             return;
         }
 
+        let this_rx_completed = self.raw.inner.has_line_ending(&self.line_ending);
+
         if append_to_last {
             let last_line = self
                 .styled_lines
@@ -492,18 +496,19 @@ impl Buffer {
                 .expect("can't append to nothing");
             let last_index = last_line.index_in_buffer();
 
-            let slice = &self.raw.inner[last_index..start_index + trunc.len()];
+            let trunc = &self.raw.inner[last_index..start_index + trunc.len()];
+            let orig = &self.raw.inner[last_index..start_index + orig.len()];
             // info!("AAAFG: {:?}", slice);
             let lossy_flavor = if self.rendering.escape_invalid_bytes {
                 LossyFlavor::escaped_bytes_styled(Style::new().dark_gray())
             } else {
                 LossyFlavor::replacement_char()
             };
-            let mut line = match slice.into_line_lossy(Style::new(), lossy_flavor) {
+            let mut line = match trunc.into_line_lossy(Style::new(), lossy_flavor) {
                 Ok(line) => line,
                 Err(_) => {
                     error!("ansi-to-tui failed to parse input! Using unstyled text.");
-                    Line::from(String::from_utf8_lossy(slice).to_string())
+                    Line::from(String::from_utf8_lossy(trunc).to_string())
                 }
             };
             // debug!(
@@ -520,10 +525,16 @@ impl Buffer {
             //     line.style_slice(1..3, Style::new().red().italic());
             // }
 
-            let line_opt = self.color_rules.apply_onto(slice, line);
+            let line_opt = self.color_rules.apply_onto(trunc, line);
 
             if let Some(line) = line_opt {
-                last_line.update_line(line, slice, self.last_terminal_size.width, &self.rendering);
+                last_line.update_line(
+                    line,
+                    orig,
+                    self.last_terminal_size.width,
+                    &self.rendering,
+                    &self.line_ending,
+                );
             } else {
                 _ = self.styled_lines.rx.pop();
                 self.styled_lines.last_rx_completed = true;
@@ -545,39 +556,23 @@ impl Buffer {
 
             let line_opt = self.color_rules.apply_onto(trunc, line);
 
-            // if line.width() >= 5 {
-            //     line.style_slice(1..3, Style::new().red().italic());
-            // }
-
-            // if !line.is_styled() {
-            //     assert!(line.spans.len() <= 1);
-            // }
-
-            // debug!(
-            //     "buf_index: {start_index}, new: {line}",
-            //     line = line
-            //         .spans
-            //         .iter()
-            //         .map(|s| s.content.as_ref())
-            //         .join("")
-            //         .escape_default()
-            // );
-
-            // let line = line_opt.unwrap_or_default();
             if let Some(line) = line_opt {
                 self.styled_lines.rx.push(BufLine::new_with_line(
                     line,
                     orig,
                     start_index,
                     self.last_terminal_size.width,
                     &self.rendering,
+                    &self.line_ending,
                     known_time.unwrap_or_else(Local::now),
-                    LineType::Port,
+                    LineType::Port {
+                        escaped_line_ending: None,
+                    },
                 ));
             }
         };
-        let last_rx_completed = self.raw.inner.has_line_ending(&self.line_ending);
-        self.styled_lines.last_rx_completed = last_rx_completed;
+
+        self.styled_lines.last_rx_completed = this_rx_completed;
     }
 
     // Forced to use Vec<u8> for now
@@ -737,8 +732,9 @@ impl Buffer {
         let should_reconsume =
             changed!(old, new, echo_user_input) || changed!(old, new, escape_invalid_bytes);
 
-        let should_rewrap_lines =
-            changed!(old, new, timestamps) || changed!(old, new, show_indices);
+        let should_rewrap_lines = changed!(old, new, timestamps)
+            || changed!(old, new, show_indices)
+            || changed!(old, new, show_line_ending);
 
         if changed!(old, new, bytes_per_line) {
             self.determine_bytes_per_line(new.bytes_per_line.into());
diff --git a/src/cli.rs b/src/cli.rs
@@ -11,3 +11,5 @@
 // - or instead, show an error and drop on port selection screen, but an --option can skip that and just close?
 // - both should skip scanning for serial ports and try to directly connect to the given port
 // - maybe also allow USB PID+VID as an "address"? would prefer to accept same formats as usb ignore configs
+
+// option to print out all possible AppActions then exit?
diff --git a/src/main.rs b/src/main.rs
@@ -1,3 +1,10 @@
 fn main() -> color_eyre::Result<()> {
     yap::run()
 }
+
+// TODO defmt support
+// TODO mouse select in line mode?
+
+// Far future TODOs:
+// TODO Forwarding + Loopback support
+// TODO TCP Socket support
diff --git a/src/settings/mod.rs b/src/settings/mod.rs
@@ -106,6 +106,10 @@ pub struct Rendering {
     /// Wrap text longer than the screen.
     pub wrap_text: bool,
 
+    #[serde(default)]
+    /// Show line ending at end of recieved lines.
+    pub show_line_ending: bool,
+
     #[serde(default)]
     /// Show invalid byte sequences in \xFF notation.
     pub escape_invalid_bytes: bool,
