diff options
Diffstat (limited to '')
| -rw-r--r-- | src/error.rs | 25 | ||||
| -rw-r--r-- | src/reader.rs | 184 | ||||
| -rw-r--r-- | src/writer.rs | 483 |
3 files changed, 665 insertions, 27 deletions
diff --git a/src/error.rs b/src/error.rs index 717dfdd..4976a78 100644 --- a/src/error.rs +++ b/src/error.rs @@ -7,6 +7,8 @@ use std::{ }; use thiserror::Error; +#[cfg(target_arch = "wasm32")] +use wasm_bindgen::JsValue; use crate::{ element::{Content, Name, NamespaceDeclaration}, @@ -72,6 +74,29 @@ pub enum Error { Deserialize(#[from] DeserializeError), #[error("root element has already been fully processed")] RootElementEnded, + #[cfg(target_arch = "wasm32")] + #[error("websocket error: {0}")] + Websocket(#[from] WebsocketError), +} + +#[cfg(target_arch = "wasm32")] +#[derive(Error, Debug, Clone)] +pub enum WebsocketError { + #[error("write: {0:?}")] + Write(JsValue), + #[error("invalid encoding")] + InvalidEncoding, + #[error("can't decode blob")] + CantDecodeBlob, + #[error("unknown data type")] + UnknownDataType, +} + +#[cfg(target_arch = "wasm32")] +impl From<JsValue> for Error { + fn from(e: JsValue) -> Self { + Self::Websocket(WebsocketError::Write(e)) + } } impl From<std::io::Error> for Error { diff --git a/src/reader.rs b/src/reader.rs index c4d85f7..0cca93f 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -1,12 +1,25 @@ +#[cfg(target_arch = "wasm32")] +use std::io::Write; + use circular::Buffer; +#[cfg(target_arch = "wasm32")] +use js_sys::{ArrayBuffer, Uint8Array}; use nom::Err; use std::{ collections::{HashMap, HashSet, VecDeque}, str, }; use tokio::io::{AsyncRead, AsyncReadExt}; +#[cfg(target_arch = "wasm32")] +use tokio::sync::mpsc; use tracing::{debug, info, trace}; +#[cfg(target_arch = "wasm32")] +use wasm_bindgen::{closure::Closure, JsCast}; +#[cfg(target_arch = "wasm32")] +use web_sys::{Blob, MessageEvent}; +#[cfg(target_arch = "wasm32")] +use crate::error::WebsocketError; use crate::{ declaration::{Declaration, VersionInfo}, element::{Content, Element, FromElement, Name, NamespaceDeclaration}, @@ -26,9 +39,124 @@ pub struct Reader<R> { // to have names reference namespaces could depth: Vec<Name>, namespace_declarations: Vec<HashSet<NamespaceDeclaration>>, + unendable: bool, root_ended: bool, } +/// Represents a WebSocket Message, after converting from JavaScript type. +/// from https://github.com/najamelan/ws_stream_wasm/blob/dev/src/ws_message.rs +#[cfg(target_arch = "wasm32")] +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum WsMessage { + /// The data of the message is a string. + /// + Text(String), + + /// The message contains binary data. + /// + Binary(Vec<u8>), +} + +/// This will convert the JavaScript event into a WsMessage. Note that this +/// will only work if the connection is set to use the binary type ArrayBuffer. +/// On binary type Blob, this will panic. +/// from https://github.com/najamelan/ws_stream_wasm/blob/dev/src/ws_message.rs +#[cfg(target_arch = "wasm32")] +impl TryFrom<MessageEvent> for WsMessage { + type Error = WebsocketError; + + fn try_from(evt: MessageEvent) -> std::result::Result<Self, Self::Error> { + match evt.data() { + d if d.is_instance_of::<ArrayBuffer>() => { + let buffy = Uint8Array::new(d.unchecked_ref()); + let mut v = vec![0; buffy.length() as usize]; + + buffy.copy_to(&mut v); // FIXME: get rid of this copy + + Ok(WsMessage::Binary(v)) + } + + // We don't allow invalid encodings. In principle if needed, + // we could add a variant to WsMessage with a CString or an OsString + // to allow the user to access this data. However until there is a usecase, + // I'm not inclined, amongst other things because the conversion from Js isn't very + // clear and it would require a bunch of testing for something that's a rather bad + // idea to begin with. If you need data that is not a valid string, use a binary + // message. + // + d if d.is_string() => match d.as_string() { + Some(text) => Ok(WsMessage::Text(text)), + None => Err(WebsocketError::InvalidEncoding), + }, + + // We have set the binary mode to array buffer (WsMeta::connect), so normally this shouldn't happen. + // That is as long as this is used within the context of the WsMeta constructor. + // + d if d.is_instance_of::<Blob>() => Err(WebsocketError::CantDecodeBlob), + + // should never happen. + // + _ => Err(WebsocketError::UnknownDataType), + } + } +} + +#[cfg(target_arch = "wasm32")] +pub struct WebSocketOnMessageRead { + queue: mpsc::UnboundedReceiver<WsMessage>, +} + +#[cfg(target_arch = "wasm32")] +impl WebSocketOnMessageRead { + pub fn new() -> (Closure<dyn FnMut(MessageEvent)>, Self) { + let (send, recv) = mpsc::unbounded_channel(); + let on_msg = Closure::wrap(Box::new(move |msg_evt: MessageEvent| { + let msg_evt = msg_evt.try_into(); + match msg_evt { + Ok(msg_evt) => match send.send(msg_evt) { + Ok(()) => {} + Err(e) => { + tracing::error!("message event send error: {:?}", e); + } + }, + Err(e) => { + tracing::error!("websocket receive error: {}", e); + } + } + }) as Box<dyn FnMut(MessageEvent)>); + + (on_msg, Self { queue: recv }) + } +} + +#[cfg(target_arch = "wasm32")] +impl Readable for WebSocketOnMessageRead { + async fn read_buf(&mut self, buffer: &mut Buffer) -> Result<usize> { + let mut queue = Vec::new(); + self.queue.recv_many(&mut queue, 10).await; + let mut bytes = 0; + for msg in queue { + match msg { + WsMessage::Text(s) => { + let text = s.as_bytes(); + bytes += buffer.write(text)?; + } + WsMessage::Binary(v) => { + bytes += buffer.write(&v)?; + } + } + } + Ok(bytes) + } +} + +pub trait Readable { + fn read_buf( + &mut self, + buffer: &mut Buffer, + ) -> impl std::future::Future<Output = Result<usize>> + Send; +} + impl<R> Reader<R> { pub fn new(reader: R) -> Self { let mut default_declarations = HashSet::new(); @@ -46,6 +174,28 @@ impl<R> Reader<R> { depth: Vec::new(), // TODO: make sure reserved namespaces are never overwritten namespace_declarations: vec![default_declarations], + unendable: false, + root_ended: false, + } + } + + pub fn new_unendable(reader: R) -> Self { + let mut default_declarations = HashSet::new(); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xml".to_string()), + namespace: XML_NS.to_string(), + }); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xmlns".to_string()), + namespace: XMLNS_NS.to_string(), + }); + Self { + inner: reader, + buffer: Buffer::with_capacity(MAX_STANZA_SIZE), + depth: Vec::new(), + // TODO: make sure reserved namespaces are never overwritten + namespace_declarations: vec![default_declarations], + unendable: true, root_ended: false, } } @@ -55,16 +205,18 @@ impl<R> Reader<R> { } } -impl<R> Reader<R> +impl<R> Readable for R where - R: AsyncRead + Unpin, + R: AsyncRead + Unpin + Send, { - pub async fn read_buf<'s>(&mut self) -> Result<usize> { - Ok(self.inner.read_buf(&mut self.buffer).await?) + async fn read_buf(&mut self, buffer: &mut Buffer) -> Result<usize> { + Ok(tokio::io::AsyncReadExt::read_buf(self, buffer).await?) } +} +impl<R: Readable> Reader<R> { pub async fn read_prolog<'s>(&'s mut self) -> Result<Option<Declaration>> { - if self.root_ended { + if !self.unendable && self.root_ended { return Err(Error::RootElementEnded); } loop { @@ -104,7 +256,7 @@ where } std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } // TODO: better error Err::Error(e) => { @@ -131,7 +283,7 @@ where } pub async fn read_start_tag<'s>(&'s mut self) -> Result<Element> { - if self.root_ended { + if !self.unendable && self.root_ended { return Err(Error::RootElementEnded); } loop { @@ -151,7 +303,7 @@ where } std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } // TODO: better error Err::Error(e) => { @@ -166,7 +318,7 @@ where } pub async fn read_end_tag<'s>(&'s mut self) -> Result<()> { - if self.root_ended { + if !self.unendable && self.root_ended { return Err(Error::RootElementEnded); } loop { @@ -189,7 +341,7 @@ where } std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } // TODO: better error Err::Error(e) => { @@ -204,7 +356,7 @@ where } pub async fn read_element<'s>(&'s mut self) -> Result<Element> { - if self.root_ended { + if !self.unendable && self.root_ended { return Err(Error::RootElementEnded); } loop { @@ -224,7 +376,7 @@ where } std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } // TODO: better error Err::Error(e) => { @@ -239,7 +391,7 @@ where } pub async fn read_content<'s>(&'s mut self) -> Result<Content> { - if self.root_ended { + if !self.unendable && self.root_ended { return Err(Error::RootElementEnded); } let mut last_char = false; @@ -256,7 +408,7 @@ where } std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } _ => match xml::ContentItem::parse(input) { Ok((rest, content_item)) => match content_item { @@ -313,7 +465,7 @@ where }, std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } // TODO: better error Err::Error(e) => { @@ -378,7 +530,7 @@ where }, std::result::Result::Err(e) => match e { Err::Incomplete(_) => { - self.read_buf().await?; + self.inner.read_buf(&mut self.buffer).await?; } // TODO: better error Err::Error(e) => { diff --git a/src/writer.rs b/src/writer.rs index 7ed1775..adb7852 100644 --- a/src/writer.rs +++ b/src/writer.rs @@ -3,6 +3,8 @@ use std::collections::HashSet; use async_recursion::async_recursion; use tokio::io::{AsyncWrite, AsyncWriteExt}; use tracing::info; +#[cfg(target_arch = "wasm32")] +use web_sys::WebSocket; use crate::{ declaration::{Declaration, VersionInfo}, @@ -17,12 +19,13 @@ use crate::{ // pub struct Writer<W, C = Composer> { #[derive(Debug)] pub struct Writer<W> { - inner: Endable<Loggable<W>>, + inner: Endable<W>, + unendable: bool, depth: Vec<Name>, namespace_declarations: Vec<HashSet<NamespaceDeclaration>>, } -impl<W> Writer<W> { +impl<W> Writer<Loggable<W>> { pub fn new(writer: W) -> Self { let mut default_declarations = HashSet::new(); default_declarations.insert(NamespaceDeclaration { @@ -35,6 +38,25 @@ impl<W> Writer<W> { }); Self { inner: Endable::new(Loggable::new(writer)), + unendable: false, + depth: Vec::new(), + namespace_declarations: vec![default_declarations], + } + } + + pub fn new_unendable(writer: W) -> Self { + let mut default_declarations = HashSet::new(); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xml".to_string()), + namespace: XML_NS.to_string(), + }); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xmlns".to_string()), + namespace: XMLNS_NS.to_string(), + }); + Self { + inner: Endable::new(Loggable::new(writer)), + unendable: true, depth: Vec::new(), namespace_declarations: vec![default_declarations], } @@ -45,9 +67,434 @@ impl<W> Writer<W> { } } -impl<W: AsyncWrite + Unpin + Send> Writer<W> { +#[cfg(target_arch = "wasm32")] +impl Writer<WebSocket> { + pub fn new(websocket: WebSocket) -> Self { + let mut default_declarations = HashSet::new(); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xml".to_string()), + namespace: XML_NS.to_string(), + }); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xmlns".to_string()), + namespace: XMLNS_NS.to_string(), + }); + Self { + inner: Endable::new(websocket), + unendable: false, + depth: Vec::new(), + namespace_declarations: vec![default_declarations], + } + } + + pub fn new_unendable(websocket: WebSocket) -> Self { + let mut default_declarations = HashSet::new(); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xml".to_string()), + namespace: XML_NS.to_string(), + }); + default_declarations.insert(NamespaceDeclaration { + prefix: Some("xmlns".to_string()), + namespace: XMLNS_NS.to_string(), + }); + Self { + inner: Endable::new(websocket), + unendable: true, + depth: Vec::new(), + namespace_declarations: vec![default_declarations], + } + } + + pub async fn write_declaration(&mut self, version: VersionInfo) -> Result<()> { + let declaration = Declaration::version(version); + let version_info; + match declaration.version_info { + VersionInfo::One => version_info = xml::VersionInfo::SingleQuoted(xml::VersionNum::One), + VersionInfo::OneDotOne => { + version_info = xml::VersionInfo::SingleQuoted(xml::VersionNum::OneDotOne) + } + } + let declaration = xml::XMLDecl { + version_info, + encoding_decl: None, + sd_decl: None, + }; + let declaration = declaration.to_string(); + if self.unendable { + self.inner.ignore_end().send_with_str(&declaration)?; + } else { + self.inner.try_as_mut()?.send_with_str(&declaration)?; + } + Ok(()) + } + + pub async fn write_full(&mut self, into_element: &impl IntoElement) -> Result<()> { + let element = into_element.into_element(); + let mut frame = String::new(); + self.write_element_to_frame(&element, &mut frame)?; + self.inner.ignore_end().send_with_str(&frame)?; + info!("wrote element: {}", frame); + Ok(()) + } + + pub async fn write_start(&mut self, into_element: &impl IntoElement) -> Result<()> { + let element = into_element.into_element(); + let mut frame = String::new(); + self.write_element_start_to_frame(&element, &mut frame)?; + self.inner.ignore_end().send_with_str(&frame)?; + info!("wrote element: {}", frame); + Ok(()) + } + + pub async fn write_all_content(&mut self, into_element: &impl IntoElement) -> Result<()> { + let mut frame = String::new(); + for content in &into_element.get_content() { + self.write_content_to_frame(content, &mut frame)?; + } + self.inner.ignore_end().send_with_str(&frame)?; + info!("wrote element: {}", frame); + Ok(()) + } + + pub async fn write(&mut self, into_content: &impl IntoContent) -> Result<()> { + let content = into_content.into_content(); + let mut frame = String::new(); + self.write_content_to_frame(&content, &mut frame)?; + self.inner.ignore_end().send_with_str(&frame)?; + info!("wrote element: {}", frame); + Ok(()) + } + + // pub async fn write_end(&mut self) + pub async fn write_end(&mut self) -> Result<()> { + let mut frame = String::new(); + self.write_end_tag_to_frame(&mut frame)?; + self.inner.ignore_end().send_with_str(&frame)?; + info!("wrote element: {}", frame); + Ok(()) + } + + pub fn write_element_to_frame(&mut self, element: &Element, frame: &mut String) -> Result<()> { + if element.content.is_empty() { + self.write_empty_to_frame(element, frame)?; + } else { + self.write_element_start_to_frame(element, frame)?; + for content in &element.content { + self.write_content_to_frame(content, frame)?; + } + self.write_end_tag_to_frame(frame)?; + } + Ok(()) + } + + pub fn write_empty_to_frame(&mut self, element: &Element, frame: &mut String) -> Result<()> { + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; + + let mut namespace_declarations_stack: Vec<_> = self + .namespace_declarations + .iter() + .flatten() + .chain(&element.namespace_declaration_overrides) + .collect(); + + let mut namespace_declarations = element.namespace_declaration_overrides.clone(); + + let default_namespace_declaration; + let prefix; + if let Some(namespace) = &element.name.namespace { + if let Some(name_namespace_declaration) = namespace_declarations_stack + .iter() + .rfind(|namespace_declaration| namespace_declaration.namespace == *namespace) + { + prefix = name_namespace_declaration.prefix.as_ref(); + } else { + default_namespace_declaration = NamespaceDeclaration { + prefix: None, + namespace: namespace.clone(), + }; + if namespace_declarations.insert(default_namespace_declaration.clone()) { + namespace_declarations_stack.push(&default_namespace_declaration); + prefix = None + } else { + return Err(Error::DuplicateNameSpaceDeclaration(NamespaceDeclaration { + prefix: None, + namespace: namespace.clone(), + })); + } + } + } else { + prefix = None + } + + let name; + if let Some(prefix) = &prefix { + name = xml::QName::PrefixedName(xml::PrefixedName { + prefix: xml::Prefix::parse_full(prefix)?, + local_part: xml::LocalPart::parse_full(&element.name.local_name)?, + }) + } else { + name = xml::QName::UnprefixedName(xml::UnprefixedName::parse_full( + &element.name.local_name, + )?) + } + + let mut attributes = Vec::new(); + + for namespace_declaration in namespace_declarations.iter() { + let ns_name = namespace_declaration + .prefix + .as_ref() + .map(|prefix| -> Result<_> { + Ok(xml::NSAttName::PrefixedAttName(xml::PrefixedAttName( + xml::NCName::parse_full(&prefix)?, + ))) + }) + .unwrap_or(Ok(xml::NSAttName::DefaultAttName))?; + let value = xml::AttValue::from(namespace_declaration.namespace.as_str()); + let xml_attribute = xml::Attribute::NamespaceDeclaration { ns_name, value }; + attributes.push(xml_attribute); + } + + for (name, value) in &element.attributes { + let prefix; + if let Some(namespace) = &name.namespace { + let name_namespace_declaration = namespace_declarations_stack + .iter() + .rfind(|namespace_declaration| namespace_declaration.namespace == *namespace) + .ok_or(Error::UndeclaredNamespace(namespace.clone()))?; + prefix = name_namespace_declaration.prefix.as_ref(); + } else { + prefix = None + } + + let att_name; + if let Some(prefix) = &prefix { + att_name = xml::QName::PrefixedName(xml::PrefixedName { + prefix: xml::Prefix::parse_full(prefix)?, + local_part: xml::LocalPart::parse_full(&name.local_name)?, + }) + } else { + att_name = + xml::QName::UnprefixedName(xml::UnprefixedName::parse_full(&name.local_name)?) + } + + let value = xml::AttValue::from(value.as_str()); + + let xml_attribute = xml::Attribute::Attribute { + name: att_name, + value, + }; + attributes.push(xml_attribute); + } + + let tag = xml::EmptyElemTag { name, attributes }; + + frame.push_str(&tag.to_string()); + + // if self.depth.is_empty() { + // self.inner.end(); + // } + + Ok(()) + } + + pub fn write_element_start_to_frame( + &mut self, + element: &Element, + frame: &mut String, + ) -> Result<()> { + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; + + let mut namespace_declarations_stack: Vec<_> = self + .namespace_declarations + .iter() + .flatten() + .chain(&element.namespace_declaration_overrides) + .collect(); + + let mut namespace_declarations = element.namespace_declaration_overrides.clone(); + + let default_namespace_declaration; + let prefix; + if let Some(namespace) = &element.name.namespace { + if let Some(name_namespace_declaration) = namespace_declarations_stack + .iter() + .rfind(|namespace_declaration| namespace_declaration.namespace == *namespace) + { + prefix = name_namespace_declaration.prefix.as_ref(); + } else { + default_namespace_declaration = NamespaceDeclaration { + prefix: None, + namespace: namespace.clone(), + }; + if namespace_declarations.insert(default_namespace_declaration.clone()) { + namespace_declarations_stack.push(&default_namespace_declaration); + prefix = None + } else { + return Err(Error::DuplicateNameSpaceDeclaration(NamespaceDeclaration { + prefix: None, + namespace: namespace.clone(), + })); + } + } + } else { + prefix = None + } + + let name; + if let Some(prefix) = &prefix { + name = xml::QName::PrefixedName(xml::PrefixedName { + prefix: xml::Prefix::parse_full(prefix)?, + local_part: xml::LocalPart::parse_full(&element.name.local_name)?, + }) + } else { + name = xml::QName::UnprefixedName(xml::UnprefixedName::parse_full( + &element.name.local_name, + )?) + } + + let mut attributes = Vec::new(); + + for namespace_declaration in namespace_declarations.iter() { + let ns_name = namespace_declaration + .prefix + .as_ref() + .map(|prefix| -> Result<_> { + Ok(xml::NSAttName::PrefixedAttName(xml::PrefixedAttName( + xml::NCName::parse_full(&prefix)?, + ))) + }) + .unwrap_or(Ok(xml::NSAttName::DefaultAttName))?; + let value = xml::AttValue::from(namespace_declaration.namespace.as_str()); + let xml_attribute = xml::Attribute::NamespaceDeclaration { ns_name, value }; + attributes.push(xml_attribute); + } + + for (name, value) in &element.attributes { + let prefix; + if let Some(namespace) = &name.namespace { + let name_namespace_declaration = namespace_declarations_stack + .iter() + .rfind(|namespace_declaration| namespace_declaration.namespace == *namespace) + .ok_or(Error::UndeclaredNamespace(namespace.clone()))?; + prefix = name_namespace_declaration.prefix.as_ref(); + } else { + prefix = None + } + + let att_name; + if let Some(prefix) = &prefix { + att_name = xml::QName::PrefixedName(xml::PrefixedName { + prefix: xml::Prefix::parse_full(prefix)?, + local_part: xml::LocalPart::parse_full(&name.local_name)?, + }) + } else { + att_name = + xml::QName::UnprefixedName(xml::UnprefixedName::parse_full(&name.local_name)?) + } + + let value = xml::AttValue::from(value.as_str()); + + let xml_attribute = xml::Attribute::Attribute { + name: att_name, + value, + }; + attributes.push(xml_attribute); + } + + let s_tag = xml::STag { name, attributes }; + + frame.push_str(&s_tag.to_string()); + + self.depth.push(element.name.clone()); + self.namespace_declarations + .push(namespace_declarations.clone()); + Ok(()) + } + + pub fn write_content_to_frame(&mut self, content: &Content, frame: &mut String) -> Result<()> { + match content { + Content::Element(element) => self.write_element_to_frame(element, frame)?, + Content::Text(text) => { + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; + frame.push_str(&escape_str(text)) + } + // TODO: comments and PI + Content::PI => {} + Content::Comment(_) => {} + } + Ok(()) + } + + pub fn write_end_tag_to_frame(&mut self, frame: &mut String) -> Result<()> { + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; + if let Some(name) = &self.depth.pop() { + let e_tag; + let namespace_declarations_stack: Vec<_> = + self.namespace_declarations.iter().flatten().collect(); + + let prefix; + if let Some(namespace) = &name.namespace { + let name_namespace_declaration = namespace_declarations_stack + .iter() + .rfind(|namespace_declaration| namespace_declaration.namespace == *namespace) + .ok_or(Error::UndeclaredNamespace(namespace.clone()))?; + prefix = name_namespace_declaration.prefix.as_ref(); + } else { + prefix = None + } + + if let Some(prefix) = &prefix { + e_tag = xml::ETag { + name: xml::QName::PrefixedName(xml::PrefixedName { + prefix: xml::Prefix::parse_full(prefix)?, + local_part: xml::LocalPart::parse_full(&name.local_name)?, + }), + }; + } else { + e_tag = xml::ETag { + name: xml::QName::UnprefixedName(xml::UnprefixedName::parse_full( + &name.local_name, + )?), + }; + } + frame.push_str(&e_tag.to_string()); + self.namespace_declarations.pop(); + + // if self.depth.is_empty() { + // self.inner.end(); + // } + Ok(()) + } else { + return Err(Error::NotInElement("".to_string())); + } + } +} + +#[cfg(not(target_arch = "wasm32"))] +impl<W: AsyncWrite + Unpin + Send> Writer<Loggable<W>> { pub async fn write_declaration(&mut self, version: VersionInfo) -> Result<()> { - let writer = self.inner.try_as_mut()?; + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; let declaration = Declaration::version(version); let version_info; match declaration.version_info { @@ -126,7 +573,11 @@ impl<W: AsyncWrite + Unpin + Send> Writer<W> { } pub async fn write_empty(&mut self, element: &Element) -> Result<()> { - let writer = self.inner.try_as_mut()?; + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; let mut namespace_declarations_stack: Vec<_> = self .namespace_declarations .iter() @@ -236,7 +687,11 @@ impl<W: AsyncWrite + Unpin + Send> Writer<W> { } pub async fn write_element_start(&mut self, element: &Element) -> Result<()> { - let writer = self.inner.try_as_mut()?; + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; let mut namespace_declarations_stack: Vec<_> = self .namespace_declarations .iter() @@ -348,10 +803,12 @@ impl<W: AsyncWrite + Unpin + Send> Writer<W> { match content { Content::Element(element) => self.write_element(element).await?, Content::Text(text) => { - self.inner - .try_as_mut()? - .write_all(escape_str(text).as_bytes()) - .await? + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; + writer.write_all(escape_str(text).as_bytes()).await? } // TODO: comments and PI Content::PI => {} @@ -361,7 +818,11 @@ impl<W: AsyncWrite + Unpin + Send> Writer<W> { } pub async fn write_end_tag(&mut self) -> Result<()> { - let writer = self.inner.try_as_mut()?; + let writer = if self.unendable { + self.inner.ignore_end() + } else { + self.inner.try_as_mut()? + }; if let Some(name) = &self.depth.pop() { let e_tag; let namespace_declarations_stack: Vec<_> = |