Clippy Pendantic

src/uu/chgrp/src/chgrp.rs

@@ -32,7 +32,7 @@ fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
     } else {
         let group = matches
             .get_one::<String>(options::ARG_GROUP)
-            .map(|s| s.as_str())
+            .map(std::string::String::as_str)
             .unwrap_or_default();
         raw_group = group.to_string();
         if group.is_empty() {

src/uu/chown/src/chown.rs

@@ -263,10 +263,7 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
     let uid = parse_uid(user, spec, sep)?;
     let gid = parse_gid(group, spec)?;
 
-    if user.chars().next().map(char::is_numeric).unwrap_or(false)
-        && group.is_empty()
-        && spec != user
-    {
+    if user.chars().next().is_some_and(char::is_numeric) && group.is_empty() && spec != user {
         // if the arg starts with an id numeric value, the group isn't set but the separator is provided,
         // we should fail with an error
         return Err(USimpleError::new(

src/uu/chroot/src/chroot.rs

@@ -63,7 +63,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     let commands = match matches.get_many::<String>(options::COMMAND) {
-        Some(v) => v.map(|s| s.as_str()).collect(),
+        Some(v) => v.map(std::string::String::as_str).collect(),
         None => vec![],
     };
 
@@ -179,15 +179,15 @@ fn set_context(root: &Path, options: &clap::ArgMatches) -> UResult<()> {
     let userspec_str = options.get_one::<String>(options::USERSPEC);
     let user_str = options
         .get_one::<String>(options::USER)
-        .map(|s| s.as_str())
+        .map(std::string::String::as_str)
         .unwrap_or_default();
     let group_str = options
         .get_one::<String>(options::GROUP)
-        .map(|s| s.as_str())
+        .map(std::string::String::as_str)
         .unwrap_or_default();
     let groups_str = options
         .get_one::<String>(options::GROUPS)
-        .map(|s| s.as_str())
+        .map(std::string::String::as_str)
         .unwrap_or_default();
     let skip_chdir = options.contains_id(options::SKIP_CHDIR);
     let userspec = match userspec_str {

src/uu/cksum/src/cksum.rs

@@ -168,13 +168,13 @@ where
                 }
             }
         };
-        print!("{}", before_filename);
+        print!("{before_filename}");
         if should_print_filename {
             // The filename might not be valid UTF-8, and filename.display() would mangle the names.
             // Therefore, emit the bytes directly to stdout, without any attempt at encoding them.
             let _dropped_result = stdout().write_all(os_str_as_bytes(filename.as_os_str())?);
         }
-        println!("{}", after_filename);
+        println!("{after_filename}");
     }
 
     Ok(())

src/uu/comm/src/comm.rs

@@ -42,7 +42,7 @@ struct LineReader {
 
 impl LineReader {
     fn new(input: Input, line_ending: LineEnding) -> Self {
-        Self { input, line_ending }
+        Self { line_ending, input }
     }
 
     fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {

src/uu/cp/src/copydir.rs

@@ -99,7 +99,7 @@
         let current_dir = env::current_dir()?;
         let root_path = current_dir.join(root);
         let root_parent = if target.exists() && !root.to_str().unwrap().ends_with("/.") {
-            root_path.parent().map(|p| p.to_path_buf())
+            root_path.parent().map(std::path::Path::to_path_buf)
         } else {
             Some(root_path)
         };
@@ -175,7 +175,7 @@
             let source_is_dir = direntry.path().is_dir();
             if path_ends_with_terminator(context.target) && source_is_dir {
                 if let Err(e) = std::fs::create_dir_all(context.target) {
-                    eprintln!("Failed to create directory: {}", e);
+                    eprintln!("Failed to create directory: {e}");
                 }
             } else {
                 descendant = descendant.strip_prefix(context.root)?.to_path_buf();

src/uu/csplit/src/csplit.rs

@@ -559,7 +559,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let patterns: Vec<String> = matches
         .get_many::<String>(options::PATTERN)
         .unwrap()
-        .map(|s| s.to_string())
+        .map(std::string::ToString::to_string)
         .collect();
     let options = CsplitOptions::new(&matches);
     if file_name == "-" {

src/uu/csplit/src/patterns.rs

@@ -192,7 +192,7 @@ mod tests {
     fn up_to_line_pattern() {
         let input: Vec<String> = vec!["24", "42", "{*}", "50", "{4}"]
             .into_iter()
-            .map(|v| v.to_string())
+            .map(std::string::ToString::to_string)
             .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 3);
@@ -223,7 +223,7 @@ mod tests {
             "/test5.*end$/-3",
         ]
         .into_iter()
-        .map(|v| v.to_string())
+        .map(std::string::ToString::to_string)
         .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 5);
@@ -277,7 +277,7 @@ mod tests {
             "%test5.*end$%-3",
         ]
         .into_iter()
-        .map(|v| v.to_string())
+        .map(std::string::ToString::to_string)
         .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 5);

src/uu/cut/src/cut.rs

@@ -476,10 +476,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 Options {
                     out_delimiter,
                     line_ending,
-                    field_opts: Some(FieldOptions {
-                        only_delimited,
-                        delimiter,
-                })},
+                    field_opts: Some(FieldOptions { delimiter, only_delimited })},
             )
         }),
         (2.., _, _, _) => Err(

src/uu/date/src/date.rs

@@ -237,7 +237,7 @@
                     None => {
                         return Err(USimpleError::new(
                             1,
-                            format!("invalid date {}", relative_time),
+                            format!("invalid date {relative_time}"),
                         ));
                     }
                 }

src/uu/dd/src/blocks.rs

@@ -23,18 +23,18 @@ const SPACE: u8 = b' ';
 /// all-spaces block at the end. Otherwise, remove the last block if
 /// it is all spaces.
 fn block(buf: &[u8], cbs: usize, sync: bool, rstat: &mut ReadStat) -> Vec<Vec<u8>> {
-    let mut blocks = buf
-        .split(|&e| e == NEWLINE)
-        .map(|split| split.to_vec())
-        .fold(Vec::new(), |mut blocks, mut split| {
+    let mut blocks = buf.split(|&e| e == NEWLINE).map(<[u8]>::to_vec).fold(
+        Vec::new(),
+        |mut blocks, mut split| {
             if split.len() > cbs {
                 rstat.records_truncated += 1;
             }
             split.resize(cbs, SPACE);
             blocks.push(split);
 
             blocks
-        });
+        },
+    );
 
     // If `sync` is true and there has been at least one partial
     // record read from the input, then leave the all-spaces block at

src/uu/dd/src/dd.rs

@@ -1409,7 +1409,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         &matches
             .get_many::<String>(options::OPERANDS)
             .unwrap_or_default()
-            .map(|s| s.as_ref())
+            .map(std::convert::AsRef::as_ref)
             .collect::<Vec<_>>()[..],
     )?;
 

src/uu/df/src/columns.rs

@@ -96,7 +96,7 @@ impl Column {
                 let names = matches
                     .get_many::<String>(OPT_OUTPUT)
                     .unwrap()
-                    .map(|s| s.as_str());
+                    .map(std::string::String::as_str);
                 let mut seen: Vec<&str> = vec![];
                 let mut columns = vec![];
                 for name in names {

src/uu/df/src/df.rs

@@ -444,7 +444,7 @@
         None => {
             let filesystems = get_all_filesystems(&opt).map_err(|e| {
                 let context = "cannot read table of mounted file systems";
-                USimpleError::new(e.code(), format!("{}: {}", context, e))
+                USimpleError::new(e.code(), format!("{context}: {e}"))
             })?;
 
             if filesystems.is_empty() {
@@ -457,7 +457,7 @@
             let paths: Vec<_> = paths.collect();
             let filesystems = get_named_filesystems(&paths, &opt).map_err(|e| {
                 let context = "cannot read table of mounted file systems";
-                USimpleError::new(e.code(), format!("{}: {}", context, e))
+                USimpleError::new(e.code(), format!("{context}: {e}"))
             })?;
 
             // This can happen if paths are given as command-line arguments

src/uu/df/src/filesystem.rs

@@ -107,13 +107,15 @@ impl Filesystem {
             mount_info.mount_dir.clone()
         };
         #[cfg(unix)]
+        #[allow(clippy::used_underscore_binding)]
         let usage = FsUsage::new(statfs(_stat_path).ok()?);
         #[cfg(windows)]
+        #[allow(clippy::used_underscore_binding)]
         let usage = FsUsage::new(Path::new(&_stat_path)).ok()?;
         Some(Self {
+            file,
             mount_info,
             usage,
-            file,
         })
     }
 

src/uu/df/src/table.rs

@@ -841,12 +841,12 @@ mod tests {
             },
             usage: crate::table::FsUsage {
                 blocksize: 4096,
-                blocks: 244029695,
-                bfree: 125085030,
-                bavail: 125085030,
+                blocks: 244_029_695,
+                bfree: 125_085_030,
+                bavail: 125_085_030,
                 bavail_top_bit_set: false,
                 files: 999,
-                ffree: 1000000,
+                ffree: 1_000_000,
             },
         };
 
@@ -871,12 +871,12 @@ mod tests {
             },
             usage: crate::table::FsUsage {
                 blocksize: 4096,
-                blocks: 244029695,
-                bfree: 125085030,
-                bavail: 125085030,
+                blocks: 244_029_695,
+                bfree: 125_085_030,
+                bavail: 125_085_030,
                 bavail_top_bit_set: false,
-                files: 99999999999,
-                ffree: 999999,
+                files: 99_999_999_999,
+                ffree: 999_999,
             },
         };
 

src/uu/dir/src/dir.rs

@@ -55,8 +55,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let locs = matches
         .get_many::<OsString>(options::PATHS)
-        .map(|v| v.map(Path::new).collect())
-        .unwrap_or_else(|| vec![Path::new(".")]);
+        .map_or_else(|| vec![Path::new(".")], |v| v.map(Path::new).collect());
 
     uu_ls::list(locs, &config)
 }

src/uu/dircolors/src/dircolors.rs

@@ -78,14 +78,14 @@ pub fn generate_type_output(fmt: &OutputFmt) -> String {
     match fmt {
         OutputFmt::Display => FILE_TYPES
             .iter()
-            .map(|&(_, key, val)| format!("\x1b[{}m{}\t{}\x1b[0m", val, key, val))
+            .map(|&(_, key, val)| format!("\x1b[{val}m{key}\t{val}\x1b[0m"))
             .collect::<Vec<String>>()
             .join("\n"),
         _ => {
             // Existing logic for other formats
             FILE_TYPES
                 .iter()
-                .map(|&(_, v1, v2)| format!("{}={}", v1, v2))
+                .map(|&(_, v1, v2)| format!("{v1}={v2}"))
                 .collect::<Vec<String>>()
                 .join(":")
         }
@@ -100,8 +100,7 @@ fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
             display_parts.push(type_output);
             for &(extension, code) in FILE_COLORS {
                 let prefix = if extension.starts_with('*') { "" } else { "*" };
-                let formatted_extension =
-                    format!("\x1b[{}m{}{}\t{}\x1b[0m", code, prefix, extension, code);
+                let formatted_extension = format!("\x1b[{code}m{prefix}{extension}\t{code}\x1b[0m");
                 display_parts.push(formatted_extension);
             }
             display_parts.join("\n")
@@ -111,8 +110,8 @@ fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
             let mut parts = vec![];
             for &(extension, code) in FILE_COLORS {
                 let prefix = if extension.starts_with('*') { "" } else { "*" };
-                let formatted_extension = format!("{}{}", prefix, extension);
-                parts.push(format!("{}={}", formatted_extension, code));
+                let formatted_extension = format!("{prefix}{extension}");
+                parts.push(format!("{formatted_extension}={code}"));
             }
             let (prefix, suffix) = get_colors_format_strings(fmt);
             let ls_colors = parts.join(sep);
@@ -133,7 +132,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let files = matches
         .get_many::<String>(options::FILE)
-        .map_or(vec![], |file_values| file_values.collect());
+        .map_or(vec![], std::iter::Iterator::collect);
 
     // clap provides .conflicts_with / .conflicts_with_all, but we want to
     // manually handle conflicts so we can match the output of GNU coreutils
@@ -493,7 +492,7 @@ pub fn generate_dircolors_config() -> String {
     );
     config.push_str("COLORTERM ?*\n");
     for term in TERMS {
-        config.push_str(&format!("TERM {}\n", term));
+        config.push_str(&format!("TERM {term}\n"));
     }
 
     config.push_str(
@@ -514,14 +513,14 @@ pub fn generate_dircolors_config() -> String {
     );
 
     for (name, _, code) in FILE_TYPES {
-        config.push_str(&format!("{} {}\n", name, code));
+        config.push_str(&format!("{name} {code}\n"));
     }
 
     config.push_str("# List any file extensions like '.gz' or '.tar' that you would like ls\n");
     config.push_str("# to color below. Put the extension, a space, and the color init string.\n");
 
     for (ext, color) in FILE_COLORS {
-        config.push_str(&format!("{} {}\n", ext, color));
+        config.push_str(&format!("{ext} {color}\n"));
     }
     config.push_str("# Subsequent TERM or COLORTERM entries, can be used to add / override\n");
     config.push_str("# config specific to those matching environment variables.");

src/uu/du/src/du.rs

@@ -594,7 +594,7 @@ fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
         if path.is_dir() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::Other,
-                format!("{}: read error: Is a directory", file_name),
+                format!("{file_name}: read error: Is a directory"),
             ));
         }
 
@@ -604,10 +604,7 @@ fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
-                    format!(
-                        "cannot open '{}' for reading: No such file or directory",
-                        file_name
-                    ),
+                    format!("cannot open '{file_name}' for reading: No such file or directory"),
                 ))
             }
             Err(e) => return Err(e),
@@ -644,7 +641,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let max_depth = parse_depth(
         matches
             .get_one::<String>(options::MAX_DEPTH)
-            .map(|s| s.as_str()),
+            .map(std::string::String::as_str),
         summarize,
     )?;
 
@@ -717,7 +714,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     };
 
     let time_format = if time.is_some() {
-        parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?.to_string()
+        parse_time_style(
+            matches
+                .get_one::<String>("time-style")
+                .map(std::string::String::as_str),
+        )?
+        .to_string()
     } else {
         "%Y-%m-%d %H:%M".to_string()
     };

src/uu/echo/src/echo.rs

@@ -123,7 +123,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let no_newline = matches.get_flag(options::NO_NEWLINE);
     let escaped = matches.get_flag(options::ENABLE_BACKSLASH_ESCAPE);
     let values: Vec<String> = match matches.get_many::<String>(options::STRING) {
-        Some(s) => s.map(|s| s.to_string()).collect(),
+        Some(s) => s.map(std::string::ToString::to_string).collect(),
         None => vec![String::new()],
     };