refactor: many new modules

Author: massivebird

src/app/config.rs

@@ -0,0 +1,25 @@
+use super::connection::Connection;
+use serde::Deserialize;
+use std::{io::Read, path::PathBuf};
+
+#[derive(Clone, Debug, Deserialize)]
+struct ConfigFile {
+    connection: Vec<Connection>,
+}
+
+pub fn read_config() -> Vec<Connection> {
+    let home = std::env::var("HOME").unwrap();
+
+    // Full path to the toml config file.
+    let toml_path = PathBuf::from(format!("{home}/.config/lanturn/config.toml"));
+
+    let mut f = std::fs::File::open(&toml_path).unwrap();
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf)
+        .expect("Failed to read contents of TOML config file.");
+
+    let c: ConfigFile = toml::from_str(&buf).unwrap();
+
+    c.connection
+}

src/app/connection/conn_type.rs

@@ -0,0 +1,15 @@
+use serde::Deserialize;
+
+#[derive(Clone, Debug, Deserialize)]
+pub enum ConnectionType {
+    Remote { url: String },
+    Local { ip: std::net::IpAddr },
+}
+
+impl Default for ConnectionType {
+    fn default() -> Self {
+        Self::Local {
+            ip: std::net::Ipv4Addr::LOCALHOST.into(),
+        }
+    }
+}

src/app/connection.rs src/app/connection/mod.rssrc/app/connection.rs renamed to src/app/connection/mod.rs

@@ -1,9 +1,12 @@
 use serde::{Deserialize, Deserializer};
-use std::borrow::Cow;
-use std::collections::VecDeque;
+use std::{borrow::Cow, collections::VecDeque};
 
 pub const MAX_STATUSES: usize = 50;
 
+mod conn_type;
+
+pub use conn_type::ConnectionType;
+
 #[derive(Clone, Debug, Deserialize)]
 pub struct Connection {
     pub name: String,
@@ -16,36 +19,8 @@ pub struct Connection {
     log: VecDeque<Result<u16, ()>>,
 }
 
-pub(super) fn deserialize_conn<'de, D>(deserializer: D) -> Result<ConnectionType, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let buf = Cow::<'de, str>::deserialize(deserializer)?;
-
-    Ok(buf.parse().map_or_else(
-        |_| ConnectionType::Web {
-            url: buf.to_string(),
-        },
-        |ip| ConnectionType::Local { ip },
-    ))
-}
-
-#[derive(Clone, Debug, Deserialize)]
-pub enum ConnectionType {
-    Web { url: String },
-    Local { ip: std::net::IpAddr },
-}
-
-impl Default for ConnectionType {
-    fn default() -> Self {
-        Self::Local {
-            ip: std::net::Ipv4Addr::LOCALHOST.into(),
-        }
-    }
-}
-
 impl Connection {
-    pub fn push_status_code(&mut self, code: Result<u16, ()>) {
+    pub fn push_status(&mut self, code: Result<u16, ()>) {
         if self.log.len() == MAX_STATUSES {
             self.log.pop_back();
         }
@@ -57,10 +32,25 @@ impl Connection {
         &self.log
     }
 
+    /// Returns the effective address.
     pub fn addr(&self) -> Cow<'_, str> {
         match &self.conn_type {
-            ConnectionType::Web { url } => Cow::Borrowed(url),
+            ConnectionType::Remote { url } => Cow::Borrowed(url),
             ConnectionType::Local { ip } => Cow::Owned(ip.to_string()),
         }
     }
 }
+
+fn deserialize_conn<'de, D>(deserializer: D) -> Result<ConnectionType, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let buf = Cow::<'de, str>::deserialize(deserializer)?;
+
+    Ok(buf.parse().map_or_else(
+        |_| ConnectionType::Remote {
+            url: buf.to_string(),
+        },
+        |ip| ConnectionType::Local { ip },
+    ))
+}

src/app/mod.rs

@@ -1,14 +1,10 @@
 use self::{
     cli::generate_matches, connection::Connection, output_fmt::OutputFmt, selected_tab::SelectedTab,
 };
-use serde::Deserialize;
-use std::{
-    io::Read,
-    path::PathBuf,
-    sync::{Arc, Mutex},
-};
+use std::sync::{Arc, Mutex};
 
 pub mod cli;
+mod config;
 pub mod connection;
 pub mod output_fmt;
 pub mod selected_tab;
@@ -22,16 +18,11 @@ pub struct App {
     is_closing: bool,
 }
 
-#[derive(Clone, Debug, Deserialize)]
-struct ConfigFile {
-    connection: Vec<Connection>,
-}
-
 impl App {
     pub fn generate() -> Self {
         let matches: clap::ArgMatches = generate_matches();
 
-        let conns = Self::read_config();
+        let conns = config::read_config();
 
         let output_fmt = match matches.get_one::<OutputFmt>("output_fmt") {
             Some(&fmt) => fmt,
@@ -45,23 +36,6 @@ impl App {
         }
     }
 
-    fn read_config() -> Vec<Connection> {
-        let home = std::env::var("HOME").unwrap();
-
-        // Full path to the toml config file.
-        let toml_path = PathBuf::from(format!("{home}/.config/lanturn/config.toml"));
-
-        let mut f = std::fs::File::open(&toml_path).unwrap();
-
-        let mut buf = String::new();
-        f.read_to_string(&mut buf)
-            .expect("Failed to read contents of TOML config file.");
-
-        let c: ConfigFile = toml::from_str(&buf).unwrap();
-
-        c.connection
-    }
-
     pub fn next_tab(&mut self) {
         self.selected_tab = self.selected_tab.next();
     }

src/app/output_fmt.rs

@@ -1,5 +1,4 @@
-use clap::builder::PossibleValue;
-use clap::ValueEnum;
+use clap::{ValueEnum, builder::PossibleValue};
 
 #[derive(Default, Copy, Clone)]
 pub enum OutputFmt {
@@ -8,6 +7,7 @@ pub enum OutputFmt {
     Bullet,
 }
 
+// Define CLI controls.
 impl ValueEnum for OutputFmt {
     fn value_variants<'a>() -> &'a [Self] {
         &[Self::Bullet, Self::Line]

src/main.rs

@@ -38,9 +38,10 @@ fn main() -> io::Result<()> {
     // Create app and run it.
     let ui_refresh_rate = Duration::from_millis(200);
 
-    let res = commence_application(&mut terminal, ui_refresh_rate, &mut app);
+    let res = start_app(&mut terminal, ui_refresh_rate, &mut app);
 
-    // Restore terminal.
+    // App is quitting!
+    // Restore terminal and environment to normal.
     disable_raw_mode()?;
     execute!(
         terminal.backend_mut(),
@@ -56,7 +57,7 @@ fn main() -> io::Result<()> {
     Ok(())
 }
 
-fn commence_application<B: Backend>(
+fn start_app<B: Backend>(
     terminal: &mut Terminal<B>,
     ui_refresh_rate: Duration,
     app: &mut App,
@@ -100,6 +101,7 @@ fn commence_application<B: Backend>(
     }
 }
 
+/// Handles user input.
 fn handle_events(app: &mut App) -> io::Result<()> {
     if let Event::Key(key) = event::read()? {
         match key.code {
@@ -123,7 +125,7 @@ fn test_conn(conns: &Arc<Mutex<Vec<Connection>>>, idx: usize) {
     let conn_type = conns.lock().unwrap().get(idx).unwrap().conn_type.clone();
 
     let code = match conn_type {
-        ConnectionType::Web { url } => {
+        ConnectionType::Remote { url } => {
             let client = reqwest::blocking::Client::new()
                 .get(url)
                 .timeout(Duration::from_secs(3));
@@ -145,5 +147,5 @@ fn test_conn(conns: &Arc<Mutex<Vec<Connection>>>, idx: usize) {
         .unwrap()
         .get_mut(idx)
         .unwrap()
-        .push_status_code(code);
+        .push_status(code);
 }

src/ui/mod.rs

@@ -0,0 +1,18 @@
+use crate::app::{App, selected_tab::SelectedTab};
+use ratatui::{Frame, layout::Rect, widgets::Tabs};
+use strum::IntoEnumIterator;
+
+mod tab;
+
+pub fn ui(f: &mut Frame, app: &App) {
+    let titles = SelectedTab::iter().map(SelectedTab::title);
+
+    let tabs = Tabs::new(titles).select(app.selected_tab as usize);
+
+    f.render_widget(tabs, Rect::new(0, 0, f.area().width, f.area().height));
+
+    match app.selected_tab {
+        SelectedTab::Live => tab::render_tab_live(f, app),
+        SelectedTab::Log => tab::render_tab_log(f, app),
+    }
+}

src/ui.rs src/ui/tab.rssrc/ui.rs renamed to src/ui/tab.rs

@@ -1,32 +1,13 @@
-use crate::app::{
-    App, connection::ConnectionType, output_fmt::OutputFmt, selected_tab::SelectedTab,
-};
+use crate::app::{App, connection::ConnectionType, output_fmt::OutputFmt};
 use ratatui::{
     Frame,
     layout::Rect,
     style::{Color, Modifier, Style, Stylize},
     text::{Line, Span},
-    widgets::{Block, List, Paragraph, Tabs},
+    widgets::{Block, List, Paragraph},
 };
-use strum::IntoEnumIterator;
-
-pub fn ui(f: &mut Frame, app: &App) {
-    // Render tabs at the top.
-
-    let titles = SelectedTab::iter().map(SelectedTab::title);
-
-    let tabs = Tabs::new(titles).select(app.selected_tab as usize);
-
-    f.render_widget(tabs, Rect::new(0, 0, f.area().width, f.area().height));
-
-    // Render contents of selected tab.
-    match app.selected_tab {
-        SelectedTab::Live => render_tab_live(f, app),
-        SelectedTab::Log => render_tab_log(f, app),
-    }
-}
 
-fn render_tab_live(f: &mut Frame, app: &App) {
+pub fn render_tab_live(f: &mut Frame, app: &App) {
     let mut list_items: Vec<Line<'_>> = Vec::new();
 
     for conn in app.connections.lock().unwrap().iter() {
@@ -39,7 +20,7 @@ fn render_tab_live(f: &mut Frame, app: &App) {
 
         let conn_output: Line<'_> = match app.output_fmt {
             OutputFmt::Bullet => Line::from(vec![
-                Span::from(" ■ ").style(color),
+                Span::from(" 󰝤 ").style(color),
                 Span::from(format!("{} ({})", conn.name, url)),
             ]),
             OutputFmt::Line => Line::from(Span::from(format!(" {} ({})", conn.name, url))).style(
@@ -66,7 +47,7 @@ fn render_tab_live(f: &mut Frame, app: &App) {
     );
 }
 
-fn render_tab_log(f: &mut Frame, app: &App) {
+pub fn render_tab_log(f: &mut Frame, app: &App) {
     let (idx, conn) = app.log_conn();
 
     let block =
@@ -115,7 +96,7 @@ const fn status_to_color(status: Result<u16, ()>, conn_type: &ConnectionType) ->
     };
 
     match conn_type {
-        ConnectionType::Web { .. } => match code {
+        ConnectionType::Remote { .. } => match code {
             200 => Color::Green,
             _ => Color::Yellow,
         },