minor code quality improvements

Author: daniel.eades

src/uu/fmt/src/parasplit.rs

@@ -255,9 +255,8 @@ impl ParagraphStream<'_> {
             if l_slice.starts_with("From ") {
                 true
             } else {
-                let colon_posn = match l_slice.find(':') {
-                    Some(n) => n,
-                    None => return false,
+                let Some(colon_posn) = l_slice.find(':') else {
+                    return false;
                 };
 
                 // header field must be nonzero length
@@ -560,12 +559,11 @@ impl<'a> Iterator for WordSplit<'a> {
 
         // find the start of the next word, and record if we find a tab character
         let (before_tab, after_tab, word_start) =
-            match self.analyze_tabs(&self.string[old_position..]) {
-                (b, a, Some(s)) => (b, a, s + old_position),
-                (_, _, None) => {
-                    self.position = self.length;
-                    return None;
-                }
+            if let (b, a, Some(s)) = self.analyze_tabs(&self.string[old_position..]) {
+                (b, a, s + old_position)
+            } else {
+                self.position = self.length;
+                return None;
             };
 
         // find the beginning of the next whitespace

src/uu/ls/src/ls.rs

@@ -403,8 +403,8 @@ fn parse_time_style(options: &clap::ArgMatches) -> Result<TimeStyle, LsError> {
         //If both FULL_TIME and TIME_STYLE are present
         //The one added last is dominant
         if options.get_flag(options::FULL_TIME)
-            && options.indices_of(options::FULL_TIME).unwrap().last()
-                > options.indices_of(options::TIME_STYLE).unwrap().last()
+            && options.indices_of(options::FULL_TIME).unwrap().next_back()
+                > options.indices_of(options::TIME_STYLE).unwrap().next_back()
         {
             Ok(TimeStyle::FullIso)
         } else {

src/uu/seq/src/seq.rs

@@ -101,8 +101,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let options = SeqOptions {
         separator: matches
             .get_one::<String>(OPT_SEPARATOR)
-            .map(|s| s.as_str())
-            .unwrap_or("\n")
+            .map_or("\n", |s| s.as_str())
             .to_string(),
         terminator: matches
             .get_one::<String>(OPT_TERMINATOR)
@@ -150,26 +149,24 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let precision = select_precision(first_precision, increment_precision, last_precision);
 
-    let format = match options.format {
-        Some(f) => {
-            let f = Format::<num_format::Float>::parse(f)?;
-            Some(f)
-        }
-        None => None,
-    };
+    let format = options
+        .format
+        .map(|f| Format::<num_format::Float>::parse(f))
+        .transpose()?;
+
     let result = print_seq(
         (first.number, increment.number, last.number),
         precision,
         &options.separator,
         &options.terminator,
         options.equal_width,
         padding,
-        &format,
+        format.as_ref(),
     );
     match result {
-        Ok(_) => Ok(()),
+        Ok(()) => Ok(()),
         Err(err) if err.kind() == ErrorKind::BrokenPipe => Ok(()),
-        Err(e) => Err(e.map_err_context(|| "write error".into())),
+        Err(err) => Err(err.map_err_context(|| "write error".into())),
     }
 }
 
@@ -263,7 +260,7 @@ fn print_seq(
     terminator: &str,
     pad: bool,
     padding: usize,
-    format: &Option<Format<num_format::Float>>,
+    format: Option<&Format<num_format::Float>>,
 ) -> std::io::Result<()> {
     let stdout = stdout();
     let mut stdout = stdout.lock();

src/uu/split/src/split.rs

@@ -1408,18 +1408,15 @@ where
         };
 
         let bytes = line.as_slice();
-        match kth_chunk {
-            Some(chunk_number) => {
-                if (i % num_chunks) == (chunk_number - 1) as usize {
-                    stdout_writer.write_all(bytes)?;
-                }
+        if let Some(chunk_number) = kth_chunk {
+            if (i % num_chunks) == (chunk_number - 1) as usize {
+                stdout_writer.write_all(bytes)?;
             }
-            None => {
-                let writer = out_files.get_writer(i % num_chunks, settings)?;
-                let writer_stdin_open = custom_write_all(bytes, writer, settings)?;
-                if !writer_stdin_open {
-                    closed_writers += 1;
-                }
+        } else {
+            let writer = out_files.get_writer(i % num_chunks, settings)?;
+            let writer_stdin_open = custom_write_all(bytes, writer, settings)?;
+            if !writer_stdin_open {
+                closed_writers += 1;
             }
         }
         i += 1;

src/uucore/src/lib/features/fsxattr.rs

@@ -79,13 +79,7 @@ pub fn apply_xattrs<P: AsRef<Path>>(
 /// `true` if the file has extended attributes (indicating an ACL), `false` otherwise.
 pub fn has_acl<P: AsRef<Path>>(file: P) -> bool {
     // don't use exacl here, it is doing more getxattr call then needed
-    match xattr::list(file) {
-        Ok(acl) => {
-            // if we have extra attributes, we have an acl
-            acl.count() > 0
-        }
-        Err(_) => false,
-    }
+    xattr::list(file).map_or(false, |acl| acl.count() > 0)
 }
 
 /// Returns the permissions bits of a file or directory which has Access Control List (ACL) entries based on its
@@ -132,7 +126,7 @@ pub fn get_acl_perm_bits_from_xattr<P: AsRef<Path>>(source: P) -> u32 {
 
             for entry in acl_entries.chunks_exact(4) {
                 // Third byte and fourth byte will be the perm bits
-                perm = (perm << 3) | entry[2] as u32 | entry[3] as u32;
+                perm = (perm << 3) | u32::from(entry[2]) | u32::from(entry[3]);
             }
             return perm;
         }

src/uucore/src/lib/features/perms.rs

@@ -273,18 +273,15 @@ impl ChownExecutor {
     #[allow(clippy::cognitive_complexity)]
     fn traverse<P: AsRef<Path>>(&self, root: P) -> i32 {
         let path = root.as_ref();
-        let meta = match self.obtain_meta(path, self.dereference) {
-            Some(m) => m,
-            _ => {
-                if self.verbosity.level == VerbosityLevel::Verbose {
-                    println!(
-                        "failed to change ownership of {} to {}",
-                        path.quote(),
-                        self.raw_owner
-                    );
-                }
-                return 1;
+        let Some(meta) = self.obtain_meta(path, self.dereference) else {
+            if self.verbosity.level == VerbosityLevel::Verbose {
+                println!(
+                    "failed to change ownership of {} to {}",
+                    path.quote(),
+                    self.raw_owner
+                );
             }
+            return 1;
         };
 
         if self.recursive
@@ -370,17 +367,15 @@ impl ChownExecutor {
                 Ok(entry) => entry,
             };
             let path = entry.path();
-            let meta = match self.obtain_meta(path, self.dereference) {
-                Some(m) => m,
-                _ => {
-                    ret = 1;
-                    if entry.file_type().is_dir() {
-                        // Instruct walkdir to skip this directory to avoid getting another error
-                        // when walkdir tries to query the children of this directory.
-                        iterator.skip_current_dir();
-                    }
-                    continue;
+
+            let Some(meta) = self.obtain_meta(path, self.dereference) else {
+                ret = 1;
+                if entry.file_type().is_dir() {
+                    // Instruct walkdir to skip this directory to avoid getting another error
+                    // when walkdir tries to query the children of this directory.
+                    iterator.skip_current_dir();
                 }
+                continue;
             };
 
             if self.preserve_root && is_root(path, self.traverse_symlinks == TraverseSymlinks::All)
@@ -425,24 +420,18 @@ impl ChownExecutor {
 
     fn obtain_meta<P: AsRef<Path>>(&self, path: P, follow: bool) -> Option<Metadata> {
         let path = path.as_ref();
-
-        let meta = get_metadata(path, follow);
-
-        match meta {
-            Err(e) => {
-                match self.verbosity.level {
-                    VerbosityLevel::Silent => (),
-                    _ => show_error!(
+        get_metadata(path, follow)
+            .inspect_err(|e| {
+                if self.verbosity.level != VerbosityLevel::Silent {
+                    show_error!(
                         "cannot {} {}: {}",
                         if follow { "dereference" } else { "access" },
                         path.quote(),
-                        strip_errno(&e)
-                    ),
+                        strip_errno(e)
+                    );
                 }
-                None
-            }
-            Ok(meta) => Some(meta),
-        }
+            })
+            .ok()
     }
 
     #[inline]