Various Clippy fixes

src/find/matchers/delete.rs

@@ -18,12 +18,12 @@ use super::{Matcher, MatcherIO};
 pub struct DeleteMatcher;
 
 impl DeleteMatcher {
-    pub fn new() -> DeleteMatcher {
+    pub fn new() -> Self {
         DeleteMatcher
     }
 
     pub fn new_box() -> io::Result<Box<dyn Matcher>> {
-        Ok(Box::new(DeleteMatcher::new()))
+        Ok(Box::new(Self::new()))
     }
 
     fn delete(&self, file_path: &Path, file_type: FileType) -> io::Result<()> {

src/find/matchers/exec.rs

@@ -29,7 +29,7 @@ impl SingleExecMatcher {
         executable: &str,
         args: &[&str],
         exec_in_parent_dir: bool,
-    ) -> Result<SingleExecMatcher, Box<dyn Error>> {
+    ) -> Result<Self, Box<dyn Error>> {
         let transformed_args = args
             .iter()
             .map(|&a| match a {
@@ -38,7 +38,7 @@ impl SingleExecMatcher {
             })
             .collect();
 
-        Ok(SingleExecMatcher {
+        Ok(Self {
             executable: executable.to_string(),
             args: transformed_args,
             exec_in_parent_dir,
@@ -50,11 +50,7 @@ impl SingleExecMatcher {
         args: &[&str],
         exec_in_parent_dir: bool,
     ) -> Result<Box<dyn Matcher>, Box<dyn Error>> {
-        Ok(Box::new(SingleExecMatcher::new(
-            executable,
-            args,
-            exec_in_parent_dir,
-        )?))
+        Ok(Box::new(Self::new(executable, args, exec_in_parent_dir)?))
     }
 }
 

src/find/matchers/logical_matchers.rs

@@ -25,8 +25,8 @@ pub struct AndMatcher {
 }
 
 impl AndMatcher {
-    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> AndMatcher {
-        AndMatcher { submatchers }
+    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> Self {
+        Self { submatchers }
     }
 }
 
@@ -62,8 +62,8 @@ pub struct AndMatcherBuilder {
 }
 
 impl AndMatcherBuilder {
-    pub fn new() -> AndMatcherBuilder {
-        AndMatcherBuilder {
+    pub fn new() -> Self {
+        Self {
             submatchers: Vec::new(),
         }
     }
@@ -94,8 +94,8 @@ pub struct OrMatcher {
 }
 
 impl OrMatcher {
-    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> OrMatcher {
-        OrMatcher { submatchers }
+    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> Self {
+        Self { submatchers }
     }
 }
 
@@ -151,8 +151,8 @@ impl OrMatcherBuilder {
         Ok(())
     }
 
-    pub fn new() -> OrMatcherBuilder {
-        let mut o = OrMatcherBuilder {
+    pub fn new() -> Self {
+        let mut o = Self {
             submatchers: Vec::new(),
         };
         o.submatchers.push(AndMatcherBuilder::new());
@@ -184,8 +184,8 @@ pub struct ListMatcher {
 }
 
 impl ListMatcher {
-    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> ListMatcher {
-        ListMatcher { submatchers }
+    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> Self {
+        Self { submatchers }
     }
 }
 
@@ -265,8 +265,8 @@ impl ListMatcherBuilder {
         Ok(())
     }
 
-    pub fn new() -> ListMatcherBuilder {
-        let mut o = ListMatcherBuilder {
+    pub fn new() -> Self {
+        let mut o = Self {
             submatchers: Vec::new(),
         };
         o.submatchers.push(OrMatcherBuilder::new());
@@ -293,7 +293,7 @@ pub struct TrueMatcher;
 
 impl TrueMatcher {
     pub fn new_box() -> Box<dyn Matcher> {
-        Box::new(TrueMatcher {})
+        Box::new(Self {})
     }
 }
 
@@ -314,7 +314,7 @@ impl Matcher for FalseMatcher {
 
 impl FalseMatcher {
     pub fn new_box() -> Box<dyn Matcher> {
-        Box::new(FalseMatcher {})
+        Box::new(Self {})
     }
 }
 
@@ -324,12 +324,12 @@ pub struct NotMatcher {
 }
 
 impl NotMatcher {
-    pub fn new(submatcher: Box<dyn Matcher>) -> NotMatcher {
-        NotMatcher { submatcher }
+    pub fn new(submatcher: Box<dyn Matcher>) -> Self {
+        Self { submatcher }
     }
 
-    pub fn new_box(submatcher: Box<dyn Matcher>) -> Box<NotMatcher> {
-        Box::new(NotMatcher::new(submatcher))
+    pub fn new_box(submatcher: Box<dyn Matcher>) -> Box<Self> {
+        Box::new(Self::new(submatcher))
     }
 }
 
@@ -375,7 +375,7 @@ mod tests {
 
     impl HasSideEffects {
         pub fn new_box() -> Box<dyn Matcher> {
-            Box::new(HasSideEffects {})
+            Box::new(Self {})
         }
     }
 

src/find/matchers/name.rs

@@ -185,7 +185,7 @@ mod tests {
         create_file_link();
 
         let link_f = get_dir_entry_for("test_data/links", "link-f");
-        let matcher = NameMatcher::new(&"link?f", false).unwrap();
+        let matcher = NameMatcher::new("link?f", false).unwrap();
         let deps = FakeDependencies::new();
         assert!(matcher.matches(&link_f, &mut deps.new_matcher_io()));
     }
@@ -195,7 +195,7 @@ mod tests {
         create_file_link();
 
         let link_f = get_dir_entry_for("test_data/links", "link-f");
-        let matcher = NameMatcher::new(&"ab?bc", true).unwrap();
+        let matcher = NameMatcher::new("ab?bc", true).unwrap();
         let deps = FakeDependencies::new();
         assert!(matcher.matches(&link_f, &mut deps.new_matcher_io()));
     }
@@ -235,7 +235,7 @@ mod tests {
         create_file_link();
 
         let link_f = get_dir_entry_for("test_data/links", "link-f");
-        let matcher = CaselessNameMatcher::new(&"linK?f", false).unwrap();
+        let matcher = CaselessNameMatcher::new("linK?f", false).unwrap();
         let deps = FakeDependencies::new();
         assert!(matcher.matches(&link_f, &mut deps.new_matcher_io()));
     }
@@ -245,7 +245,7 @@ mod tests {
         create_file_link();
 
         let link_f = get_dir_entry_for("test_data/links", "link-f");
-        let matcher = CaselessNameMatcher::new(&"AbB?c", true).unwrap();
+        let matcher = CaselessNameMatcher::new("AbB?c", true).unwrap();
         let deps = FakeDependencies::new();
         assert!(matcher.matches(&link_f, &mut deps.new_matcher_io()));
     }

src/find/matchers/perm.rs

@@ -31,11 +31,11 @@ pub enum ComparisonType {
 #[cfg(unix)]
 impl FromStr for ComparisonType {
     type Err = Box<dyn Error>;
-    fn from_str(s: &str) -> Result<ComparisonType, Box<dyn Error>> {
+    fn from_str(s: &str) -> Result<Self, Box<dyn Error>> {
         Ok(match s {
-            "" => ComparisonType::Exact,
-            "-" => ComparisonType::AtLeast,
-            "/" => ComparisonType::AnyOf,
+            "" => Self::Exact,
+            "-" => Self::AtLeast,
+            "/" => Self::AnyOf,
             _ => {
                 return Err(From::from(format!(
                     "Invalid prefix {} for -perm. Only allowed \
@@ -270,9 +270,9 @@ pub struct PermMatcher {}
 
 impl PermMatcher {
     #[cfg(unix)]
-    pub fn new(pattern: &str) -> Result<PermMatcher, Box<dyn Error>> {
+    pub fn new(pattern: &str) -> Result<Self, Box<dyn Error>> {
         let (bit_pattern, comparison_type) = parsing::parse(pattern)?;
-        Ok(PermMatcher {
+        Ok(Self {
             pattern: bit_pattern,
             comparison_type,
         })
@@ -286,7 +286,7 @@ impl PermMatcher {
     }
 
     pub fn new_box(pattern: &str) -> Result<Box<dyn Matcher>, Box<dyn Error>> {
-        Ok(Box::new(PermMatcher::new(pattern)?))
+        Ok(Box::new(Self::new(pattern)?))
     }
 }
 

src/find/matchers/printer.rs

@@ -28,12 +28,12 @@ pub struct Printer {
 }
 
 impl Printer {
-    pub fn new(delimiter: PrintDelimiter) -> Printer {
-        Printer { delimiter }
+    pub fn new(delimiter: PrintDelimiter) -> Self {
+        Self { delimiter }
     }
 
     pub fn new_box(delimiter: PrintDelimiter) -> Box<dyn Matcher> {
-        Box::new(Printer::new(delimiter))
+        Box::new(Self::new(delimiter))
     }
 }
 

src/find/matchers/printf.rs

@@ -334,7 +334,7 @@ struct FormatString {
 }
 
 impl FormatString {
-    fn parse(string: &str) -> Result<FormatString, Box<dyn Error>> {
+    fn parse(string: &str) -> Result<Self, Box<dyn Error>> {
         FormatStringParser { string }.parse()
     }
 }
@@ -600,14 +600,14 @@ pub struct Printf {
 }
 
 impl Printf {
-    pub fn new(format: &str) -> Result<Printf, Box<dyn Error>> {
-        Ok(Printf {
+    pub fn new(format: &str) -> Result<Self, Box<dyn Error>> {
+        Ok(Self {
             format: FormatString::parse(format)?,
         })
     }
 
     pub fn new_box(format: &str) -> Result<Box<dyn Matcher>, Box<dyn Error>> {
-        Ok(Box::new(Printf::new(format)?))
+        Ok(Box::new(Self::new(format)?))
     }
 }
 

src/find/matchers/prune.rs

@@ -12,12 +12,12 @@ use super::{Matcher, MatcherIO};
 pub struct PruneMatcher;
 
 impl PruneMatcher {
-    pub fn new() -> PruneMatcher {
-        PruneMatcher {}
+    pub fn new() -> Self {
+        Self {}
     }
 
     pub fn new_box() -> Box<dyn Matcher> {
-        Box::new(PruneMatcher::new())
+        Box::new(Self::new())
     }
 }
 

src/find/matchers/regex.rs

@@ -39,11 +39,11 @@ pub enum RegexType {
 }
 
 impl RegexType {
-    pub const VALUES: &'static [RegexType] = &[
-        RegexType::Emacs,
-        RegexType::Grep,
-        RegexType::PosixBasic,
-        RegexType::PosixExtended,
+    pub const VALUES: &'static [Self] = &[
+        Self::Emacs,
+        Self::Grep,
+        Self::PosixBasic,
+        Self::PosixExtended,
     ];
 }
 
@@ -63,18 +63,18 @@ impl FromStr for RegexType {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "emacs" => Ok(RegexType::Emacs),
-            "grep" => Ok(RegexType::Grep),
-            "posix-basic" => Ok(RegexType::PosixBasic),
-            "posix-extended" => Ok(RegexType::PosixExtended),
+            "emacs" => Ok(Self::Emacs),
+            "grep" => Ok(Self::Grep),
+            "posix-basic" => Ok(Self::PosixBasic),
+            "posix-extended" => Ok(Self::PosixExtended),
             _ => Err(ParseRegexTypeError(s.to_owned())),
         }
     }
 }
 
 impl Default for RegexType {
     fn default() -> Self {
-        RegexType::Emacs
+        Self::Emacs
     }
 }
 
@@ -87,7 +87,7 @@ impl RegexMatcher {
         regex_type: RegexType,
         pattern: &str,
         ignore_case: bool,
-    ) -> Result<RegexMatcher, Box<dyn Error>> {
+    ) -> Result<Self, Box<dyn Error>> {
         let syntax = match regex_type {
             RegexType::Emacs => Syntax::emacs(),
             RegexType::Grep => Syntax::grep(),
@@ -104,19 +104,15 @@ impl RegexMatcher {
             },
             syntax,
         )?;
-        Ok(RegexMatcher { regex })
+        Ok(Self { regex })
     }
 
     pub fn new_box(
         regex_type: RegexType,
         pattern: &str,
         ignore_case: bool,
     ) -> Result<Box<dyn Matcher>, Box<dyn Error>> {
-        Ok(Box::new(RegexMatcher::new(
-            regex_type,
-            pattern,
-            ignore_case,
-        )?))
+        Ok(Box::new(Self::new(regex_type, pattern, ignore_case)?))
     }
 }