clippy warnings

src/header/shared/entity.rs

@@ -57,10 +57,7 @@ impl EntityTag {
     /// If the tag contains invalid characters.
     pub fn new(weak: bool, tag: String) -> EntityTag {
         assert!(check_slice_validity(&tag), "Invalid tag: {:?}", tag);
-        EntityTag {
-            weak,
-            tag,
-        }
+        EntityTag { weak, tag }
     }
 
     /// Constructs a new weak EntityTag.
@@ -199,7 +196,11 @@ mod tests {
     fn test_etag_parse_failures() {
         // Expected failures
         assert!("no-dquotes".parse::<EntityTag>().is_err());
-        assert!("w/\"the-first-w-is-case-sensitive\"".parse::<EntityTag>().is_err());
+        assert!(
+            "w/\"the-first-w-is-case-sensitive\""
+                .parse::<EntityTag>()
+                .is_err()
+        );
         assert!("".parse::<EntityTag>().is_err());
         assert!("\"unmatched-dquotes1".parse::<EntityTag>().is_err());
         assert!("unmatched-dquotes2\"".parse::<EntityTag>().is_err());
@@ -208,14 +209,26 @@ mod tests {
 
     #[test]
     fn test_etag_fmt() {
-        assert_eq!(format!("{}", EntityTag::strong("foobar".to_owned())), "\"foobar\"");
-        assert_eq!(format!("{}", EntityTag::strong("".to_owned())), "\"\"");
+        assert_eq!(
+            format!("{}", EntityTag::strong("foobar".to_owned())),
+            "\"foobar\""
+        );
+        assert_eq!(
+            format!("{}", EntityTag::strong("".to_owned())),
+            "\"\""
+        );
         assert_eq!(
             format!("{}", EntityTag::weak("weak-etag".to_owned())),
             "W/\"weak-etag\""
         );
-        assert_eq!(format!("{}", EntityTag::weak("\u{0065}".to_owned())), "W/\"\x65\"");
-        assert_eq!(format!("{}", EntityTag::weak("".to_owned())), "W/\"\"");
+        assert_eq!(
+            format!("{}", EntityTag::weak("\u{0065}".to_owned())),
+            "W/\"\x65\""
+        );
+        assert_eq!(
+            format!("{}", EntityTag::weak("".to_owned())),
+            "W/\"\""
+        );
     }
 
     #[test]

src/header/shared/httpdate.rs

@@ -64,7 +64,11 @@ impl IntoHeaderValue for HttpDate {
     fn try_into(self) -> Result<HeaderValue, Self::Error> {
         let mut wrt = BytesMut::with_capacity(29).writer();
         write!(wrt, "{}", self.0.rfc822()).unwrap();
-        unsafe { Ok(HeaderValue::from_shared_unchecked(wrt.get_mut().take().freeze())) }
+        unsafe {
+            Ok(HeaderValue::from_shared_unchecked(
+                wrt.get_mut().take().freeze(),
+            ))
+        }
     }
 }
 
@@ -100,12 +104,24 @@ mod tests {
 
     #[test]
     fn test_date() {
-        assert_eq!("Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
         assert_eq!(
-            "Sunday, 07-Nov-94 08:48:37 GMT".parse::<HttpDate>().unwrap(),
+            "Sun, 07 Nov 1994 08:48:37 GMT"
+                .parse::<HttpDate>()
+                .unwrap(),
+            NOV_07
+        );
+        assert_eq!(
+            "Sunday, 07-Nov-94 08:48:37 GMT"
+                .parse::<HttpDate>()
+                .unwrap(),
+            NOV_07
+        );
+        assert_eq!(
+            "Sun Nov  7 08:48:37 1994"
+                .parse::<HttpDate>()
+                .unwrap(),
             NOV_07
         );
-        assert_eq!("Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(), NOV_07);
         assert!("this-is-no-date".parse::<HttpDate>().is_err());
     }
 }

src/header/shared/quality_item.rs

@@ -47,10 +47,7 @@ impl<T> QualityItem<T> {
     /// The item can be of any type.
     /// The quality should be a value in the range [0, 1].
     pub fn new(item: T, quality: Quality) -> QualityItem<T> {
-        QualityItem {
-            item,
-            quality,
-        }
+        QualityItem { item, quality }
     }
 }
 
@@ -66,7 +63,11 @@ impl<T: fmt::Display> fmt::Display for QualityItem<T> {
         match self.quality.0 {
             1000 => Ok(()),
             0 => f.write_str("; q=0"),
-            x => write!(f, "; q=0.{}", format!("{:03}", x).trim_right_matches('0')),
+            x => write!(
+                f,
+                "; q=0.{}",
+                format!("{:03}", x).trim_right_matches('0')
+            ),
         }
     }
 }
@@ -119,7 +120,10 @@ fn from_f32(f: f32) -> Quality {
     // this function is only used internally. A check that `f` is within range
     // should be done before calling this method. Just in case, this
     // debug_assert should catch if we were forgetful
-    debug_assert!(f >= 0f32 && f <= 1f32, "q value must be between 0.0 and 1.0");
+    debug_assert!(
+        f >= 0f32 && f <= 1f32,
+        "q value must be between 0.0 and 1.0"
+    );
     Quality((f * 1000f32) as u16)
 }
 
@@ -152,7 +156,10 @@ mod internal {
 
     impl IntoQuality for f32 {
         fn into_quality(self) -> Quality {
-            assert!(self >= 0f32 && self <= 1f32, "float must be between 0.0 and 1.0");
+            assert!(
+                self >= 0f32 && self <= 1f32,
+                "float must be between 0.0 and 1.0"
+            );
             super::from_f32(self)
         }
     }
@@ -288,6 +295,10 @@ mod tests {
     #[test]
     fn test_fuzzing_bugs() {
         assert!("99999;".parse::<QualityItem<String>>().is_err());
-        assert!("\x0d;;;=\u{d6aa}==".parse::<QualityItem<String>>().is_err())
+        assert!(
+            "\x0d;;;=\u{d6aa}=="
+                .parse::<QualityItem<String>>()
+                .is_err()
+        )
     }
 }