quick_xml/
writer.rs

Help
1//! Contains high-level interface for an events-based XML emitter.
2
3use std::io::Write;
4use std::result::Result as StdResult;
5
6use crate::encoding::UTF8_BOM;
7use crate::errors::{Error, Result};
8use crate::events::{attributes::Attribute, BytesCData, BytesStart, BytesText, Event};
9
10#[cfg(feature = "async-tokio")]
11mod async_tokio;
12
13/// XML writer. Writes XML [`Event`]s to a [`std::io::Write`] or [`tokio::io::AsyncWrite`] implementor.
14#[cfg(feature = "serialize")]
15use {crate::de::DeError, serde::Serialize};
16
17/// XML writer. Writes XML [`Event`]s to a [`std::io::Write`] implementor.
18///
19/// # Examples
20///
21/// ```
22/// # use pretty_assertions::assert_eq;
23/// use quick_xml::events::{Event, BytesEnd, BytesStart};
24/// use quick_xml::reader::Reader;
25/// use quick_xml::writer::Writer;
26/// use std::io::Cursor;
27///
28/// let xml = r#"<this_tag k1="v1" k2="v2"><child>text</child></this_tag>"#;
29/// let mut reader = Reader::from_str(xml);
30/// reader.trim_text(true);
31/// let mut writer = Writer::new(Cursor::new(Vec::new()));
32/// loop {
33///     match reader.read_event() {
34///         Ok(Event::Start(e)) if e.name().as_ref() == b"this_tag" => {
35///
36///             // crates a new element ... alternatively we could reuse `e` by calling
37///             // `e.into_owned()`
38///             let mut elem = BytesStart::new("my_elem");
39///
40///             // collect existing attributes
41///             elem.extend_attributes(e.attributes().map(|attr| attr.unwrap()));
42///
43///             // copy existing attributes, adds a new my-key="some value" attribute
44///             elem.push_attribute(("my-key", "some value"));
45///
46///             // writes the event to the writer
47///             assert!(writer.write_event(Event::Start(elem)).is_ok());
48///         },
49///         Ok(Event::End(e)) if e.name().as_ref() == b"this_tag" => {
50///             assert!(writer.write_event(Event::End(BytesEnd::new("my_elem"))).is_ok());
51///         },
52///         Ok(Event::Eof) => break,
53///         // we can either move or borrow the event to write, depending on your use-case
54///         Ok(e) => assert!(writer.write_event(e).is_ok()),
55///         Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
56///     }
57/// }
58///
59/// let result = writer.into_inner().into_inner();
60/// let expected = r#"<my_elem k1="v1" k2="v2" my-key="some value"><child>text</child></my_elem>"#;
61/// assert_eq!(result, expected.as_bytes());
62/// ```
63#[derive(Clone)]
64pub struct Writer<W> {
65    /// underlying writer
66    writer: W,
67    indent: Option<Indentation>,
68}
69
70impl<W> Writer<W> {
71    /// Creates a `Writer` from a generic writer.
72    pub fn new(inner: W) -> Writer<W> {
73        Writer {
74            writer: inner,
75            indent: None,
76        }
77    }
78
79    /// Creates a `Writer` with configured indents from a generic writer.
80    pub fn new_with_indent(inner: W, indent_char: u8, indent_size: usize) -> Writer<W> {
81        Writer {
82            writer: inner,
83            indent: Some(Indentation::new(indent_char, indent_size)),
84        }
85    }
86
87    /// Consumes this `Writer`, returning the underlying writer.
88    pub fn into_inner(self) -> W {
89        self.writer
90    }
91
92    /// Get a mutable reference to the underlying writer.
93    pub fn get_mut(&mut self) -> &mut W {
94        &mut self.writer
95    }
96
97    /// Get a reference to the underlying writer.
98    pub fn get_ref(&self) -> &W {
99        &self.writer
100    }
101
102    /// Provides a simple, high-level API for writing XML elements.
103    ///
104    /// Returns an [`ElementWriter`] that simplifies setting attributes and writing
105    /// content inside the element.
106    ///
107    /// # Example
108    ///
109    /// ```
110    /// # use quick_xml::Result;
111    /// # fn main() -> Result<()> {
112    /// use quick_xml::events::{BytesStart, BytesText, Event};
113    /// use quick_xml::writer::Writer;
114    /// use quick_xml::Error;
115    /// use std::io::Cursor;
116    ///
117    /// let mut writer = Writer::new(Cursor::new(Vec::new()));
118    ///
119    /// // writes <tag attr1="value1"/>
120    /// writer.create_element("tag")
121    ///     .with_attribute(("attr1", "value1"))  // chain `with_attribute()` calls to add many attributes
122    ///     .write_empty()?;
123    ///
124    /// // writes <tag attr1="value1" attr2="value2">with some text inside</tag>
125    /// writer.create_element("tag")
126    ///     .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter())  // or add attributes from an iterator
127    ///     .write_text_content(BytesText::new("with some text inside"))?;
128    ///
129    /// // writes <tag><fruit quantity="0">apple</fruit><fruit quantity="1">orange</fruit></tag>
130    /// writer.create_element("tag")
131    ///     // We need to provide error type, because it is not named somewhere explicitly
132    ///     .write_inner_content::<_, Error>(|writer| {
133    ///         let fruits = ["apple", "orange"];
134    ///         for (quant, item) in fruits.iter().enumerate() {
135    ///             writer
136    ///                 .create_element("fruit")
137    ///                 .with_attribute(("quantity", quant.to_string().as_str()))
138    ///                 .write_text_content(BytesText::new(item))?;
139    ///         }
140    ///         Ok(())
141    ///     })?;
142    /// # Ok(())
143    /// # }
144    /// ```
145    #[must_use]
146    pub fn create_element<'a, N>(&'a mut self, name: &'a N) -> ElementWriter<W>
147    where
148        N: 'a + AsRef<str> + ?Sized,
149    {
150        ElementWriter {
151            writer: self,
152            start_tag: BytesStart::new(name.as_ref()),
153        }
154    }
155}
156
157impl<W: Write> Writer<W> {
158    /// Write a [Byte-Order-Mark] character to the document.
159    ///
160    /// # Example
161    ///
162    /// ```rust
163    /// # use quick_xml::Result;
164    /// # fn main() -> Result<()> {
165    /// use quick_xml::events::{BytesStart, BytesText, Event};
166    /// use quick_xml::writer::Writer;
167    /// use quick_xml::Error;
168    /// use std::io::Cursor;
169    ///
170    /// let mut buffer = Vec::new();
171    /// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
172    ///
173    /// writer.write_bom()?;
174    /// writer
175    ///     .create_element("empty")
176    ///     .with_attribute(("attr1", "value1"))
177    ///     .write_empty()
178    ///     .expect("failure");
179    ///
180    /// assert_eq!(
181    ///     std::str::from_utf8(&buffer).unwrap(),
182    ///     "\u{FEFF}<empty attr1=\"value1\"/>"
183    /// );
184    /// # Ok(())
185    /// # }
186    /// ```
187    /// [Byte-Order-Mark]: https://unicode.org/faq/utf_bom.html#BOM
188    pub fn write_bom(&mut self) -> Result<()> {
189        self.write(UTF8_BOM)
190    }
191
192    /// Writes the given event to the underlying writer.
193    pub fn write_event<'a, E: AsRef<Event<'a>>>(&mut self, event: E) -> Result<()> {
194        let mut next_should_line_break = true;
195        let result = match *event.as_ref() {
196            Event::Start(ref e) => {
197                let result = self.write_wrapped(b"<", e, b">");
198                if let Some(i) = self.indent.as_mut() {
199                    i.grow();
200                }
201                result
202            }
203            Event::End(ref e) => {
204                if let Some(i) = self.indent.as_mut() {
205                    i.shrink();
206                }
207                self.write_wrapped(b"</", e, b">")
208            }
209            Event::Empty(ref e) => self.write_wrapped(b"<", e, b"/>"),
210            Event::Text(ref e) => {
211                next_should_line_break = false;
212                self.write(e)
213            }
214            Event::Comment(ref e) => self.write_wrapped(b"<!--", e, b"-->"),
215            Event::CData(ref e) => {
216                next_should_line_break = false;
217                self.write(b"<![CDATA[")?;
218                self.write(e)?;
219                self.write(b"]]>")
220            }
221            Event::Decl(ref e) => self.write_wrapped(b"<?", e, b"?>"),
222            Event::PI(ref e) => self.write_wrapped(b"<?", e, b"?>"),
223            Event::DocType(ref e) => self.write_wrapped(b"<!DOCTYPE ", e, b">"),
224            Event::Eof => Ok(()),
225        };
226        if let Some(i) = self.indent.as_mut() {
227            i.should_line_break = next_should_line_break;
228        }
229        result
230    }
231
232    /// Writes bytes
233    #[inline]
234    pub(crate) fn write(&mut self, value: &[u8]) -> Result<()> {
235        self.writer.write_all(value).map_err(Into::into)
236    }
237
238    #[inline]
239    fn write_wrapped(&mut self, before: &[u8], value: &[u8], after: &[u8]) -> Result<()> {
240        if let Some(ref i) = self.indent {
241            if i.should_line_break {
242                self.writer.write_all(b"\n")?;
243                self.writer.write_all(i.current())?;
244            }
245        }
246        self.write(before)?;
247        self.write(value)?;
248        self.write(after)?;
249        Ok(())
250    }
251
252    /// Manually write a newline and indentation at the proper level.
253    ///
254    /// This can be used when the heuristic to line break and indent after any
255    /// [`Event`] apart from [`Text`] fails such as when a [`Start`] occurs directly
256    /// after [`Text`].
257    ///
258    /// This method will do nothing if `Writer` was not constructed with [`new_with_indent`].
259    ///
260    /// [`Text`]: Event::Text
261    /// [`Start`]: Event::Start
262    /// [`new_with_indent`]: Self::new_with_indent
263    pub fn write_indent(&mut self) -> Result<()> {
264        if let Some(ref i) = self.indent {
265            self.writer.write_all(b"\n")?;
266            self.writer.write_all(i.current())?;
267        }
268        Ok(())
269    }
270
271    /// Write an arbitrary serializable type
272    ///
273    /// Note: If you are attempting to write XML in a non-UTF-8 encoding, this may not
274    /// be safe to use. Rust basic types assume UTF-8 encodings.
275    ///
276    /// ```rust
277    /// # use pretty_assertions::assert_eq;
278    /// # use serde::Serialize;
279    /// # use quick_xml::events::{BytesStart, Event};
280    /// # use quick_xml::writer::Writer;
281    /// # use quick_xml::DeError;
282    /// # fn main() -> Result<(), DeError> {
283    /// #[derive(Debug, PartialEq, Serialize)]
284    /// struct MyData {
285    ///     question: String,
286    ///     answer: u32,
287    /// }
288    ///
289    /// let data = MyData {
290    ///     question: "The Ultimate Question of Life, the Universe, and Everything".into(),
291    ///     answer: 42,
292    /// };
293    ///
294    /// let mut buffer = Vec::new();
295    /// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
296    ///
297    /// let start = BytesStart::new("root");
298    /// let end = start.to_end();
299    ///
300    /// writer.write_event(Event::Start(start.clone()))?;
301    /// writer.write_serializable("my_data", &data)?;
302    /// writer.write_event(Event::End(end))?;
303    ///
304    /// assert_eq!(
305    ///     std::str::from_utf8(&buffer)?,
306    ///     r#"<root>
307    ///     <my_data>
308    ///         <question>The Ultimate Question of Life, the Universe, and Everything</question>
309    ///         <answer>42</answer>
310    ///     </my_data>
311    /// </root>"#
312    /// );
313    /// # Ok(())
314    /// # }
315    /// ```
316    #[cfg(feature = "serialize")]
317    pub fn write_serializable<T: Serialize>(
318        &mut self,
319        tag_name: &str,
320        content: &T,
321    ) -> std::result::Result<(), DeError> {
322        use crate::se::{Indent, Serializer};
323
324        self.write_indent()?;
325        let mut fmt = ToFmtWrite(&mut self.writer);
326        let mut serializer = Serializer::with_root(&mut fmt, Some(tag_name))?;
327
328        if let Some(indent) = &mut self.indent {
329            serializer.set_indent(Indent::Borrow(indent));
330        }
331
332        content.serialize(serializer)?;
333
334        Ok(())
335    }
336}
337
338/// A struct to write an element. Contains methods to add attributes and inner
339/// elements to the element
340pub struct ElementWriter<'a, W> {
341    writer: &'a mut Writer<W>,
342    start_tag: BytesStart<'a>,
343}
344
345impl<'a, W> ElementWriter<'a, W> {
346    /// Adds an attribute to this element.
347    pub fn with_attribute<'b, I>(mut self, attr: I) -> Self
348    where
349        I: Into<Attribute<'b>>,
350    {
351        self.start_tag.push_attribute(attr);
352        self
353    }
354
355    /// Add additional attributes to this element using an iterator.
356    ///
357    /// The yielded items must be convertible to [`Attribute`] using `Into`.
358    pub fn with_attributes<'b, I>(mut self, attributes: I) -> Self
359    where
360        I: IntoIterator,
361        I::Item: Into<Attribute<'b>>,
362    {
363        self.start_tag.extend_attributes(attributes);
364        self
365    }
366}
367
368impl<'a, W: Write> ElementWriter<'a, W> {
369    /// Write some text inside the current element.
370    pub fn write_text_content(self, text: BytesText) -> Result<&'a mut Writer<W>> {
371        self.writer
372            .write_event(Event::Start(self.start_tag.borrow()))?;
373        self.writer.write_event(Event::Text(text))?;
374        self.writer
375            .write_event(Event::End(self.start_tag.to_end()))?;
376        Ok(self.writer)
377    }
378
379    /// Write a CData event `<![CDATA[...]]>` inside the current element.
380    pub fn write_cdata_content(self, text: BytesCData) -> Result<&'a mut Writer<W>> {
381        self.writer
382            .write_event(Event::Start(self.start_tag.borrow()))?;
383        self.writer.write_event(Event::CData(text))?;
384        self.writer
385            .write_event(Event::End(self.start_tag.to_end()))?;
386        Ok(self.writer)
387    }
388
389    /// Write a processing instruction `<?...?>` inside the current element.
390    pub fn write_pi_content(self, text: BytesText) -> Result<&'a mut Writer<W>> {
391        self.writer
392            .write_event(Event::Start(self.start_tag.borrow()))?;
393        self.writer.write_event(Event::PI(text))?;
394        self.writer
395            .write_event(Event::End(self.start_tag.to_end()))?;
396        Ok(self.writer)
397    }
398
399    /// Write an empty (self-closing) tag.
400    pub fn write_empty(self) -> Result<&'a mut Writer<W>> {
401        self.writer.write_event(Event::Empty(self.start_tag))?;
402        Ok(self.writer)
403    }
404
405    /// Create a new scope for writing XML inside the current element.
406    pub fn write_inner_content<F, E>(self, closure: F) -> StdResult<&'a mut Writer<W>, E>
407    where
408        F: FnOnce(&mut Writer<W>) -> StdResult<(), E>,
409        E: From<Error>,
410    {
411        self.writer
412            .write_event(Event::Start(self.start_tag.borrow()))?;
413        closure(self.writer)?;
414        self.writer
415            .write_event(Event::End(self.start_tag.to_end()))?;
416        Ok(self.writer)
417    }
418}
419#[cfg(feature = "serialize")]
420struct ToFmtWrite<T>(pub T);
421
422#[cfg(feature = "serialize")]
423impl<T> std::fmt::Write for ToFmtWrite<T>
424where
425    T: std::io::Write,
426{
427    fn write_str(&mut self, s: &str) -> std::fmt::Result {
428        self.0.write_all(s.as_bytes()).map_err(|_| std::fmt::Error)
429    }
430}
431
432#[derive(Clone)]
433pub(crate) struct Indentation {
434    /// todo: this is an awkward fit as it has no impact on indentation logic, but it is
435    /// only applicable when an indentation exists. Potentially refactor later
436    should_line_break: bool,
437    /// The character code to be used for indentations (e.g. ` ` or `\t`)
438    indent_char: u8,
439    /// How many instances of the indent character ought to be used for each level of indentation
440    indent_size: usize,
441    /// Used as a cache for the bytes used for indentation
442    indents: Vec<u8>,
443    /// The current amount of indentation
444    current_indent_len: usize,
445}
446
447impl Indentation {
448    pub fn new(indent_char: u8, indent_size: usize) -> Self {
449        Self {
450            should_line_break: false,
451            indent_char,
452            indent_size,
453            indents: vec![indent_char; 128],
454            current_indent_len: 0, // invariant - needs to remain less than indents.len()
455        }
456    }
457
458    /// Increase indentation by one level
459    pub fn grow(&mut self) {
460        self.current_indent_len += self.indent_size;
461        if self.current_indent_len > self.indents.len() {
462            self.indents
463                .resize(self.current_indent_len, self.indent_char);
464        }
465    }
466
467    /// Decrease indentation by one level. Do nothing, if level already zero
468    pub fn shrink(&mut self) {
469        self.current_indent_len = self.current_indent_len.saturating_sub(self.indent_size);
470    }
471
472    /// Returns indent string for current level
473    pub fn current(&self) -> &[u8] {
474        &self.indents[..self.current_indent_len]
475    }
476}
477
478#[cfg(test)]
479mod indentation {
480    use super::*;
481    use crate::events::*;
482    use pretty_assertions::assert_eq;
483
484    #[test]
485    fn self_closed() {
486        let mut buffer = Vec::new();
487        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
488
489        let tag = BytesStart::new("self-closed")
490            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
491        writer
492            .write_event(Event::Empty(tag))
493            .expect("write tag failed");
494
495        assert_eq!(
496            std::str::from_utf8(&buffer).unwrap(),
497            r#"<self-closed attr1="value1" attr2="value2"/>"#
498        );
499    }
500
501    #[test]
502    fn empty_paired() {
503        let mut buffer = Vec::new();
504        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
505
506        let start = BytesStart::new("paired")
507            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
508        let end = start.to_end();
509        writer
510            .write_event(Event::Start(start.clone()))
511            .expect("write start tag failed");
512        writer
513            .write_event(Event::End(end))
514            .expect("write end tag failed");
515
516        assert_eq!(
517            std::str::from_utf8(&buffer).unwrap(),
518            r#"<paired attr1="value1" attr2="value2">
519</paired>"#
520        );
521    }
522
523    #[test]
524    fn paired_with_inner() {
525        let mut buffer = Vec::new();
526        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
527
528        let start = BytesStart::new("paired")
529            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
530        let end = start.to_end();
531        let inner = BytesStart::new("inner");
532
533        writer
534            .write_event(Event::Start(start.clone()))
535            .expect("write start tag failed");
536        writer
537            .write_event(Event::Empty(inner))
538            .expect("write inner tag failed");
539        writer
540            .write_event(Event::End(end))
541            .expect("write end tag failed");
542
543        assert_eq!(
544            std::str::from_utf8(&buffer).unwrap(),
545            r#"<paired attr1="value1" attr2="value2">
546    <inner/>
547</paired>"#
548        );
549    }
550
551    #[test]
552    fn paired_with_text() {
553        let mut buffer = Vec::new();
554        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
555
556        let start = BytesStart::new("paired")
557            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
558        let end = start.to_end();
559        let text = BytesText::new("text");
560
561        writer
562            .write_event(Event::Start(start.clone()))
563            .expect("write start tag failed");
564        writer
565            .write_event(Event::Text(text))
566            .expect("write text failed");
567        writer
568            .write_event(Event::End(end))
569            .expect("write end tag failed");
570
571        assert_eq!(
572            std::str::from_utf8(&buffer).unwrap(),
573            r#"<paired attr1="value1" attr2="value2">text</paired>"#
574        );
575    }
576
577    #[test]
578    fn mixed_content() {
579        let mut buffer = Vec::new();
580        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
581
582        let start = BytesStart::new("paired")
583            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
584        let end = start.to_end();
585        let text = BytesText::new("text");
586        let inner = BytesStart::new("inner");
587
588        writer
589            .write_event(Event::Start(start.clone()))
590            .expect("write start tag failed");
591        writer
592            .write_event(Event::Text(text))
593            .expect("write text failed");
594        writer
595            .write_event(Event::Empty(inner))
596            .expect("write inner tag failed");
597        writer
598            .write_event(Event::End(end))
599            .expect("write end tag failed");
600
601        assert_eq!(
602            std::str::from_utf8(&buffer).unwrap(),
603            r#"<paired attr1="value1" attr2="value2">text<inner/>
604</paired>"#
605        );
606    }
607
608    #[test]
609    fn nested() {
610        let mut buffer = Vec::new();
611        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
612
613        let start = BytesStart::new("paired")
614            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
615        let end = start.to_end();
616        let inner = BytesStart::new("inner");
617
618        writer
619            .write_event(Event::Start(start.clone()))
620            .expect("write start 1 tag failed");
621        writer
622            .write_event(Event::Start(start.clone()))
623            .expect("write start 2 tag failed");
624        writer
625            .write_event(Event::Empty(inner))
626            .expect("write inner tag failed");
627        writer
628            .write_event(Event::End(end.clone()))
629            .expect("write end tag 2 failed");
630        writer
631            .write_event(Event::End(end))
632            .expect("write end tag 1 failed");
633
634        assert_eq!(
635            std::str::from_utf8(&buffer).unwrap(),
636            r#"<paired attr1="value1" attr2="value2">
637    <paired attr1="value1" attr2="value2">
638        <inner/>
639    </paired>
640</paired>"#
641        );
642    }
643
644    #[cfg(feature = "serialize")]
645    #[test]
646    fn serializable() {
647        #[derive(Serialize)]
648        struct Foo {
649            #[serde(rename = "@attribute")]
650            attribute: &'static str,
651
652            element: Bar,
653            list: Vec<&'static str>,
654
655            #[serde(rename = "$text")]
656            text: &'static str,
657
658            val: String,
659        }
660
661        #[derive(Serialize)]
662        struct Bar {
663            baz: usize,
664            bat: usize,
665        }
666
667        let mut buffer = Vec::new();
668        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
669
670        let content = Foo {
671            attribute: "attribute",
672            element: Bar { baz: 42, bat: 43 },
673            list: vec!["first element", "second element"],
674            text: "text",
675            val: "foo".to_owned(),
676        };
677
678        let start = BytesStart::new("paired")
679            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
680        let end = start.to_end();
681
682        writer
683            .write_event(Event::Start(start.clone()))
684            .expect("write start tag failed");
685        writer
686            .write_serializable("foo_element", &content)
687            .expect("write serializable inner contents failed");
688        writer
689            .write_event(Event::End(end))
690            .expect("write end tag failed");
691
692        assert_eq!(
693            std::str::from_utf8(&buffer).unwrap(),
694            r#"<paired attr1="value1" attr2="value2">
695    <foo_element attribute="attribute">
696        <element>
697            <baz>42</baz>
698            <bat>43</bat>
699        </element>
700        <list>first element</list>
701        <list>second element</list>
702        text
703        <val>foo</val>
704    </foo_element>
705</paired>"#
706        );
707    }
708
709    #[test]
710    fn element_writer_empty() {
711        let mut buffer = Vec::new();
712        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
713
714        writer
715            .create_element("empty")
716            .with_attribute(("attr1", "value1"))
717            .with_attribute(("attr2", "value2"))
718            .write_empty()
719            .expect("failure");
720
721        assert_eq!(
722            std::str::from_utf8(&buffer).unwrap(),
723            r#"<empty attr1="value1" attr2="value2"/>"#
724        );
725    }
726
727    #[test]
728    fn element_writer_text() {
729        let mut buffer = Vec::new();
730        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
731
732        writer
733            .create_element("paired")
734            .with_attribute(("attr1", "value1"))
735            .with_attribute(("attr2", "value2"))
736            .write_text_content(BytesText::new("text"))
737            .expect("failure");
738
739        assert_eq!(
740            std::str::from_utf8(&buffer).unwrap(),
741            r#"<paired attr1="value1" attr2="value2">text</paired>"#
742        );
743    }
744
745    #[test]
746    fn element_writer_nested() {
747        let mut buffer = Vec::new();
748        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
749
750        writer
751            .create_element("outer")
752            .with_attribute(("attr1", "value1"))
753            .with_attribute(("attr2", "value2"))
754            .write_inner_content::<_, Error>(|writer| {
755                let fruits = ["apple", "orange", "banana"];
756                for (quant, item) in fruits.iter().enumerate() {
757                    writer
758                        .create_element("fruit")
759                        .with_attribute(("quantity", quant.to_string().as_str()))
760                        .write_text_content(BytesText::new(item))?;
761                }
762                writer
763                    .create_element("inner")
764                    .write_inner_content(|writer| {
765                        writer.create_element("empty").write_empty().map(|_| ())
766                    })?;
767
768                Ok(())
769            })
770            .expect("failure");
771
772        assert_eq!(
773            std::str::from_utf8(&buffer).unwrap(),
774            r#"<outer attr1="value1" attr2="value2">
775    <fruit quantity="0">apple</fruit>
776    <fruit quantity="1">orange</fruit>
777    <fruit quantity="2">banana</fruit>
778    <inner>
779        <empty/>
780    </inner>
781</outer>"#
782        );
783    }
784}
quick_xml/writer.rs

quick_xml/
writer.rs
