🎨

rustfmt.toml

@@ -1 +0,0 @@
-match_block_trailing_comma = true

src/de/buffer.rs

@@ -1,5 +1,5 @@
-use crate::error::Result;
 use crate::debug_expect;
+use crate::error::Result;
 use std::{collections::VecDeque, io::Read};
 use xml::reader::{EventReader, XmlEvent};
 
@@ -86,21 +86,21 @@ impl<'parent, R: Read> BufferedXmlReader<R> for ChildXmlBuffer<'parent, R> {
                     };
 
                     return debug_expect!(taken, CachedXmlEvent::Unused(ev) => Ok(ev));
-                },
+                }
                 Some(CachedXmlEvent::Used) => {
                     debug_assert!(
                         self.cursor != 0,
                         "Event buffer should not start with 'used' slot (should have been popped)"
                     );
                     self.cursor += 1;
                     continue;
-                },
+                }
                 None => {
                     debug_assert_eq!(self.buffer.len(), self.cursor);
 
                     // Skip creation of buffer entry when consuming event straight away
                     return next_significant_event(&mut self.reader);
-                },
+                }
             }
         }
     }
@@ -143,11 +143,11 @@ fn get_from_buffer_or_reader<'buf>(
             Some(CachedXmlEvent::Unused(_)) => break,
             Some(CachedXmlEvent::Used) => {
                 *index += 1;
-            },
+            }
             None => {
                 let next = next_significant_event(reader)?;
                 buffer.push_back(CachedXmlEvent::Unused(next));
-            },
+            }
         }
     }
 
@@ -162,7 +162,7 @@ fn next_significant_event(reader: &mut EventReader<impl Read>) -> Result<XmlEven
             XmlEvent::StartDocument { .. }
             | XmlEvent::ProcessingInstruction { .. }
             | XmlEvent::Whitespace { .. }
-            | XmlEvent::Comment(_) => { /* skip */ },
+            | XmlEvent::Comment(_) => { /* skip */ }
             other => return Ok(other),
         }
     }

src/de/map.rs

@@ -1,7 +1,7 @@
 use std::io::Read;
 
-use serde::forward_to_deserialize_any;
 use serde::de::{self, IntoDeserializer, Unexpected};
+use serde::forward_to_deserialize_any;
 use xml::attribute::OwnedAttribute;
 use xml::reader::XmlEvent;
 
@@ -46,7 +46,7 @@ impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::MapAccess<'de> for MapA
                 self.next_attr_value = Some(value);
                 seed.deserialize(name.local_name.into_deserializer())
                     .map(Some)
-            },
+            }
             None => match *self.de.peek()? {
                 XmlEvent::StartElement { ref name, .. } => seed
                     .deserialize(
@@ -77,7 +77,7 @@ impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::MapAccess<'de> for MapA
                 }
                 let result = seed.deserialize(&mut *self.de)?;
                 Ok(result)
-            },
+            }
         }
     }
 

src/de/mod.rs

@@ -1,17 +1,17 @@
 use std::{io::Read, marker::PhantomData};
 
-use serde::forward_to_deserialize_any;
-use serde::de::{self, Unexpected};
 use log::debug;
+use serde::de::{self, Unexpected};
+use serde::forward_to_deserialize_any;
 use xml::name::OwnedName;
 use xml::reader::{EventReader, ParserConfig, XmlEvent};
 
 use self::buffer::{BufferedXmlReader, ChildXmlBuffer, RootXmlBuffer};
 use self::map::MapAccess;
 use self::seq::SeqAccess;
 use self::var::EnumAccess;
-use crate::{debug_expect, expect};
 use crate::error::{Error, Result};
+use crate::{debug_expect, expect};
 
 mod buffer;
 mod map;
@@ -175,11 +175,11 @@ impl<'de, R: Read, B: BufferedXmlReader<R>> Deserializer<R, B> {
         match next {
             XmlEvent::StartElement { .. } => {
                 self.depth += 1;
-            },
+            }
             XmlEvent::EndElement { .. } => {
                 self.depth -= 1;
-            },
-            _ => {},
+            }
+            _ => {}
         }
         debug!("Fetched {:?}", next);
         Ok(next)

src/de/seq.rs

@@ -3,8 +3,8 @@ use std::io::Read;
 use serde::de;
 use xml::reader::XmlEvent;
 
-use crate::debug_expect;
 use crate::de::ChildDeserializer;
+use crate::debug_expect;
 use crate::error::{Error, Result};
 
 pub struct SeqAccess<'a, R: Read> {
@@ -53,11 +53,11 @@ impl<'de, 'a, R: 'a + Read> de::SeqAccess<'de> for SeqAccess<'a, R> {
         match self.max_size.as_mut() {
             Some(&mut 0) => {
                 return Ok(None);
-            },
+            }
             Some(max_size) => {
                 *max_size -= 1;
-            },
-            None => {},
+            }
+            None => {}
         }
 
         match &self.seq_type {
@@ -84,34 +84,34 @@ impl<'de, 'a, R: 'a + Read> de::SeqAccess<'de> for SeqAccess<'a, R> {
                             } else {
                                 return Ok(None);
                             }
-                        },
+                        }
                         XmlEvent::EndElement { .. } => {
                             if local_depth == 0 {
                                 return Ok(None);
                             } else {
                                 local_depth -= 1;
                                 self.de.buffered_reader.skip();
                             }
-                        },
+                        }
                         XmlEvent::EndDocument => {
                             return Ok(None);
-                        },
+                        }
                         _ => {
                             self.de.buffered_reader.skip();
-                        },
+                        }
                     }
                 }
-            },
+            }
             SeqType::AllMembers => {
                 let next_element = self.de.peek()?;
 
                 match next_element {
                     XmlEvent::EndElement { .. } | XmlEvent::EndDocument => return Ok(None),
                     _ => {
                         return seed.deserialize(&mut self.de).map(Some);
-                    },
+                    }
                 }
-            },
+            }
         }
     }
 

src/de/var.rs

@@ -4,9 +4,9 @@ use serde::de::{self, Deserializer as SerdeDeserializer, IntoDeserializer};
 use xml::name::OwnedName;
 use xml::reader::XmlEvent;
 
-use crate::expect;
 use crate::de::Deserializer;
 use crate::error::{Error, Result};
+use crate::expect;
 
 use super::buffer::BufferedXmlReader;
 
@@ -67,7 +67,7 @@ impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::VariantAccess<'de>
                 } else {
                     Err(de::Error::invalid_length(attributes.len(), &"0"))
                 }
-            },
+            }
             XmlEvent::Characters(_) => Ok(()),
             _ => unreachable!(),
         }

src/lib.rs

@@ -32,8 +32,8 @@
 //! }
 //! ```
 
-mod error;
 pub mod de;
+mod error;
 pub mod ser;
 
 pub use crate::de::{from_reader, from_str, Deserializer};

tests/failures.rs

@@ -1,7 +1,7 @@
+use log::info;
+use serde_derive::Deserialize;
 use serde_xml_rs::from_str;
 use simple_logger::SimpleLogger;
-use serde_derive::Deserialize;
-use log::info;
 
 fn init_logger() {
     let _ = SimpleLogger::new().init();
@@ -27,7 +27,7 @@ fn simple_struct_from_attributes_should_fail() {
         Err(e) => {
             info!("simple_struct_from_attributes_should_fail(): {}", e);
             assert!(true)
-        },
+        }
     }
 }
 
@@ -46,6 +46,6 @@ fn multiple_roots_attributes_should_fail() {
         Err(e) => {
             info!("multiple_roots_attributes_should_fail(): {}", e);
             assert!(true)
-        },
+        }
     }
 }

tests/migrated.rs

@@ -2,7 +2,7 @@ use simple_logger::SimpleLogger;
 use std::fmt::Debug;
 
 use serde::{de, ser};
-use serde_derive::{Serialize, Deserialize};
+use serde_derive::{Deserialize, Serialize};
 use serde_xml_rs::{from_str, Error};
 
 fn init_logger() {

tests/round_trip.rs

@@ -1,5 +1,5 @@
 use serde::Deserialize;
-use serde_derive::{Serialize, Deserialize};
+use serde_derive::{Deserialize, Serialize};
 use serde_xml_rs::{self, from_str, to_string, EventReader, ParserConfig};
 
 #[derive(Debug, Serialize, Deserialize, PartialEq)]