fix: centralize ansi styling helpers

Author: gregce

crates/deadreckon/src/lib.rs

@@ -1,3 +1,6 @@
 pub mod cards;
 pub mod sleep;
 pub mod ui_card;
+
+#[allow(dead_code)]
+mod ui;

crates/deadreckon/src/main.rs

@@ -22035,8 +22035,9 @@ mod tui_tests {
     #[test]
     fn chain_attach_plain_emits_periodic_snapshot_no_ansi() {
         let snapshot = chain_attach_header_text(&chain_fixture());
+        let ansi_start = format!("{}[", char::from(27));
 
-        assert!(!snapshot.contains("\u{1b}["), "{snapshot}");
+        assert!(!snapshot.contains(&ansi_start), "{snapshot}");
         assert!(snapshot.contains("policy branch=stack"), "{snapshot}");
     }
 

crates/deadreckon/src/ui.rs

@@ -1,9 +1,13 @@
 use std::io::{self, IsTerminal, Write as _};
+use std::iter::Peekable;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use ratatui::style::Color;
 
 static PLAIN_OUTPUT: AtomicBool = AtomicBool::new(false);
+#[allow(dead_code)]
+const ANSI_ESC: char = '\u{1b}';
+const ANSI_RESET: &str = "\x1b[0m";
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum Stream {
@@ -87,12 +91,56 @@ pub(crate) fn render(stream: Stream, tone: Tone, text: impl AsRef<str>) -> Strin
         return text.to_string();
     };
     if enabled(stream) {
-        format!("\x1b[{code}m{text}\x1b[0m")
+        ansi_wrap(code, text)
     } else {
         text.to_string()
     }
 }
 
+pub(crate) fn ansi_wrap(code: &str, text: &str) -> String {
+    format!("\x1b[{code}m{text}{ANSI_RESET}")
+}
+
+#[allow(dead_code)]
+pub(crate) fn ansi_reset() -> &'static str {
+    ANSI_RESET
+}
+
+#[allow(dead_code)]
+pub(crate) fn strip_ansi(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut chars = text.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if read_ansi_sequence(ch, &mut chars).is_some() {
+            continue;
+        }
+        out.push(ch);
+    }
+    out
+}
+
+#[allow(dead_code)]
+pub(crate) fn read_ansi_sequence<I>(first: char, chars: &mut Peekable<I>) -> Option<(String, bool)>
+where
+    I: Iterator<Item = char>,
+{
+    if first != ANSI_ESC || chars.peek() != Some(&'[') {
+        return None;
+    }
+    let mut sequence = String::from(first);
+    if let Some(bracket) = chars.next() {
+        sequence.push(bracket);
+    }
+    for code in chars.by_ref() {
+        sequence.push(code);
+        if code.is_ascii_alphabetic() {
+            let active = sequence != ANSI_RESET;
+            return Some((sequence, active));
+        }
+    }
+    Some((sequence, false))
+}
+
 pub(crate) fn status_tone(status: impl AsRef<str>) -> Tone {
     match status.as_ref().trim().to_ascii_lowercase().as_str() {
         "ok" | "ready" | "set" | "wrote" | "updated" | "installed" | "completed" | "passed"

crates/deadreckon/src/ui_card.rs

@@ -123,21 +123,7 @@ pub fn pad_visible(text: &str, width: usize) -> String {
 }
 
 pub fn strip_ansi(text: &str) -> String {
-    let mut out = String::with_capacity(text.len());
-    let mut chars = text.chars().peekable();
-    while let Some(ch) = chars.next() {
-        if ch == '\u{1b}' && chars.peek() == Some(&'[') {
-            chars.next();
-            for code in chars.by_ref() {
-                if code.is_ascii_alphabetic() {
-                    break;
-                }
-            }
-            continue;
-        }
-        out.push(ch);
-    }
-    out
+    crate::ui::strip_ansi(text)
 }
 
 fn body_lines(card: &Card, plain: bool, color: bool) -> Vec<String> {
@@ -256,15 +242,15 @@ fn border(position: &str, width: usize, plain: bool, color: bool) -> String {
 
 fn style_border(text: &str, color: bool) -> String {
     if color {
-        format!("\u{1b}[2m{text}\u{1b}[0m")
+        crate::ui::ansi_wrap("2", text)
     } else {
         text.to_string()
     }
 }
 
 fn style_title(text: &str, color: bool) -> String {
     if color {
-        format!("\u{1b}[1m{text}\u{1b}[0m")
+        crate::ui::ansi_wrap("1", text)
     } else {
         text.to_string()
     }
@@ -281,7 +267,7 @@ fn style_tone(text: &str, tone: Tone, color: bool) -> String {
         Tone::Bad => "31",
         Tone::Dim => "2",
     };
-    format!("\u{1b}[{code}m{text}\u{1b}[0m")
+    crate::ui::ansi_wrap(code, text)
 }
 
 fn truncate_visible_for_mode(text: &str, width: usize, plain: bool) -> String {
@@ -310,18 +296,8 @@ fn truncate_visible_inner(text: &str, width: usize, ellipsis: &str) -> String {
     let mut active_style = false;
     let mut chars = text.chars().peekable();
     while let Some(ch) = chars.next() {
-        if ch == '\u{1b}' && chars.peek() == Some(&'[') {
-            let mut sequence = String::from(ch);
-            if let Some(bracket) = chars.next() {
-                sequence.push(bracket);
-            }
-            for code in chars.by_ref() {
-                sequence.push(code);
-                if code.is_ascii_alphabetic() {
-                    active_style = sequence != "\u{1b}[0m";
-                    break;
-                }
-            }
+        if let Some((sequence, active)) = crate::ui::read_ansi_sequence(ch, &mut chars) {
+            active_style = active;
             out.push_str(&sequence);
             continue;
         }
@@ -333,7 +309,7 @@ fn truncate_visible_inner(text: &str, width: usize, ellipsis: &str) -> String {
     }
     out.push_str(ellipsis);
     if active_style {
-        out.push_str("\u{1b}[0m");
+        out.push_str(crate::ui::ansi_reset());
     }
     out
 }

crates/deadreckon/tests/coherence.rs

@@ -23,14 +23,22 @@ fn runstatus_executing_renders_running_through_glossary() {
 #[test]
 fn raw_ansi_escapes_stay_in_ui_module() {
     let manifest = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    let main = fs::read_to_string(manifest.join("src/main.rs")).expect("main");
-    assert!(!main.contains("\\x1b["), "main.rs contains raw ANSI");
-    let ui = fs::read_to_string(manifest.join("src/ui.rs")).expect("ui");
-    let ui_card = fs::read_to_string(manifest.join("src/ui_card.rs")).expect("ui_card");
-    assert!(
-        ui.contains("\\x1b[") || ui_card.contains("\\u{1b}["),
-        "ui modules own ANSI rendering"
-    );
+    for entry in fs::read_dir(manifest.join("src")).expect("src dir") {
+        let path = entry.expect("entry").path();
+        if path.extension().and_then(|ext| ext.to_str()) != Some("rs") {
+            continue;
+        }
+        let text = fs::read_to_string(&path).expect("source");
+        if path.file_name().and_then(|name| name.to_str()) == Some("ui.rs") {
+            assert!(text.contains("\\x1b["), "ui.rs owns raw ANSI rendering");
+            continue;
+        }
+        assert!(
+            !text.contains("\\x1b[") && !text.contains("\\u{1b}["),
+            "{} contains raw ANSI escape construction",
+            path.display()
+        );
+    }
 }
 
 #[test]