switch to using peanuts for xml

1 files changed, 18 insertions, 57 deletions

diff --git a/src/jabber.rs b/src/jabber.rs
index 1436bfa..afe840b 100644
--- a/src/jabber.rs
+++ b/src/jabber.rs
@@ -1,16 +1,15 @@
 use std::str;
 use std::sync::Arc;
 
-use quick_xml::{events::Event, se::Serializer, NsReader, Writer};
+use peanuts::{Reader, Writer};
 use rsasl::prelude::SASLConfig;
-use serde::Serialize;
 use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
 use tracing::{debug, info, trace};
 
 use crate::connection::{Tls, Unencrypted};
-use crate::error::JabberError;
+use crate::error::Error;
 use crate::stanza::stream::Stream;
-use crate::stanza::DECLARATION;
+use crate::stanza::XML_VERSION;
 use crate::Result;
 use crate::JID;
 
@@ -18,8 +17,8 @@ pub struct Jabber<S>
 where
     S: AsyncRead + AsyncWrite + Unpin,
 {
-    reader: NsReader<BufReader<ReadHalf<S>>>,
-    writer: WriteHalf<S>,
+    reader: Reader<ReadHalf<S>>,
+    writer: Writer<WriteHalf<S>>,
     jid: Option<JID>,
     auth: Option<Arc<SASLConfig>>,
     server: String,
@@ -36,7 +35,8 @@ where
         auth: Option<Arc<SASLConfig>>,
         server: String,
     ) -> Self {
-        let reader = NsReader::from_reader(BufReader::new(reader));
+        let reader = Reader::new(reader);
+        let writer = Writer::new(writer);
         Self {
             reader,
             writer,
@@ -49,7 +49,7 @@ where
 
 impl<S> Jabber<S>
 where
-    S: AsyncRead + AsyncWrite + Unpin,
+    S: AsyncRead + AsyncWrite + Unpin + Send,
 {
     // pub async fn negotiate(self) -> Result<Jabber<S>> {}
 
@@ -57,65 +57,26 @@ where
         // client to server
 
         // declaration
-        let mut xmlwriter = Writer::new(&mut self.writer);
-        xmlwriter.write_event_async(DECLARATION.clone()).await?;
+        self.writer.write_declaration(XML_VERSION).await?;
 
         // opening stream element
-        let server = &self.server.to_owned().try_into()?;
-        let stream_element = Stream::new_client(None, server, None, "en");
+        let server = self.server.clone().try_into()?;
+        let stream = Stream::new_client(None, server, None, "en".to_string());
         // TODO: nicer function to serialize to xml writer
-        let mut buffer = String::new();
-        let ser = Serializer::with_root(&mut buffer, Some("stream:stream")).expect("stream name");
-        stream_element.serialize(ser).unwrap();
-        trace!("sent: {}", buffer);
-        self.writer.write_all(buffer.as_bytes()).await.unwrap();
+        self.writer.write_start(&stream).await?;
 
         // server to client
 
         // may or may not send a declaration
-        let mut buf = Vec::new();
-        let mut first_event = self.reader.read_resolved_event_into_async(&mut buf).await?;
-        trace!("received: {:?}", first_event);
-        match first_event {
-            (quick_xml::name::ResolveResult::Unbound, Event::Decl(e)) => {
-                if let Ok(version) = e.version() {
-                    if version.as_ref() == b"1.0" {
-                        first_event = self.reader.read_resolved_event_into_async(&mut buf).await?;
-                        trace!("received: {:?}", first_event);
-                    } else {
-                        // todo: error
-                        todo!()
-                    }
-                } else {
-                    first_event = self.reader.read_resolved_event_into_async(&mut buf).await?;
-                    trace!("received: {:?}", first_event);
-                }
-            }
-            _ => (),
-        }
+        let decl = self.reader.read_prolog().await?;
 
         // receive stream element and validate
-        match first_event {
-            (quick_xml::name::ResolveResult::Bound(ns), Event::Start(e)) => {
-                if ns.0 == crate::stanza::stream::XMLNS.as_bytes() {
-                    e.attributes().try_for_each(|attr| -> Result<()> {
-                        let attr = attr?;
-                        match attr.key.into_inner() {
-                            b"from" => {
-                                self.server = str::from_utf8(&attr.value)?.to_owned();
-                                Ok(())
-                            }
-                            _ => Ok(()),
-                        }
-                    });
-                    return Ok(());
-                } else {
-                    return Err(JabberError::BadStream);
-                }
-            }
-            // TODO: errors for incorrect namespace
-            _ => Err(JabberError::BadStream),
+        let stream: Stream = self.reader.read_start().await?;
+        if let Some(from) = stream.from {
+            self.server = from.to_string()
         }
+
+        Ok(())
     }
 }