use cargo workspace

1 files changed, 0 insertions, 191 deletions

diff --git a/src/stanza/stream.rs b/src/stanza/stream.rs
deleted file mode 100644
index 84d62d9..0000000
--- a/src/stanza/stream.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use peanuts::element::{Content, ElementBuilder, FromElement, IntoElement, NamespaceDeclaration};
-use peanuts::XML_NS;
-use peanuts::{element::Name, Element};
-use tracing::debug;
-
-use crate::stanza::bind;
-use crate::JID;
-
-use super::sasl::{self, Mechanisms};
-use super::starttls::{self, StartTls};
-use super::stream_error::{Error as StreamError, Text};
-use super::{client, stream_error};
-
-pub const XMLNS: &str = "http://etherx.jabber.org/streams";
-
-// MUST be qualified by stream namespace
-// #[derive(XmlSerialize, XmlDeserialize)]
-// #[peanuts(xmlns = XMLNS)]
-#[derive(Debug)]
-pub struct Stream {
-    pub from: Option<JID>,
-    to: Option<JID>,
-    id: Option<String>,
-    version: Option<String>,
-    // TODO: lang enum
-    lang: Option<String>,
-    // #[peanuts(content)]
-    // content: Message,
-}
-
-impl FromElement for Stream {
-    fn from_element(mut element: Element) -> std::result::Result<Self, peanuts::DeserializeError> {
-        element.check_namespace(XMLNS)?;
-        element.check_name("stream")?;
-
-        let from = element.attribute_opt("from")?;
-        let to = element.attribute_opt("to")?;
-        let id = element.attribute_opt("id")?;
-        let version = element.attribute_opt("version")?;
-        let lang = element.attribute_opt_namespaced("lang", peanuts::XML_NS)?;
-
-        Ok(Stream {
-            from,
-            to,
-            id,
-            version,
-            lang,
-        })
-    }
-}
-
-impl IntoElement for Stream {
-    fn builder(&self) -> ElementBuilder {
-        Element::builder("stream", Some(XMLNS.to_string()))
-            .push_namespace_declaration_override(Some("stream"), XMLNS)
-            .push_namespace_declaration_override(None::<&str>, client::XMLNS)
-            .push_attribute_opt("to", self.to.clone())
-            .push_attribute_opt("from", self.from.clone())
-            .push_attribute_opt("id", self.id.clone())
-            .push_attribute_opt("version", self.version.clone())
-            .push_attribute_opt_namespaced(peanuts::XML_NS, "to", self.lang.clone())
-    }
-}
-
-impl<'s> Stream {
-    pub fn new(
-        from: Option<JID>,
-        to: Option<JID>,
-        id: Option<String>,
-        version: Option<String>,
-        lang: Option<String>,
-    ) -> Self {
-        Self {
-            from,
-            to,
-            id,
-            version,
-            lang,
-        }
-    }
-
-    /// For initial stream headers, the initiating entity SHOULD include the 'xml:lang' attribute.
-    /// For privacy, it is better to not set `from` when sending a client stanza over an unencrypted connection.
-    pub fn new_client(from: Option<JID>, to: JID, id: Option<String>, lang: String) -> Self {
-        Self {
-            from,
-            to: Some(to),
-            id,
-            version: Some("1.0".to_string()),
-            lang: Some(lang),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Features {
-    pub features: Vec<Feature>,
-}
-
-impl IntoElement for Features {
-    fn builder(&self) -> ElementBuilder {
-        Element::builder("features", Some(XMLNS)).push_children(self.features.clone())
-    }
-}
-
-impl FromElement for Features {
-    fn from_element(
-        mut element: Element,
-    ) -> std::result::Result<Features, peanuts::DeserializeError> {
-        element.check_namespace(XMLNS)?;
-        element.check_name("features")?;
-
-        debug!("got features stanza");
-        let features = element.children()?;
-        debug!("got features period");
-
-        Ok(Features { features })
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum Feature {
-    StartTls(StartTls),
-    Sasl(Mechanisms),
-    Bind,
-    Unknown,
-}
-
-impl IntoElement for Feature {
-    fn builder(&self) -> ElementBuilder {
-        match self {
-            Feature::StartTls(start_tls) => start_tls.builder(),
-            Feature::Sasl(mechanisms) => mechanisms.builder(),
-            Feature::Bind => todo!(),
-            Feature::Unknown => todo!(),
-        }
-    }
-}
-
-impl FromElement for Feature {
-    fn from_element(element: Element) -> peanuts::element::DeserializeResult<Self> {
-        let identity = element.identify();
-        debug!("identity: {:?}", identity);
-        match element.identify() {
-            (Some(starttls::XMLNS), "starttls") => {
-                debug!("identified starttls");
-                Ok(Feature::StartTls(StartTls::from_element(element)?))
-            }
-            (Some(sasl::XMLNS), "mechanisms") => {
-                debug!("identified mechanisms");
-                Ok(Feature::Sasl(Mechanisms::from_element(element)?))
-            }
-            (Some(bind::XMLNS), "bind") => {
-                debug!("identified bind");
-                Ok(Feature::Bind)
-            }
-            _ => {
-                debug!("identified unknown feature");
-                Ok(Feature::Unknown)
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Error {
-    error: StreamError,
-    text: Option<Text>,
-}
-
-impl FromElement for Error {
-    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
-        element.check_name("error")?;
-        element.check_namespace(XMLNS)?;
-
-        let error = element.pop_child_one()?;
-        let text = element.pop_child_opt()?;
-
-        Ok(Error { error, text })
-    }
-}
-
-impl IntoElement for Error {
-    fn builder(&self) -> ElementBuilder {
-        Element::builder("error", Some(XMLNS))
-            .push_child(self.error.clone())
-            .push_child_opt(self.text.clone())
-    }
-}