cargo format

Author: joelsa

src/config.rs

@@ -1,9 +1,6 @@
 use clap::ValueEnum;
-use std::sync::{
-    Arc, Mutex as StdMutex,
-    atomic::AtomicBool,
-};
 use std::io::BufWriter;
+use std::sync::{Arc, Mutex as StdMutex, atomic::AtomicBool};
 
 /// Which line ending to send when you press Enter
 #[derive(Copy, Clone, Debug, ValueEnum)]
@@ -27,7 +24,7 @@ impl LineEnding {
             LineEnding::Crlf => "CRLF (\\r\\n)",
         }
     }
-    
+
     pub fn bytes(self) -> &'static [u8] {
         match self {
             LineEnding::None => b"",
@@ -43,4 +40,4 @@ pub struct UiConfig {
     pub line_ending: LineEnding,
     pub tx_log: Option<Arc<StdMutex<BufWriter<std::fs::File>>>>,
     pub log_ts: bool,
-}
+}

src/logging.rs

@@ -12,7 +12,7 @@ pub fn create_log_writer(path: &PathBuf, log_type: &str) -> Result<LogWriter> {
         .append(true)
         .open(path)
         .with_context(|| format!("Failed to open {} log file: {}", log_type, path.display()))?;
-    
+
     println!("Logging {} to: {}", log_type, path.display());
     Ok(Arc::new(Mutex::new(BufWriter::new(file))))
 }
@@ -29,4 +29,4 @@ pub fn create_tx_log_writer(path: Option<&PathBuf>) -> Result<Option<LogWriter>>
         Some(path) => Ok(Some(create_log_writer(path, "TX")?)),
         None => Ok(None),
     }
-}
+}

src/main.rs

@@ -10,7 +10,7 @@ use config::{LineEnding, UiConfig};
 use crossterm::terminal;
 use logging::{create_rx_log_writer, create_tx_log_writer};
 use port_discovery::{choose_port_interactive, get_available_ports, print_ports};
-use ratatui::{backend::CrosstermBackend, Terminal};
+use ratatui::{Terminal, backend::CrosstermBackend};
 use serial_io::{SerialData, SerialReader};
 use serialport::SerialPort;
 use std::io::Read;
@@ -20,8 +20,8 @@ use std::sync::{
     atomic::{AtomicBool, Ordering},
 };
 use std::time::Duration;
-use tokio::sync::{mpsc, Mutex};
-use ui::{run_ui, UiMessage};
+use tokio::sync::{Mutex, mpsc};
+use ui::{UiMessage, run_ui};
 
 /// sermonizer — a tiny, friendly serial monitor
 #[derive(Parser, Debug)]
@@ -199,4 +199,4 @@ async fn main() -> Result<()> {
 
     println!("\nDisconnected. Bye!");
     Ok(())
-}
+}

src/port_discovery.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use serialport::{SerialPortInfo, SerialPortType};
 use std::io::{self, Write};
 
@@ -77,4 +77,4 @@ pub fn choose_port_interactive(ports: &[SerialPortInfo]) -> Result<String> {
             Ok(name)
         }
     }
-}
+}

src/serial_io.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
+use chrono::Utc;
 use serialport::SerialPort;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
-use tokio::sync::{mpsc, Mutex};
-use chrono::Utc;
+use tokio::sync::{Mutex, mpsc};
 
 #[derive(Debug, Clone)]
 pub enum SerialData {
@@ -82,34 +82,34 @@ impl SerialReader {
     fn format_hex_data(&mut self, bytes: &[u8]) -> String {
         let capacity = if self.log_ts { 32 } else { 0 } + bytes.len() * 3; // Estimate capacity
         let mut hex_str = String::with_capacity(capacity);
-        
+
         if self.log_ts {
             hex_str.push_str("[");
             hex_str.push_str(&Utc::now().format("%Y-%m-%d %H:%M:%S%.3f").to_string());
             hex_str.push_str("] ");
         }
-        
+
         // Optimize hex formatting with pre-allocated string
         for (i, b) in bytes.iter().enumerate() {
             if i > 0 {
                 hex_str.push(' ');
             }
             hex_str.push_str(&format!("{:02X}", b));
         }
-        
+
         hex_str
     }
 
     fn format_text_data(&mut self, bytes: &[u8]) -> String {
         let capacity = if self.log_ts { 32 } else { 0 } + bytes.len();
         let mut text = String::with_capacity(capacity);
-        
+
         if self.log_ts {
             text.push_str("[");
             text.push_str(&Utc::now().format("%Y-%m-%d %H:%M:%S%.3f").to_string());
             text.push_str("] ");
         }
-        
+
         // Use from_utf8_lossy but avoid extra allocations where possible
         text.push_str(&String::from_utf8_lossy(bytes));
         text
@@ -119,11 +119,11 @@ impl SerialReader {
         if let Some(w) = &self.rx_log_writer {
             if let Ok(mut lw) = w.lock() {
                 use std::io::Write;
-                
+
                 if self.log_ts {
                     let _ = write!(lw, "[{}] ", Utc::now().format("%Y-%m-%d %H:%M:%S%.3f"));
                 }
-                
+
                 if self.hex_mode {
                     for (i, b) in bytes.iter().enumerate() {
                         let separator = if i + 1 == bytes.len() { "" } else { " " };
@@ -133,7 +133,7 @@ impl SerialReader {
                 } else {
                     let _ = lw.write_all(bytes);
                 }
-                
+
                 let _ = lw.flush();
             }
         }
@@ -148,4 +148,4 @@ pub async fn write_bytes_async(
     guard.write_all(bytes)?;
     guard.flush()?;
     Ok(())
-}
+}

src/ui/app_state.rs

@@ -55,7 +55,7 @@ impl AppState {
                 self.auto_scroll_state
                     .select(Some(self.output_lines.len() - 1));
             }
-            
+
             self.needs_render = true;
         }
     }
@@ -167,4 +167,4 @@ impl AppState {
     pub fn mark_rendered(&mut self) {
         self.needs_render = false;
     }
-}
+}

src/ui/mod.rs

@@ -5,17 +5,15 @@ pub use app_state::AppState;
 pub use rendering::draw_ui;
 
 use anyhow::Result;
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
-};
-use ratatui::{backend::Backend, Terminal};
-use std::sync::atomic::Ordering;
+use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
+use ratatui::{Terminal, backend::Backend};
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 use tokio::sync::mpsc;
 
 use crate::config::UiConfig;
-use crate::serial_io::{write_bytes_async, SerialData};
+use crate::serial_io::{SerialData, write_bytes_async};
 use chrono::Utc;
 
 #[derive(Debug)]
@@ -92,7 +90,9 @@ async fn handle_key_event(
     ui_config: &UiConfig,
 ) -> Result<()> {
     match key.code {
-        KeyCode::Char(c) if key.modifiers.contains(KeyModifiers::CONTROL) && (c == 'c' || c == 'd') => {
+        KeyCode::Char(c)
+            if key.modifiers.contains(KeyModifiers::CONTROL) && (c == 'c' || c == 'd') =>
+        {
             app_state.quit();
         }
         KeyCode::Esc => {
@@ -173,4 +173,4 @@ async fn handle_enter_key(
     }
 
     Ok(())
-}
+}

src/ui/rendering.rs

@@ -1,10 +1,10 @@
+use super::app_state::AppState;
 use ratatui::{
     Frame,
     layout::{Constraint, Direction, Layout},
     style::{Color, Style},
     widgets::{Block, Borders, List, ListItem, Paragraph},
 };
-use super::app_state::AppState;
 
 pub fn draw_ui(f: &mut Frame, app_state: &mut AppState) {
     let chunks = Layout::default()
@@ -58,4 +58,4 @@ pub fn draw_ui(f: &mut Frame, app_state: &mut AppState) {
         chunks[1].x + app_state.input_line.len() as u16 + 1,
         chunks[1].y + 1,
     ));
-}
+}