Merge pull request #89 from webern/minor-updates

minor updates

Author: webern

Cargo.lock

@@ -91,7 +91,7 @@ impl Display for OtherError {
         self.throw_site.fmt(f)?;
         if let Some(msg) = &self.message {
             if !msg.is_empty() {
-                write!(f, " - {}", msg)?;
+                write!(f, " - {msg}")?;
             }
         }
         if let Some(e) = &self.source {

src/error.rs

@@ -149,7 +149,7 @@ fn parse_cdata(iter: &mut Iter<'_>) -> Result<String> {
 fn parse_bang_cdata_1() {
     let data = "foo";
     let iter_char_after = 'b';
-    let input = format!("<![CDATA[{}]]>bar", data);
+    let input = format!("<![CDATA[{data}]]>bar");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -161,7 +161,7 @@ fn parse_bang_cdata_1() {
 fn parse_bang_cdata_2() {
     let data = "foo]] >bar]>]>x";
     let iter_char_after = 'x';
-    let input = format!("<![CDATA[{}]]>x", data);
+    let input = format!("<![CDATA[{data}]]>x");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -173,7 +173,7 @@ fn parse_bang_cdata_2() {
 fn parse_bang_cdata_3() {
     let data = "foo]]>bar]>]>x";
     let iter_char_after = 'b';
-    let input = format!("<![CDATA[{}]]>x", data);
+    let input = format!("<![CDATA[{data}]]>x");
     let expected = LtParse::Some(Node::CData("foo".into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -185,7 +185,7 @@ fn parse_bang_cdata_3() {
 fn parse_bang_cdata_4() {
     let data = "<xml>bloop</xml>";
     let iter_char_after = '<';
-    let input = format!("<![CDATA[{}]]><foo></foo>", data);
+    let input = format!("<![CDATA[{data}]]><foo></foo>");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -197,7 +197,7 @@ fn parse_bang_cdata_4() {
 fn parse_bang_cdata_5() {
     let data = "<![CDATA[";
     let iter_char_after = '<';
-    let input = format!("<![CDATA[{}]]><foo></foo>", data);
+    let input = format!("<![CDATA[{data}]]><foo></foo>");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -209,7 +209,7 @@ fn parse_bang_cdata_5() {
 fn parse_bang_cdata_6() {
     let data = "<&]>]";
     let iter_char_after = 'b';
-    let input = format!("<![CDATA[{}]]>bar", data);
+    let input = format!("<![CDATA[{data}]]>bar");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -221,7 +221,7 @@ fn parse_bang_cdata_6() {
 fn parse_bang_cdata_7() {
     let data = "]";
     let iter_char_after = 'b';
-    let input = format!("<![CDATA[{}]]>bar", data);
+    let input = format!("<![CDATA[{data}]]>bar");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -233,7 +233,7 @@ fn parse_bang_cdata_7() {
 fn parse_bang_cdata_8() {
     let data = "]]";
     let iter_char_after = 'b';
-    let input = format!("<![CDATA[{}]]>bar", data);
+    let input = format!("<![CDATA[{data}]]>bar");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();
@@ -245,7 +245,7 @@ fn parse_bang_cdata_8() {
 fn parse_bang_cdata_9() {
     let data = "]]]";
     let iter_char_after = 'b';
-    let input = format!("<![CDATA[{}]]>bar", data);
+    let input = format!("<![CDATA[{data}]]>bar");
     let expected = LtParse::Some(Node::CData(data.into()));
     let mut iter = Iter::new(&input).unwrap();
     let actual = parse_bang(&mut iter).unwrap();

src/parser/bang.rs

@@ -44,7 +44,7 @@ pub(super) fn display_char(c: char) -> String {
         '\u{000B}' => "\\u000B".into(),
         '\u{000C}' => "\\u000C".into(),
         ' ' => "%20".into(),
-        _ => format!("{}", c),
+        _ => format!("{c}"),
     }
 }
 
@@ -81,7 +81,7 @@ impl Display for ParseError {
         }
         if let Some(msg) = &self.message {
             if !msg.is_empty() {
-                write!(f, " - {}", msg)?;
+                write!(f, " - {msg}")?;
             }
         }
         if let Some(e) = &self.source {

src/parser/error.rs

@@ -397,7 +397,7 @@ fn test_parse_string_bad_amp_or_apos_err() {
 #[test]
 fn test_parse_string_quotes_inside_1() {
     let want = r#"attr val with something 'quoted' inside"#;
-    let terminated = format!("{}\"", want);
+    let terminated = format!("{want}\"");
     use crate::parser::Iter;
     let mut iter = Iter::new(terminated.as_str()).unwrap();
     let got = parse_string(&mut iter, StringType::AttributeDouble).unwrap();
@@ -407,7 +407,7 @@ fn test_parse_string_quotes_inside_1() {
 #[test]
 fn test_parse_string_quotes_inside_2() {
     let want = r#"attr val with something "quoted" inside"#;
-    let terminated = format!("{}'", want);
+    let terminated = format!("{want}'");
     use crate::parser::Iter;
     let mut iter = Iter::new(terminated.as_str()).unwrap();
     let got = parse_string(&mut iter, StringType::AttributeSingle).unwrap();

src/parser/string.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::default::Default;
+use std::fmt::{Display, Formatter};
 use std::io::{Cursor, Write};
 use std::path::Path;
 
@@ -281,13 +282,13 @@ impl Document {
     }
 }
 
-impl ToString for Document {
-    fn to_string(&self) -> String {
+impl Display for Document {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let opts = WriteOpts::default();
-        match self.to_string_opts(&opts) {
-            Ok(s) => s,
-            Err(_) => "<error/>".to_string(),
-        }
+        let s = self
+            .to_string_opts(&opts)
+            .unwrap_or_else(|_| "<error/>".to_string());
+        write!(f, "{s}")
     }
 }
 

src/xdoc/doc.rs

@@ -32,7 +32,7 @@ impl Display for Element {
             .map_err(|_| std::fmt::Error)?;
         let bytes = cursor.into_inner();
         let s = String::from_utf8_lossy(bytes.as_slice());
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 

src/xdoc/element.rs

@@ -79,10 +79,7 @@ impl Index {
 
     /// Gets the parent of the given `element`.
     pub fn parent(&self, element: &Element) -> Option<&Element> {
-        let child_index = match self.index(element) {
-            Some(ix) => ix,
-            None => return None,
-        };
+        let child_index = self.index(element)?;
 
         self.parent_index(child_index)
             .and_then(|parent_index| self.element(parent_index))

src/xdoc/index.rs

@@ -17,9 +17,7 @@ pub use index::Index;
 pub(crate) use name::Name;
 pub use node::{Misc, Node};
 pub use pi::Pi;
-pub use write_ops::{Newline, WriteOpts};
-
-pub use crate::xdoc::error::Result;
+pub use write_ops::WriteOpts;
 
 #[macro_use]
 mod macros;

src/xdoc/mod.rs

@@ -152,7 +152,7 @@ mod tests {
         a.mut_map().insert("4".to_string(), String::new());
         let entries = a.map().keys();
         for (i, item) in entries.enumerate() {
-            assert_eq!(format!("{}", i), item.to_owned());
+            assert_eq!(format!("{i}"), item.to_owned());
         }
     }