aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--examples/example.rs (renamed from src/main.rs)0
-rw-r--r--src/error.rs30
-rw-r--r--src/lib.rs2
-rw-r--r--src/reader.rs239
-rw-r--r--src/writer.rs487
-rw-r--r--src/xml/mod.rs2
-rw-r--r--src/xml/parsers_complete.rs7
7 files changed, 721 insertions, 46 deletions
diff --git a/src/main.rs b/examples/example.rs
index 580652e..580652e 100644
--- a/src/main.rs
+++ b/examples/example.rs
diff --git a/src/error.rs b/src/error.rs
index ae4aa26..d927bc1 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},
@@ -45,13 +47,16 @@ pub enum DeserializeError {
// TODO: add error context (usually the stanza)
#[derive(Error, Debug, Clone)]
pub enum Error {
+ #[cfg(target_arch = "wasm32")]
+ #[error("websocket closed")]
+ WebSocketClosed,
#[error("io: {0}")]
// TODO: is this okay?
ReadError(Arc<std::io::Error>),
#[error("utf8 conversion: {0}")]
Utf8Error(#[from] Utf8Error),
#[error("nom parsing: {0}")]
- ParseError(String),
+ ParseError(String, String),
#[error("unknown xml entity reference `&{0};`")]
EntityProcessError(String),
#[error("invalid character reference: {0}")]
@@ -72,6 +77,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/lib.rs b/src/lib.rs
index 3b4a592..8d95d0b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,7 +2,7 @@ pub mod declaration;
pub mod element;
mod endable;
mod error;
-mod loggable;
+pub mod loggable;
pub mod reader;
mod writer;
pub mod xml;
diff --git a/src/reader.rs b/src/reader.rs
index 9eb7c91..751ee1d 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,121 @@ 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")]
+#[derive(Debug)]
+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> {
+ debug!("reading buf");
+ let msg = self.queue.recv().await;
+ let msg = match msg {
+ Some(msg) => msg,
+ None => return Err(Error::WebSocketClosed),
+ };
+ match msg {
+ WsMessage::Text(s) => {
+ let text = s.as_bytes();
+ Ok(buffer.write(text)?)
+ }
+ WsMessage::Binary(v) => Ok(buffer.write(&v)?),
+ }
+ }
+}
+
+pub trait Readable {
+ fn read_buf(&mut self, buffer: &mut Buffer)
+ -> impl std::future::Future<Output = Result<usize>>;
+}
+
impl<R> Reader<R> {
pub fn new(reader: R) -> Self {
let mut default_declarations = HashSet::new();
@@ -46,6 +171,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 +202,18 @@ impl<R> Reader<R> {
}
}
-impl<R> Reader<R>
+impl<R> Readable for R
where
R: AsyncRead + Unpin,
{
- 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,11 +253,15 @@ 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) => return Err(Error::ParseError(e.to_string())),
- Err::Failure(e) => return Err(Error::ParseError(e.to_string())),
+ Err::Error(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
+ Err::Failure(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
},
}
}
@@ -127,7 +280,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 {
@@ -147,18 +300,22 @@ 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) => return Err(Error::ParseError(e.to_string())),
- Err::Failure(e) => return Err(Error::ParseError(e.to_string())),
+ Err::Error(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
+ Err::Failure(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
},
}
}
}
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 {
@@ -181,18 +338,22 @@ 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) => return Err(Error::ParseError(e.to_string())),
- Err::Failure(e) => return Err(Error::ParseError(e.to_string())),
+ Err::Error(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
+ Err::Failure(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
},
}
}
}
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 {
@@ -212,18 +373,22 @@ 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) => return Err(Error::ParseError(e.to_string())),
- Err::Failure(e) => return Err(Error::ParseError(e.to_string())),
+ Err::Error(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
+ Err::Failure(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
},
}
}
}
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;
@@ -240,7 +405,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 {
@@ -289,7 +454,7 @@ where
} else {
let len =
self.buffer.available_data() - rest.as_bytes().len();
- let comment = comment.to_string();
+ let comment = comment.0.to_string();
self.buffer.consume(len);
return Ok(Content::Comment(comment));
}
@@ -297,11 +462,15 @@ 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) => return Err(Error::ParseError(e.to_string())),
- Err::Failure(e) => return Err(Error::ParseError(e.to_string())),
+ Err::Error(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
+ Err::Failure(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
},
},
},
@@ -351,18 +520,22 @@ where
}
xml::ContentItem::Comment(comment) => {
let len = self.buffer.available_data() - rest.as_bytes().len();
- let comment = comment.to_string();
+ let comment = comment.0.to_string();
self.buffer.consume(len);
return Ok(Content::Comment(comment));
}
},
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) => return Err(Error::ParseError(e.to_string())),
- Err::Failure(e) => return Err(Error::ParseError(e.to_string())),
+ Err::Error(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
+ Err::Failure(e) => {
+ return Err(Error::ParseError(input.to_string(), e.to_string()))
+ }
},
}
}
@@ -388,7 +561,7 @@ impl<R> Reader<R> {
}) {
let prefix = match prefix {
xml::NSAttName::PrefixedAttName(prefixed_att_name) => {
- Some(prefixed_att_name.to_string())
+ Some(prefixed_att_name.0.to_string())
}
xml::NSAttName::DefaultAttName => None,
};
@@ -408,6 +581,10 @@ impl<R> Reader<R> {
.chain(element_namespace_declarations.iter())
.collect();
+ trace!(
+ "namespace declaration stack: {:?}",
+ namespace_declarations_stack
+ );
// element name
let element_namespace_declaration;
@@ -571,7 +748,7 @@ impl<R> Reader<R> {
}) {
let prefix = match prefix {
xml::NSAttName::PrefixedAttName(prefixed_att_name) => {
- Some(prefixed_att_name.to_string())
+ Some(prefixed_att_name.0.to_string())
}
xml::NSAttName::DefaultAttName => None,
};
diff --git a/src/writer.rs b/src/writer.rs
index 7ed1775..40a935b 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,438 @@ 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 into_inner(self) -> WebSocket {
+ self.inner.into_inner()
+ }
+
+ 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 +577,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 +691,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 +807,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 +822,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<_> =
diff --git a/src/xml/mod.rs b/src/xml/mod.rs
index b0d9056..005a122 100644
--- a/src/xml/mod.rs
+++ b/src/xml/mod.rs
@@ -328,7 +328,7 @@ impl<'s> Deref for CharData<'s> {
/// [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
#[derive(Clone, Debug, PartialEq, Eq)]
#[repr(transparent)]
-pub struct Comment<'s>(&'s str);
+pub struct Comment<'s>(pub(crate) &'s str);
impl<'s> Deref for Comment<'s> {
type Target = &'s str;
diff --git a/src/xml/parsers_complete.rs b/src/xml/parsers_complete.rs
index f18d0ff..1e2ac31 100644
--- a/src/xml/parsers_complete.rs
+++ b/src/xml/parsers_complete.rs
@@ -40,7 +40,12 @@ pub trait Parser<'s> {
return Err(crate::error::Error::ExtraData(rest.to_string()));
}
}
- Result::Err(e) => return Err(crate::error::Error::ParseError(e.to_string())),
+ Result::Err(e) => {
+ return Err(crate::error::Error::ParseError(
+ input.to_string(),
+ e.to_string(),
+ ))
+ }
}
}
}
generated by cgit (git 2.34.1) at 2025-04-17 11:07:38 +0000