Remove no longer used indent field from SimpleTypeSerializer

src/de/simple_type.rs

@@ -791,7 +791,7 @@ impl<'de, 'a> EnumAccess<'de> for SimpleTypeDeserializer<'de, 'a> {
 mod tests {
     use super::*;
     use crate::se::simple_type::{QuoteTarget, SimpleTypeSerializer};
-    use crate::se::{Indent, QuoteLevel};
+    use crate::se::QuoteLevel;
     use crate::utils::{ByteBuf, Bytes};
     use serde::de::IgnoredAny;
     use serde::{Deserialize, Serialize};
@@ -828,7 +828,6 @@ mod tests {
                         writer: String::new(),
                         target: QuoteTarget::Text,
                         level: QuoteLevel::Full,
-                        indent: Indent::None,
                     })
                     .unwrap(),
                     xml
@@ -943,7 +942,7 @@ mod tests {
                             writer: &mut buffer,
                             target: QuoteTarget::Text,
                             level: QuoteLevel::Full,
-                            indent: Some(Indent::None),
+                            write_delimiter: false,
                         })
                         .unwrap();
                     assert_eq!(buffer, $input);

src/se/content.rs

@@ -82,13 +82,12 @@ pub struct ContentSerializer<'w, 'i, W: Write> {
 impl<'w, 'i, W: Write> ContentSerializer<'w, 'i, W> {
     /// Turns this serializer into serializer of a text content
     #[inline]
-    pub fn into_simple_type_serializer(self) -> SimpleTypeSerializer<'i, &'w mut W> {
+    pub fn into_simple_type_serializer(self) -> SimpleTypeSerializer<&'w mut W> {
         //TODO: Customization point: choose between CDATA and Text representation
         SimpleTypeSerializer {
             writer: self.writer,
             target: QuoteTarget::Text,
             level: self.level,
-            indent: Indent::None,
         }
     }
 
@@ -127,7 +126,7 @@ impl<'w, 'i, W: Write> ContentSerializer<'w, 'i, W> {
     /// Writes simple type content between `name` tags
     pub(super) fn write_wrapped<S>(mut self, name: XmlName, serialize: S) -> Result<bool, SeError>
     where
-        S: for<'a> FnOnce(SimpleTypeSerializer<'i, &'a mut W>) -> Result<&'a mut W, SeError>,
+        S: for<'a> FnOnce(SimpleTypeSerializer<&'a mut W>) -> Result<&'a mut W, SeError>,
     {
         self.write_indent()?;
         self.writer.write_char('<')?;

src/se/element.rs

@@ -5,7 +5,7 @@ use crate::se::content::ContentSerializer;
 use crate::se::key::QNameSerializer;
 use crate::se::simple_type::{QuoteTarget, SimpleSeq, SimpleTypeSerializer};
 use crate::se::text::TextSerializer;
-use crate::se::{Indent, SeError, XmlName};
+use crate::se::{SeError, XmlName};
 use serde::ser::{
     Impossible, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
     SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, Serializer,
@@ -335,7 +335,7 @@ pub enum Tuple<'w, 'k, W: Write> {
     /// Serialize each tuple field as an element
     Element(ElementSerializer<'w, 'k, W>),
     /// Serialize tuple as an `xs:list`: space-delimited content of fields
-    Text(SimpleSeq<'k, &'w mut W>),
+    Text(SimpleSeq<&'w mut W>),
 }
 
 impl<'w, 'k, W: Write> SerializeTupleVariant for Tuple<'w, 'k, W> {
@@ -419,7 +419,6 @@ impl<'w, 'k, W: Write> Struct<'w, 'k, W> {
             writer: &mut self.ser.ser.writer,
             target: QuoteTarget::DoubleQAttr,
             level: self.ser.ser.level,
-            indent: Indent::None,
         })?;
         self.ser.ser.writer.write_char('"')?;
 

src/se/simple_type.rs

@@ -4,7 +4,7 @@
 //! [as defined]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
 
 use crate::escape::_escape;
-use crate::se::{Indent, QuoteLevel, SeError};
+use crate::se::{QuoteLevel, SeError};
 use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
     SerializeTupleVariant, Serializer,
@@ -179,30 +179,26 @@ macro_rules! write_atomic {
 ///
 /// [item]: https://www.w3.org/TR/xmlschema11-1/#std-item_type_definition
 /// [simple type]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
-pub struct AtomicSerializer<'i, W: Write> {
+pub struct AtomicSerializer<W: Write> {
     pub writer: W,
     pub target: QuoteTarget,
     /// Defines which XML characters need to be escaped
     pub level: QuoteLevel,
-    /// When `Some`, the indent that should be written before the content
-    /// if content is not an empty string.
-    /// When `None` an `xs:list` delimiter (a space) should be written
-    pub(crate) indent: Option<Indent<'i>>,
+    /// When `true` an `xs:list` delimiter (a space) should be written
+    pub(crate) write_delimiter: bool,
 }
 
-impl<'i, W: Write> AtomicSerializer<'i, W> {
+impl<W: Write> AtomicSerializer<W> {
     fn write_str(&mut self, value: &str) -> Result<(), SeError> {
-        if let Some(indent) = self.indent.as_mut() {
-            indent.write_indent(&mut self.writer)?;
-        } else {
+        if self.write_delimiter {
             // TODO: Customization point -- possible non-XML compatible extension to specify delimiter char
             self.writer.write_char(' ')?;
         }
         Ok(self.writer.write_str(value)?)
     }
 }
 
-impl<'i, W: Write> Serializer for AtomicSerializer<'i, W> {
+impl<W: Write> Serializer for AtomicSerializer<W> {
     type Ok = bool;
     type Error = SeError;
 
@@ -401,31 +397,28 @@ impl<'i, W: Write> Serializer for AtomicSerializer<'i, W> {
 /// - CDATA content (`<...><![CDATA[cdata]]></...>`)
 ///
 /// [simple types]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
-pub struct SimpleTypeSerializer<'i, W: Write> {
+pub struct SimpleTypeSerializer<W: Write> {
     /// Writer to which this serializer writes content
     pub writer: W,
     /// Target for which element is serializing. Affects additional characters to escape.
     pub target: QuoteTarget,
     /// Defines which XML characters need to be escaped
     pub level: QuoteLevel,
-    /// Indent that should be written before the content if content is not an empty string
-    pub(crate) indent: Indent<'i>,
 }
 
-impl<'i, W: Write> SimpleTypeSerializer<'i, W> {
+impl<W: Write> SimpleTypeSerializer<W> {
     fn write_str(&mut self, value: &str) -> Result<(), SeError> {
-        self.indent.write_indent(&mut self.writer)?;
         Ok(self.writer.write_str(value)?)
     }
 }
 
-impl<'i, W: Write> Serializer for SimpleTypeSerializer<'i, W> {
+impl<W: Write> Serializer for SimpleTypeSerializer<W> {
     type Ok = W;
     type Error = SeError;
 
-    type SerializeSeq = SimpleSeq<'i, W>;
-    type SerializeTuple = SimpleSeq<'i, W>;
-    type SerializeTupleStruct = SimpleSeq<'i, W>;
+    type SerializeSeq = SimpleSeq<W>;
+    type SerializeTuple = SimpleSeq<W>;
+    type SerializeTupleStruct = SimpleSeq<W>;
     type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
     type SerializeMap = Impossible<Self::Ok, Self::Error>;
     type SerializeStruct = Impossible<Self::Ok, Self::Error>;
@@ -470,7 +463,6 @@ impl<'i, W: Write> Serializer for SimpleTypeSerializer<'i, W> {
             writer: self.writer,
             target: self.target,
             level: self.level,
-            indent: self.indent,
             is_empty: true,
         })
     }
@@ -535,35 +527,27 @@ impl<'i, W: Write> Serializer for SimpleTypeSerializer<'i, W> {
 }
 
 /// Serializer for a sequence of atomic values delimited by space
-pub struct SimpleSeq<'i, W: Write> {
+pub struct SimpleSeq<W: Write> {
     writer: W,
     target: QuoteTarget,
     level: QuoteLevel,
-    /// Indent that should be written before the content if content is not an empty string
-    indent: Indent<'i>,
     /// If `true`, nothing was written yet to the `writer`
     is_empty: bool,
 }
 
-impl<'i, W: Write> SerializeSeq for SimpleSeq<'i, W> {
+impl<W: Write> SerializeSeq for SimpleSeq<W> {
     type Ok = W;
     type Error = SeError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: ?Sized + Serialize,
     {
-        // Write indent for the first element and delimiter for others
-        let indent = if self.is_empty {
-            Some(self.indent.borrow())
-        } else {
-            None
-        };
         if value.serialize(AtomicSerializer {
             writer: &mut self.writer,
             target: self.target,
             level: self.level,
-            indent,
+            write_delimiter: !self.is_empty,
         })? {
             self.is_empty = false;
         }
@@ -576,7 +560,7 @@ impl<'i, W: Write> SerializeSeq for SimpleSeq<'i, W> {
     }
 }
 
-impl<'i, W: Write> SerializeTuple for SimpleSeq<'i, W> {
+impl<W: Write> SerializeTuple for SimpleSeq<W> {
     type Ok = W;
     type Error = SeError;
 
@@ -594,7 +578,7 @@ impl<'i, W: Write> SerializeTuple for SimpleSeq<'i, W> {
     }
 }
 
-impl<'i, W: Write> SerializeTupleStruct for SimpleSeq<'i, W> {
+impl<W: Write> SerializeTupleStruct for SimpleSeq<W> {
     type Ok = W;
     type Error = SeError;
 
@@ -612,7 +596,7 @@ impl<'i, W: Write> SerializeTupleStruct for SimpleSeq<'i, W> {
     }
 }
 
-impl<'i, W: Write> SerializeTupleVariant for SimpleSeq<'i, W> {
+impl<W: Write> SerializeTupleVariant for SimpleSeq<W> {
     type Ok = W;
     type Error = SeError;
 
@@ -928,7 +912,7 @@ mod tests {
                         writer: &mut buffer,
                         target: QuoteTarget::Text,
                         level: QuoteLevel::Full,
-                        indent: Some(Indent::None),
+                        write_delimiter: false,
                     };
 
                     let has_written = $data.serialize(ser).unwrap();
@@ -949,7 +933,7 @@ mod tests {
                         writer: &mut buffer,
                         target: QuoteTarget::Text,
                         level: QuoteLevel::Full,
-                        indent: Some(Indent::None),
+                        write_delimiter: false,
                     };
 
                     match $data.serialize(ser).unwrap_err() {
@@ -1047,7 +1031,6 @@ mod tests {
                         writer: String::new(),
                         target: QuoteTarget::Text,
                         level: QuoteLevel::Full,
-                        indent: Indent::None,
                     };
 
                     let buffer = $data.serialize(ser).unwrap();
@@ -1067,7 +1050,6 @@ mod tests {
                         writer: &mut buffer,
                         target: QuoteTarget::Text,
                         level: QuoteLevel::Full,
-                        indent: Indent::None,
                     };
 
                     match $data.serialize(ser).unwrap_err() {
@@ -1153,19 +1135,15 @@ mod tests {
 
     mod simple_seq {
         use super::*;
-        use crate::writer::Indentation;
         use pretty_assertions::assert_eq;
 
         #[test]
         fn empty_seq() {
             let mut buffer = String::new();
-            let mut indent = Indentation::new(b'*', 2);
-            indent.grow();
             let ser = SimpleSeq {
                 writer: &mut buffer,
                 target: QuoteTarget::Text,
                 level: QuoteLevel::Full,
-                indent: Indent::Owned(indent),
                 is_empty: true,
             };
 
@@ -1176,13 +1154,10 @@ mod tests {
         #[test]
         fn all_items_empty() {
             let mut buffer = String::new();
-            let mut indent = Indentation::new(b'*', 2);
-            indent.grow();
             let mut ser = SimpleSeq {
                 writer: &mut buffer,
                 target: QuoteTarget::Text,
                 level: QuoteLevel::Full,
-                indent: Indent::Owned(indent),
                 is_empty: true,
             };
 
@@ -1196,61 +1171,52 @@ mod tests {
         #[test]
         fn some_items_empty1() {
             let mut buffer = String::new();
-            let mut indent = Indentation::new(b'*', 2);
-            indent.grow();
             let mut ser = SimpleSeq {
                 writer: &mut buffer,
                 target: QuoteTarget::Text,
                 level: QuoteLevel::Full,
-                indent: Indent::Owned(indent),
                 is_empty: true,
             };
 
             SerializeSeq::serialize_element(&mut ser, "").unwrap();
             SerializeSeq::serialize_element(&mut ser, &1).unwrap();
             SerializeSeq::serialize_element(&mut ser, "").unwrap();
             SerializeSeq::end(ser).unwrap();
-            assert_eq!(buffer, "\n**1");
+            assert_eq!(buffer, "1");
         }
 
         #[test]
         fn some_items_empty2() {
             let mut buffer = String::new();
-            let mut indent = Indentation::new(b'*', 2);
-            indent.grow();
             let mut ser = SimpleSeq {
                 writer: &mut buffer,
                 target: QuoteTarget::Text,
                 level: QuoteLevel::Full,
-                indent: Indent::Owned(indent),
                 is_empty: true,
             };
 
             SerializeSeq::serialize_element(&mut ser, &1).unwrap();
             SerializeSeq::serialize_element(&mut ser, "").unwrap();
             SerializeSeq::serialize_element(&mut ser, &2).unwrap();
             SerializeSeq::end(ser).unwrap();
-            assert_eq!(buffer, "\n**1 2");
+            assert_eq!(buffer, "1 2");
         }
 
         #[test]
         fn items() {
             let mut buffer = String::new();
-            let mut indent = Indentation::new(b'*', 2);
-            indent.grow();
             let mut ser = SimpleSeq {
                 writer: &mut buffer,
                 target: QuoteTarget::Text,
                 level: QuoteLevel::Full,
-                indent: Indent::Owned(indent),
                 is_empty: true,
             };
 
             SerializeSeq::serialize_element(&mut ser, &1).unwrap();
             SerializeSeq::serialize_element(&mut ser, &2).unwrap();
             SerializeSeq::serialize_element(&mut ser, &3).unwrap();
             SerializeSeq::end(ser).unwrap();
-            assert_eq!(buffer, "\n**1 2 3");
+            assert_eq!(buffer, "1 2 3");
         }
     }
 }

src/se/text.rs

@@ -23,16 +23,16 @@ macro_rules! write_primitive {
 /// This serializer a very similar to [`SimpleTypeSerializer`], but different
 /// from it in how it processes unit enum variants. Unlike [`SimpleTypeSerializer`]
 /// this serializer does not write anything for the unit variant.
-pub struct TextSerializer<'i, W: Write>(pub SimpleTypeSerializer<'i, W>);
+pub struct TextSerializer<W: Write>(pub SimpleTypeSerializer<W>);
 
-impl<'i, W: Write> Serializer for TextSerializer<'i, W> {
+impl<W: Write> Serializer for TextSerializer<W> {
     type Ok = W;
     type Error = SeError;
 
-    type SerializeSeq = SimpleSeq<'i, W>;
-    type SerializeTuple = SimpleSeq<'i, W>;
-    type SerializeTupleStruct = SimpleSeq<'i, W>;
-    type SerializeTupleVariant = SimpleSeq<'i, W>;
+    type SerializeSeq = SimpleSeq<W>;
+    type SerializeTuple = SimpleSeq<W>;
+    type SerializeTupleStruct = SimpleSeq<W>;
+    type SerializeTupleVariant = SimpleSeq<W>;
     type SerializeMap = Impossible<Self::Ok, Self::Error>;
     type SerializeStruct = Impossible<Self::Ok, Self::Error>;
     type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;