Client work

Author: nilscc

src/irc/client.rs

@@ -5,53 +5,47 @@ pub mod capabilities;
 mod test;
 
 use buffer::Buffer;
-use web_sys::WebSocket;
-use yew::AttrValue;
+use capabilities::{CapNegotiator, Capability};
 
 use super::parser::Message;
 
-pub trait Socket {
-    type Error;
-
-    fn new(host: &str) -> Result<Self, Self::Error>
-    where
-        Self: Sized;
+#[derive(Debug, PartialEq, Clone)]
+enum ClientState {
+    PreCapLs,
+    CapLs,
+    //CapReq,
 }
 
-impl Socket for WebSocket {
-    type Error = ();
-    fn new(host: &str) -> Result<Self, Error> {
-        match WebSocket::new(host) {
-            Ok(ws) => Ok(ws),
-            Err(_) => Err(()),
-        }
-    }
-}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Error {}
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Client {
-    pub capabilities: Vec<Capability>,
+    state: ClientState,
+    cap_negotiator: CapNegotiator,
     pub buffers: Vec<Buffer>,
 }
 
-// TODO: proper error type
-type Error = ();
-
-///
-type Messages = Vec<Message>;
-
 impl Client {
+    // Supported list of capabilities
+    pub fn supported_capabilities() -> Vec<Capability> {
+        vec![Capability::new("sasl")]
+    }
+
     pub fn new() -> Self {
         Client {
-            capabilities: vec![],
+            state: ClientState::PreCapLs,
+            cap_negotiator: CapNegotiator::request(Self::supported_capabilities()),
             buffers: vec![],
         }
     }
 
-    pub fn request_capabilities(_capabilities: Vec<Capability>) -> Result<Messages, Error> {
-        Ok(vec![Message::cmd("CAP").param("LS").build()])
+    pub fn request_capabilities(&mut self) -> Message {
+        self.state = ClientState::CapLs;
+        self.cap_negotiator.ls(Some("302"))
     }
-}
 
-#[derive(Debug, Clone, PartialEq)]
-pub struct Capability(pub AttrValue);
+    pub fn handle(&mut self, _message: &Message) -> Result<(), Error> {
+        Ok(())
+    }
+}

src/irc/client/capabilities.rs

@@ -5,21 +5,29 @@ use yew::AttrValue;
 /// https://ircv3.net/specs/extensions/capability-negotiation.html
 use crate::irc::parser::{Command, Message, MessageBuilderError};
 
-use super::Capability;
-
 #[cfg(test)]
 mod test;
 
 type Result = std::result::Result<Messages, Error>;
 type Messages = Vec<Message>;
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct Capability(pub AttrValue);
+
+impl Capability {
+    pub fn new(value: &str) -> Self {
+        Capability(value.to_owned().into())
+    }
+}
+
 #[derive(Debug)]
 pub enum Error {
     UnexpectedCommand(Command),
     UnexpectedSubcommand(String),
     MessageBuilderError(MessageBuilderError),
 }
 
+#[derive(Debug, Clone, PartialEq)]
 pub struct CapNegotiator {
     pub requested: Vec<Capability>,
     pub acknowledged: Vec<Capability>,
@@ -35,7 +43,7 @@ impl CapNegotiator {
         }
     }
 
-    pub fn ls(&self, version: Option<String>) -> Message {
+    pub fn ls(&self, version: Option<&str>) -> Message {
         let mut builder = Message::cmd("CAP").param("LS");
 
         if let Some(version) = version {

src/irc/client/test.rs

@@ -1,13 +1,30 @@
-use websocket::ClientBuilder;
+use websocket::{stream::sync::NetworkStream, sync::Client, ClientBuilder, OwnedMessage};
 
-#[test]
-#[ignore = "requires dotenv to be set up."]
-fn test_client_websocket() {
+use super::{capabilities::CapNegotiator, Capability};
+
+fn connect() -> Client<Box<dyn NetworkStream + Send>> {
     let host = dotenv::var("WEBSOCKET_HOST").expect("");
     println!("Connectin websocket to {host}");
-    let client = ClientBuilder::new(&host).unwrap().connect(None);
-    if let Err(err) = client {
-        println!("Failed to connect websocket to {host}:\n{err}");
-        assert!(false);
+    match ClientBuilder::new(&host).unwrap().connect(None) {
+        Err(err) => {
+            panic!("Failed to connect websocket to {host}:\n{err}")
+        }
+        Ok(client) => client,
+    }
+}
+
+#[test]
+#[ignore = "requires dotenv to be set up."]
+fn integrate_client_with_websocket() {
+    let mut client = connect();
+    let capabilities = CapNegotiator::request(vec![Capability("sasl".into())]);
+
+    let msg = capabilities.ls(Some("302".into()));
+    client
+        .send_message(&OwnedMessage::Text(msg.to_string()))
+        .unwrap();
+
+    if let Ok(msg) = client.recv_message() {
+        println!("{msg:?}");
     }
 }

src/ui/app/home.rs

@@ -50,9 +50,10 @@ fn example_buffer() -> Buffer {
 pub fn HomePage(props: &HomeProps) -> Html {
     let nav = use_navigator().unwrap();
 
-    let client = use_state_eq(|| Client {
-        capabilities: vec![],
-        buffers: vec![example_buffer()],
+    let client = use_state_eq(|| {
+        let mut c = Client::new();
+        c.buffers.push(example_buffer());
+        c
     });
 
     if props.settings.is_none() {