Implementation of simple chat

.gitignore

@@ -12,3 +12,8 @@ Cargo.lock
 
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
+
+
+# Added by cargo
+
+/target

Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "simple-chat"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "chat-svr"
+
+[[bin]]
+name = "chat-clt"
+
+[dependencies]
+anyhow = { version = "1.0.86", default-features = false, features = ["std"] }
+clap = { version = "4.5.8", default-features = false, features = ["std", "derive"] }
+futures = { version = "0.3.30", default-features = false }
+futures-util = { version = "0.3.30", default-features = false, features = ["sink"] }
+tokio = { version = "1.38.0", default-features = false, features = ["full"] }
+tokio-stream = { version = "0.1.15", default-features = false, features = ["net"] }
+tokio-util = { version = "0.7.11", default-features = false, features = ["codec"] }
+ratatui = { version = "0.27.0", default-features = false, features = ["crossterm"] }
+regex = { version = "1.10.5", default-features = false, features = ["unicode-perl"] }
+serde = { version = "1.0.194", default-features = false, features = ["derive"] }
+serde_json = { version = "1.0.120", default-features = false, features = ["std"] }
+tui-input = { version = "0.9.0", default-features = false, features = ["crossterm"] }
+
+[workspace.lints.clippy]
+wildcard_imports = "deny"

src/bin/chat-clt.rs

@@ -0,0 +1,227 @@
+use std::io::{stdout, Stdout};
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use ratatui::{
+    backend::CrosstermBackend,
+    crossterm::{
+        event::{self, KeyCode},
+        execute,
+        terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+    },
+    prelude::{Constraint, Layout},
+    style::{Style, Stylize},
+    symbols::border,
+    text::{Line, Span, Text},
+    widgets::{Block, List, ListItem, Paragraph},
+    Frame, Terminal,
+};
+use regex::Regex;
+use tui_input::{backend::crossterm::EventHandler, Input};
+
+use simple_chat::{
+    client::{Connection, Messages},
+    ClientMessage,
+};
+
+static REGEX: std::sync::OnceLock<Regex> = std::sync::OnceLock::new();
+
+type Tui = Terminal<CrosstermBackend<Stdout>>;
+
+enum ClientCommand<A> {
+    Connect(String, A),
+    Send(String),
+    Leave,
+}
+
+impl core::str::FromStr for ClientCommand<String> {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let input_re = REGEX.get_or_init(|| {
+            Regex::new(
+                r#"(?x)
+                ^(leave)\s*$ |
+                ^(connect)\s+(.*)@(.*)$ |
+                ^(send)\s+(.*)
+                "#,
+            )
+            .unwrap()
+        });
+
+        let captures = input_re.captures(s).map(|captures| {
+            captures
+                .iter()
+                .skip(1)
+                .flatten()
+                .map(|c| c.as_str())
+                .collect::<Vec<_>>()
+        });
+
+        let ret = match captures.as_deref() {
+            Some(["leave"]) => Ok(Self::Leave),
+            Some(["connect", nick, addr]) => Ok(Self::Connect(nick.to_string(), addr.to_string())),
+            Some(["send", message]) => Ok(Self::Send(message.to_string())),
+            _ => {
+                anyhow::bail!("invalid command")
+            }
+        };
+
+        ret
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct App {
+    input: Input,
+    messages: Arc<Messages>,
+    connection: Option<Connection>,
+    exit: bool,
+}
+
+impl App {
+    fn run(&mut self, terminal: &mut Tui) -> Result<()> {
+        while !self.exit {
+            terminal.draw(|frame| ui(frame, self))?;
+            if event::poll(std::time::Duration::from_millis(16))? {
+                self.handle_events()?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn handle_events(&mut self) -> Result<()> {
+        if let event::Event::Key(key) = event::read()? {
+            match key.code {
+                KeyCode::Enter => {
+                    let input = self.input.value().to_string();
+                    match input.parse::<ClientCommand<String>>() {
+                        Ok(ClientCommand::Leave) => self.exit(),
+                        Ok(ClientCommand::Connect(nick, addr)) => {
+                            if self.connection.is_none() {
+                                self.messages
+                                    .push("INFO", &format!("Connecting to {addr} as {nick}"));
+                                match Connection::connect(&nick, addr, self.messages.clone()) {
+                                    Ok(connection) => self.connection = Some(connection),
+                                    Err(e) => {
+                                        let err = format!("Failed to connect to server: {e}");
+                                        self.messages.push("ERROR", &err);
+                                    }
+                                }
+                            } else {
+                                self.messages.push("ERROR", "Already connected to server");
+                            }
+                        }
+                        Ok(ClientCommand::Send(message)) => {
+                            if let Some(connection) = &mut self.connection {
+                                self.messages.push(&connection.nick, &message);
+                                if let Err(e) = connection.send(ClientMessage::SendMsg(message)) {
+                                    let err = format!("Failed to send message: {e}");
+                                    self.messages.push("ERROR", &err);
+                                }
+                            } else {
+                                self.messages.push("ERROR", "Not connected to a server");
+                            }
+                        }
+                        _ => {
+                            self.messages.push("ERROR", "Invalid command");
+                        }
+                    }
+                    self.input.reset();
+                }
+                _ => {
+                    self.input.handle_event(&event::Event::Key(key));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn exit(&mut self) {
+        self.exit = true;
+        if let Some(connection) = &mut self.connection {
+            connection
+                .send(ClientMessage::Leave)
+                .or_else(|e| {
+                    eprintln!("Failed to send disconnect message: {e:?}");
+                    anyhow::Ok(())
+                })
+                .context("should always return Ok")
+                .unwrap();
+        }
+    }
+}
+
+fn ui(f: &mut Frame, app: &App) {
+    let vertical = Layout::vertical([
+        Constraint::Min(1),
+        Constraint::Length(3),
+        Constraint::Length(1),
+    ]);
+    let [message_area, input_area, help_area] = vertical.areas(f.size());
+
+    let header = Text::from(Line::from(vec![
+        "Type ".into(),
+        "connect <nick>@<ip>:<port>".bold().green(),
+        " to connect to a server, type ".into(),
+        "leave".bold().red(),
+        " to exit.".into(),
+    ]))
+    .patch_style(Style::default());
+    let help_message = Paragraph::new(header);
+    f.render_widget(help_message, help_area);
+
+    let width = input_area.width.max(3) - 3;
+    let scroll = app.input.visual_scroll(width as usize);
+    let input_block = Block::bordered().title(" Input ").border_set(border::THICK);
+    let input = Paragraph::new(app.input.value())
+        .scroll((0, scroll as u16))
+        .block(input_block);
+    f.render_widget(input, input_area);
+
+    f.set_cursor(
+        input_area.x + ((app.input.visual_cursor()).max(scroll) - scroll) as u16 + 1,
+        input_area.y + 1,
+    );
+
+    let message_block = Block::bordered()
+        .title(" Messages ")
+        .border_set(border::THICK);
+    let messages: Vec<ListItem> = app
+        .messages
+        .get()
+        .iter()
+        .map(|(n, m)| {
+            let content = vec![Line::from(Span::raw(format!("{n}: {m}")))];
+            ListItem::new(content)
+        })
+        .collect();
+    let messages = List::new(messages).block(message_block);
+    f.render_widget(messages, message_area);
+}
+
+fn main() -> Result<()> {
+    let mut terminal = init()?;
+    terminal.clear()?;
+
+    let mut app = App::default();
+    let res = app.run(&mut terminal);
+
+    restore()?;
+
+    res
+}
+
+fn init() -> Result<Tui> {
+    execute!(stdout(), EnterAlternateScreen)?;
+    enable_raw_mode()?;
+    Terminal::new(CrosstermBackend::new(stdout())).map_err(anyhow::Error::from)
+}
+
+fn restore() -> Result<()> {
+    execute!(stdout(), LeaveAlternateScreen)?;
+    disable_raw_mode()?;
+    Ok(())
+}

src/bin/chat-svr.rs

@@ -0,0 +1,22 @@
+use anyhow::Result;
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct Cli {
+    /// Set the server port to listen on. Defaults to `8080`.
+    #[arg(short)]
+    port: Option<usize>,
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let cli = Cli::parse();
+    let port = if let Some(port) = cli.port {
+        port
+    } else {
+        8080
+    };
+    let addr = format!("127.0.0.1:{port}");
+    simple_chat::server::run(addr).await
+}