Apply some (pedantic) clippy lints

atezet · spenserblack · commit 58a06a44c764 · 2024-10-10T08:46:55.000-04:00
diff --git a/examples/control.rs b/examples/control.rs
@@ -4,7 +4,7 @@ use colored::*;
 
 #[cfg(not(windows))]
 fn main() {
-    both()
+    both();
 }
 
 #[cfg(windows)]
diff --git a/src/color.rs b/src/color.rs
@@ -85,11 +85,11 @@ impl Color {
     }
 
     /// Gets the closest plain color to the TrueColor
-    fn closest_color_euclidean(&self) -> Self {
+    fn closest_color_euclidean(self) -> Self {
         use std::cmp;
         use Color::*;
 
-        match *self {
+        match self {
             TrueColor {
                 r: r1,
                 g: g1,
@@ -332,13 +332,13 @@ mod tests {
         #[test]
         fn parse() {
             let color: Result<Color, _> = "blue".parse();
-            assert_eq!(Ok(Color::Blue), color)
+            assert_eq!(Ok(Color::Blue), color);
         }
 
         #[test]
         fn error() {
             let color: Result<Color, ()> = "bloublou".parse();
-            assert_eq!(Err(()), color)
+            assert_eq!(Err(()), color);
         }
     }
 
diff --git a/src/control.rs b/src/control.rs
@@ -69,13 +69,13 @@ pub struct ShouldColorize {
 /// Use this to force colored to ignore the environment and always/never colorize
 /// See example/control.rs
 pub fn set_override(override_colorize: bool) {
-    SHOULD_COLORIZE.set_override(override_colorize)
+    SHOULD_COLORIZE.set_override(override_colorize);
 }
 
 /// Remove the manual override and let the environment decide if it's ok to colorize
 /// See example/control.rs
 pub fn unset_override() {
-    SHOULD_COLORIZE.unset_override()
+    SHOULD_COLORIZE.unset_override();
 }
 
 lazy_static! {
@@ -177,7 +177,7 @@ mod specs {
                     assert_eq!(
                         None,
                         ShouldColorize::normalize_env(Err(env::VarError::NotUnicode("".into())))
-                    )
+                    );
                 });
 
                 ctx.it("should return Some(true) if != 0", |_| {
@@ -281,19 +281,19 @@ mod specs {
                         clicolor: false,
                         ..ShouldColorize::default()
                     };
-                    false == colorize_control.should_colorize()
+                    !colorize_control.should_colorize()
                 });
 
                 ctx.it("clicolor == true means colors !", |_| {
                     let colorize_control = ShouldColorize {
                         clicolor: true,
                         ..ShouldColorize::default()
                     };
-                    true == colorize_control.should_colorize()
+                    colorize_control.should_colorize()
                 });
 
                 ctx.it("unset clicolors implies true", |_| {
-                    true == ShouldColorize::default().should_colorize()
+                    ShouldColorize::default().should_colorize()
                 });
             });
 
@@ -307,7 +307,7 @@ mod specs {
                             ..ShouldColorize::default()
                         };
 
-                        true == colorize_control.should_colorize()
+                        colorize_control.should_colorize()
                     },
                 );
 
@@ -320,7 +320,7 @@ mod specs {
                             ..ShouldColorize::default()
                         };
 
-                        false == colorize_control.should_colorize()
+                        !colorize_control.should_colorize()
                     },
                 );
             });
@@ -332,10 +332,9 @@ mod specs {
                         clicolor_force: None,
                         has_manual_override: AtomicBool::new(true),
                         manual_override: AtomicBool::new(true),
-                        .. ShouldColorize::default()
                     };
 
-                    true == colorize_control.should_colorize()
+                    colorize_control.should_colorize();
                 });
 
                 ctx.it("should not colorize if manual_override is false, but clicolor is true or clicolor_force is true", |_| {
@@ -344,11 +343,10 @@ mod specs {
                         clicolor_force: Some(true),
                         has_manual_override: AtomicBool::new(true),
                         manual_override: AtomicBool::new(false),
-                        .. ShouldColorize::default()
                     };
 
-                    false == colorize_control.should_colorize()
-                })
+                    !colorize_control.should_colorize()
+                });
             });
 
             ctx.specify("::set_override", |ctx| {
@@ -361,21 +359,15 @@ mod specs {
                     let colorize_control = ShouldColorize::default();
                     colorize_control.set_override(true);
                     {
-                        assert_eq!(
-                            true,
-                            colorize_control.has_manual_override.load(Ordering::Relaxed)
-                        );
+                        assert!(colorize_control.has_manual_override.load(Ordering::Relaxed));
                         let val = colorize_control.manual_override.load(Ordering::Relaxed);
-                        assert_eq!(true, val);
+                        assert!(val);
                     }
                     colorize_control.set_override(false);
                     {
-                        assert_eq!(
-                            true,
-                            colorize_control.has_manual_override.load(Ordering::Relaxed)
-                        );
+                        assert!(colorize_control.has_manual_override.load(Ordering::Relaxed));
                         let val = colorize_control.manual_override.load(Ordering::Relaxed);
-                        assert_eq!(false, val);
+                        assert!(!val);
                     }
                 });
             });
@@ -390,10 +382,7 @@ mod specs {
                     let colorize_control = ShouldColorize::default();
                     colorize_control.set_override(true);
                     colorize_control.unset_override();
-                    assert_eq!(
-                        false,
-                        colorize_control.has_manual_override.load(Ordering::Relaxed)
-                    );
+                    assert!(!colorize_control.has_manual_override.load(Ordering::Relaxed));
                 });
             });
         }));
diff --git a/src/lib.rs b/src/lib.rs
@@ -490,17 +490,17 @@ impl ColoredString {
     }
 
     #[cfg(not(feature = "no-color"))]
-    fn has_colors(&self) -> bool {
+    fn has_colors() -> bool {
         control::SHOULD_COLORIZE.should_colorize()
     }
 
     #[cfg(feature = "no-color")]
-    fn has_colors(&self) -> bool {
+    fn has_colors() -> bool {
         false
     }
 
     fn compute_style(&self) -> String {
-        if !self.has_colors() || self.is_plain() {
+        if !ColoredString::has_colors() || self.is_plain() {
             return String::new();
         }
 
@@ -534,7 +534,7 @@ impl ColoredString {
     }
 
     fn escape_inner_reset_sequences(&self) -> Cow<str> {
-        if !self.has_colors() || self.is_plain() {
+        if !ColoredString::has_colors() || self.is_plain() {
             return self.input.as_str().into();
         }
 
@@ -713,7 +713,7 @@ impl<'a> Colorize for &'a str {
 
 impl fmt::Display for ColoredString {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if !self.has_colors() || self.is_plain() {
+        if !ColoredString::has_colors() || self.is_plain() {
             return <String as fmt::Display>::fmt(&self.input, f);
         }
 
@@ -944,22 +944,22 @@ mod tests {
 
     #[test]
     fn color_fn() {
-        assert_eq!("blue".blue(), "blue".color("blue"))
+        assert_eq!("blue".blue(), "blue".color("blue"));
     }
 
     #[test]
     fn on_color_fn() {
-        assert_eq!("blue".on_blue(), "blue".on_color("blue"))
+        assert_eq!("blue".on_blue(), "blue".on_color("blue"));
     }
 
     #[test]
     fn bright_color_fn() {
-        assert_eq!("blue".bright_blue(), "blue".color("bright blue"))
+        assert_eq!("blue".bright_blue(), "blue".color("bright blue"));
     }
 
     #[test]
     fn on_bright_color_fn() {
-        assert_eq!("blue".on_bright_blue(), "blue".on_color("bright blue"))
+        assert_eq!("blue".on_bright_blue(), "blue".on_color("bright blue"));
     }
 
     #[test]
@@ -981,8 +981,8 @@ mod tests {
         let cstring = cstring.bold().italic();
         assert_eq!(cstring.fgcolor(), Some(Color::Blue));
         assert_eq!(cstring.bgcolor(), Some(Color::BrightYellow));
-        assert_eq!(cstring.style().contains(Styles::Bold), true);
-        assert_eq!(cstring.style().contains(Styles::Italic), true);
-        assert_eq!(cstring.style().contains(Styles::Dimmed), false);
+        assert!(cstring.style().contains(Styles::Bold));
+        assert!(cstring.style().contains(Styles::Italic));
+        assert!(!cstring.style().contains(Styles::Dimmed));
     }
 }
diff --git a/src/style.rs b/src/style.rs
@@ -563,7 +563,7 @@ mod tests {
 
         #[test]
         fn empty_is_none() {
-            assert_eq!(None, Styles::from_u8(CLEARV))
+            assert_eq!(None, Styles::from_u8(CLEARV));
         }
     }
 
@@ -632,19 +632,19 @@ mod tests {
         #[test]
         fn aggreg1() {
             let styles: &[Styles] = &[Bold, Bold, Bold];
-            test_aggreg!(styles, [Bold])
+            test_aggreg!(styles, [Bold]);
         }
 
         #[test]
         fn aggreg2() {
             let styles: &[Styles] = &[Italic, Italic, Bold, Bold];
-            test_aggreg!(styles, [Bold, Italic])
+            test_aggreg!(styles, [Bold, Italic]);
         }
 
         #[test]
         fn aggreg3() {
             let styles: &[Styles] = &[Bold, Italic, Bold];
-            test_aggreg!(styles, [Bold, Italic])
+            test_aggreg!(styles, [Bold, Italic]);
         }
 
         macro_rules! test_combine {
@@ -658,49 +658,49 @@ mod tests {
         #[test]
         fn two1() {
             let s: &[Styles] = &[Bold, Underline];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn two2() {
             let s: &[Styles] = &[Underline, Italic];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn two3() {
             let s: &[Styles] = &[Bold, Italic];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn three1() {
             let s: &[Styles] = &[Bold, Underline, Italic];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn three2() {
             let s: &[Styles] = &[Dimmed, Underline, Italic];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn four() {
             let s: &[Styles] = &[Dimmed, Underline, Italic, Hidden];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn five() {
             let s: &[Styles] = &[Dimmed, Underline, Italic, Blink, Hidden];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
         fn six() {
             let s: &[Styles] = &[Bold, Dimmed, Underline, Italic, Blink, Hidden];
-            test_combine!(s)
+            test_combine!(s);
         }
 
         #[test]
@@ -715,7 +715,7 @@ mod tests {
                 Hidden,
                 Strikethrough,
             ];
-            test_combine!(s)
+            test_combine!(s);
         }
     }
 
@@ -724,9 +724,9 @@ mod tests {
         let mut style = Style(Styles::Bold.to_u8());
         style.add(Styles::Italic);
 
-        assert_eq!(style.contains(Styles::Bold), true);
-        assert_eq!(style.contains(Styles::Italic), true);
-        assert_eq!(style.contains(Styles::Dimmed), false);
+        assert!(style.contains(Styles::Bold));
+        assert!(style.contains(Styles::Italic));
+        assert!(!style.contains(Styles::Dimmed));
     }
 
     mod style_bitwise_logic {

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ use colored::*;`
`4`	`4`
`5`	`5`	`#[cfg(not(windows))]`
`6`	`6`	`fn main() {`
`7`		`- both()`
	`7`	`+ both();`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`#[cfg(windows)]`
Original file line number	Diff line number	Diff line change
`@@ -490,17 +490,17 @@ impl ColoredString {`
`490`	`490`	`}`
`491`	`491`
`492`	`492`	`#[cfg(not(feature = "no-color"))]`
`493`		`- fn has_colors(&self) -> bool {`
	`493`	`+ fn has_colors() -> bool {`
`494`	`494`	`control::SHOULD_COLORIZE.should_colorize()`
`495`	`495`	`}`
`496`	`496`
`497`	`497`	`#[cfg(feature = "no-color")]`
`498`		`- fn has_colors(&self) -> bool {`
	`498`	`+ fn has_colors() -> bool {`
`499`	`499`	`false`
`500`	`500`	`}`
`501`	`501`
`502`	`502`	`fn compute_style(&self) -> String {`
`503`		`- if !self.has_colors() \|\| self.is_plain() {`
	`503`	`+ if !ColoredString::has_colors() \|\| self.is_plain() {`
`504`	`504`	`return String::new();`
`505`	`505`	`}`
`506`	`506`
`@@ -534,7 +534,7 @@ impl ColoredString {`
`534`	`534`	`}`
`535`	`535`
`536`	`536`	`fn escape_inner_reset_sequences(&self) -> Cow<str> {`
`537`		`- if !self.has_colors() \|\| self.is_plain() {`
	`537`	`+ if !ColoredString::has_colors() \|\| self.is_plain() {`
`538`	`538`	`return self.input.as_str().into();`
`539`	`539`	`}`
`540`	`540`
`@@ -713,7 +713,7 @@ impl<'a> Colorize for &'a str {`
`713`	`713`
`714`	`714`	`impl fmt::Display for ColoredString {`
`715`	`715`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`716`		`- if !self.has_colors() \|\| self.is_plain() {`
	`716`	`+ if !ColoredString::has_colors() \|\| self.is_plain() {`
`717`	`717`	`return <String as fmt::Display>::fmt(&self.input, f);`
`718`	`718`	`}`
`719`	`719`
`@@ -944,22 +944,22 @@ mod tests {`
`944`	`944`
`945`	`945`	`#[test]`
`946`	`946`	`fn color_fn() {`
`947`		`- assert_eq!("blue".blue(), "blue".color("blue"))`
	`947`	`+ assert_eq!("blue".blue(), "blue".color("blue"));`
`948`	`948`	`}`
`949`	`949`
`950`	`950`	`#[test]`
`951`	`951`	`fn on_color_fn() {`
`952`		`- assert_eq!("blue".on_blue(), "blue".on_color("blue"))`
	`952`	`+ assert_eq!("blue".on_blue(), "blue".on_color("blue"));`
`953`	`953`	`}`
`954`	`954`
`955`	`955`	`#[test]`
`956`	`956`	`fn bright_color_fn() {`
`957`		`- assert_eq!("blue".bright_blue(), "blue".color("bright blue"))`
	`957`	`+ assert_eq!("blue".bright_blue(), "blue".color("bright blue"));`
`958`	`958`	`}`
`959`	`959`
`960`	`960`	`#[test]`
`961`	`961`	`fn on_bright_color_fn() {`
`962`		`- assert_eq!("blue".on_bright_blue(), "blue".on_color("bright blue"))`
	`962`	`+ assert_eq!("blue".on_bright_blue(), "blue".on_color("bright blue"));`
`963`	`963`	`}`
`964`	`964`
`965`	`965`	`#[test]`
`@@ -981,8 +981,8 @@ mod tests {`
`981`	`981`	`let cstring = cstring.bold().italic();`
`982`	`982`	`assert_eq!(cstring.fgcolor(), Some(Color::Blue));`
`983`	`983`	`assert_eq!(cstring.bgcolor(), Some(Color::BrightYellow));`
`984`		`- assert_eq!(cstring.style().contains(Styles::Bold), true);`
`985`		`- assert_eq!(cstring.style().contains(Styles::Italic), true);`
`986`		`- assert_eq!(cstring.style().contains(Styles::Dimmed), false);`
	`984`	`+ assert!(cstring.style().contains(Styles::Bold));`
	`985`	`+ assert!(cstring.style().contains(Styles::Italic));`
	`986`	`+ assert!(!cstring.style().contains(Styles::Dimmed));`
`987`	`987`	`}`
`988`	`988`	`}`