diff --git a/Cargo.toml b/Cargo.toml index bcb4c54d2a3..e4e125248b0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -666,7 +666,6 @@ redundant_closure_for_method_calls = "allow" # 125 cast_possible_truncation = "allow" # 122 too_many_lines = "allow" # 101 trivially_copy_pass_by_ref = "allow" # 84 -single_match_else = "allow" # 82 cast_possible_wrap = "allow" # 78 cast_sign_loss = "allow" # 70 struct_excessive_bools = "allow" # 68 diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs index eeec8902528..babb0ce925e 100644 --- a/src/uu/cat/src/cat.rs +++ b/src/uu/cat/src/cat.rs @@ -639,40 +639,34 @@ fn write_end( fn write_to_end(in_buf: &[u8], writer: &mut W) -> io::Result { // using memchr2 significantly improves performances - match memchr2(b'\n', b'\r', in_buf) { - Some(p) => { - writer.write_all(&in_buf[..p])?; - Ok(p) - } - None => { - writer.write_all(in_buf)?; - Ok(in_buf.len()) - } + if let Some(p) = memchr2(b'\n', b'\r', in_buf) { + writer.write_all(&in_buf[..p])?; + Ok(p) + } else { + writer.write_all(in_buf)?; + Ok(in_buf.len()) } } fn write_tab_to_end(mut in_buf: &[u8], writer: &mut W) -> io::Result { let mut count = 0; loop { - match in_buf + if let Some(p) = in_buf .iter() .position(|c| *c == b'\n' || *c == b'\t' || *c == b'\r') { - Some(p) => { - writer.write_all(&in_buf[..p])?; - if in_buf[p] == b'\t' { - writer.write_all(b"^I")?; - in_buf = &in_buf[p + 1..]; - count += p + 1; - } else { - // b'\n' or b'\r' - return Ok(count + p); - } - } - None => { - writer.write_all(in_buf)?; - return Ok(in_buf.len() + count); + writer.write_all(&in_buf[..p])?; + if in_buf[p] == b'\t' { + writer.write_all(b"^I")?; + in_buf = &in_buf[p + 1..]; + count += p + 1; + } else { + // b'\n' or b'\r' + return Ok(count + p); } + } else { + writer.write_all(in_buf)?; + return Ok(in_buf.len() + count); } } } diff --git a/src/uu/chmod/src/chmod.rs b/src/uu/chmod/src/chmod.rs index 6ff03e5032c..78dccffdc25 100644 --- a/src/uu/chmod/src/chmod.rs +++ b/src/uu/chmod/src/chmod.rs @@ -272,42 +272,41 @@ impl Chmoder { /// Calculate the new mode based on the current mode and the chmod specification. /// Returns (`new_mode`, `naively_expected_new_mode`) for symbolic modes, or (`new_mode`, `new_mode`) for numeric/reference modes. fn calculate_new_mode(&self, current_mode: u32, is_dir: bool) -> UResult<(u32, u32)> { - match self.fmode { - Some(mode) => Ok((mode, mode)), - None => { - let cmode_unwrapped = self.cmode.clone().unwrap(); - let mut new_mode = current_mode; - let mut naively_expected_new_mode = current_mode; - - for mode in cmode_unwrapped.split(',') { - let result = if mode.chars().any(|c| c.is_ascii_digit()) { - mode::parse_numeric(new_mode, mode, is_dir).map(|v| (v, v)) - } else { - mode::parse_symbolic(new_mode, mode, mode::get_umask(), is_dir).map(|m| { - // calculate the new mode as if umask was 0 - let naive_mode = - mode::parse_symbolic(naively_expected_new_mode, mode, 0, is_dir) - .unwrap(); // we know that mode must be valid, so this cannot fail - (m, naive_mode) - }) - }; - - match result { - Ok((mode, naive_mode)) => { - new_mode = mode; - naively_expected_new_mode = naive_mode; - } - Err(f) => { - return if self.quiet { - Err(ExitCode::new(1)) - } else { - Err(USimpleError::new(1, f)) - }; - } + if let Some(mode) = self.fmode { + Ok((mode, mode)) + } else { + let cmode_unwrapped = self.cmode.clone().unwrap(); + let mut new_mode = current_mode; + let mut naively_expected_new_mode = current_mode; + + for mode in cmode_unwrapped.split(',') { + let result = if mode.chars().any(|c| c.is_ascii_digit()) { + mode::parse_numeric(new_mode, mode, is_dir).map(|v| (v, v)) + } else { + mode::parse_symbolic(new_mode, mode, mode::get_umask(), is_dir).map(|m| { + // calculate the new mode as if umask was 0 + let naive_mode = + mode::parse_symbolic(naively_expected_new_mode, mode, 0, is_dir) + .unwrap(); // we know that mode must be valid, so this cannot fail + (m, naive_mode) + }) + }; + + match result { + Ok((mode, naive_mode)) => { + new_mode = mode; + naively_expected_new_mode = naive_mode; + } + Err(f) => { + return if self.quiet { + Err(ExitCode::new(1)) + } else { + Err(USimpleError::new(1, f)) + }; } } - Ok((new_mode, naively_expected_new_mode)) } + Ok((new_mode, naively_expected_new_mode)) } } @@ -655,32 +654,31 @@ impl Chmoder { self.calculate_new_mode(fperm, file.is_dir())?; // Determine how to apply the permissions - match self.fmode { - Some(mode) => self.change_file(fperm, mode, file)?, - None => { - // Special handling for symlinks when not dereferencing - if file.is_symlink() && !dereference { - // TODO: On most Unix systems, symlink permissions are ignored by the kernel, - // so changing them has no effect. We skip this operation for compatibility. - // Note that "chmod without dereferencing" effectively does nothing on symlinks. - if self.verbose { - println!( - "neither symbolic link {} nor referent has been changed", - file.quote() - ); - } - } else { - self.change_file(fperm, new_mode, file)?; - } - // if a permission would have been removed if umask was 0, but it wasn't because umask was not 0, print an error and fail - if (new_mode & !naively_expected_new_mode) != 0 { - return Err(ChmodError::NewPermissions( - file.into(), - display_permissions_unix(new_mode as mode_t, false), - display_permissions_unix(naively_expected_new_mode as mode_t, false), - ) - .into()); + if let Some(mode) = self.fmode { + self.change_file(fperm, mode, file)?; + } else { + // Special handling for symlinks when not dereferencing + if file.is_symlink() && !dereference { + // TODO: On most Unix systems, symlink permissions are ignored by the kernel, + // so changing them has no effect. We skip this operation for compatibility. + // Note that "chmod without dereferencing" effectively does nothing on symlinks. + if self.verbose { + println!( + "neither symbolic link {} nor referent has been changed", + file.quote() + ); } + } else { + self.change_file(fperm, new_mode, file)?; + } + // if a permission would have been removed if umask was 0, but it wasn't because umask was not 0, print an error and fail + if (new_mode & !naively_expected_new_mode) != 0 { + return Err(ChmodError::NewPermissions( + file.into(), + display_permissions_unix(new_mode as mode_t, false), + display_permissions_unix(naively_expected_new_mode as mode_t, false), + ) + .into()); } } diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs index 9335d6ecdca..4f093bda1ad 100644 --- a/src/uu/cp/src/cp.rs +++ b/src/uu/cp/src/cp.rs @@ -828,12 +828,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { let (sources, target) = parse_path_args(paths, &options)?; if let Err(error) = copy(&sources, &target, &options) { - match error { + if let CpError::NotAllFilesCopied = error { // Error::NotAllFilesCopied is non-fatal, but the error // code should still be EXIT_ERR as does GNU cp - CpError::NotAllFilesCopied => {} + } else { // Else we caught a fatal bubbled-up error, log it to stderr - _ => show_error!("{error}"), + show_error!("{error}"); } set_exit_code(EXIT_ERR); } diff --git a/src/uu/cp/src/platform/macos.rs b/src/uu/cp/src/platform/macos.rs index efc00de623f..a545c552ba4 100644 --- a/src/uu/cp/src/platform/macos.rs +++ b/src/uu/cp/src/platform/macos.rs @@ -85,37 +85,32 @@ pub(crate) fn copy_on_write( if raw_pfn.is_null() || error != 0 { // clonefile(2) is either not supported or it errored out (possibly because the FS does not // support COW). - match reflink_mode { - ReflinkMode::Always => { - return Err(translate!("cp-error-failed-to-clone", "source" => source.quote(), "dest" => dest.quote(), "error" => error) + if reflink_mode == ReflinkMode::Always { + return Err(translate!("cp-error-failed-to-clone", "source" => source.quote(), "dest" => dest.quote(), "error" => error) .into()); - } - _ => { - copy_debug.reflink = OffloadReflinkDebug::Yes; - if source_is_stream { - let mut src_file = File::open(source)?; - let mode = 0o622 & !get_umask(); - let mut dst_file = OpenOptions::new() - .create(true) - .write(true) - .mode(mode) - .open(dest)?; - - let dest_is_stream = is_stream(&dst_file.metadata()?); - if !dest_is_stream { - // `copy_stream` doesn't clear the dest file, if dest is not a stream, we should clear it manually. - dst_file.set_len(0)?; - } + } + copy_debug.reflink = OffloadReflinkDebug::Yes; + if source_is_stream { + let mut src_file = File::open(source)?; + let mode = 0o622 & !get_umask(); + let mut dst_file = OpenOptions::new() + .create(true) + .write(true) + .mode(mode) + .open(dest)?; - buf_copy::copy_stream(&mut src_file, &mut dst_file) - .map_err(|_| std::io::Error::from(std::io::ErrorKind::Other)) - .map_err(|e| CpError::IoErrContext(e, context.to_owned()))? - } else { - fs::copy(source, dest) - .map_err(|e| CpError::IoErrContext(e, context.to_owned()))? - } + let dest_is_stream = is_stream(&dst_file.metadata()?); + if !dest_is_stream { + // `copy_stream` doesn't clear the dest file, if dest is not a stream, we should clear it manually. + dst_file.set_len(0)?; } - }; + + buf_copy::copy_stream(&mut src_file, &mut dst_file) + .map_err(|_| std::io::Error::from(std::io::ErrorKind::Other)) + .map_err(|e| CpError::IoErrContext(e, context.to_owned()))?; + } else { + fs::copy(source, dest).map_err(|e| CpError::IoErrContext(e, context.to_owned()))?; + } } Ok(copy_debug) diff --git a/src/uu/csplit/src/csplit.rs b/src/uu/csplit/src/csplit.rs index 1c2978cea0f..67a5d3cc1ea 100644 --- a/src/uu/csplit/src/csplit.rs +++ b/src/uu/csplit/src/csplit.rs @@ -454,16 +454,11 @@ impl SplitWriter<'_> { // write the extra lines required by the offset while offset > 0 { - match input_iter.next() { - Some((_, line)) => { - self.writeln(&line?)?; - } - None => { - self.finish_split()?; - return Err(CsplitError::LineOutOfRange( - pattern_as_str.to_string(), - )); - } + if let Some((_, line)) = input_iter.next() { + self.writeln(&line?)?; + } else { + self.finish_split()?; + return Err(CsplitError::LineOutOfRange(pattern_as_str.to_string())); } offset -= 1; } diff --git a/src/uu/csplit/src/patterns.rs b/src/uu/csplit/src/patterns.rs index 83d868cb397..6710484e9e5 100644 --- a/src/uu/csplit/src/patterns.rs +++ b/src/uu/csplit/src/patterns.rs @@ -71,21 +71,18 @@ impl Iterator for ExecutePatternIter { type Item = (Option, usize); fn next(&mut self) -> Option<(Option, usize)> { - match self.max { + if let Some(m) = self.max { // iterate until m is reached - Some(m) => { - if self.cur == m { - None - } else { - self.cur += 1; - Some((self.max, self.cur)) - } - } - // no limit, just increment a counter - None => { + if self.cur == m { + None + } else { self.cur += 1; - Some((None, self.cur)) + Some((self.max, self.cur)) } + } else { + // no limit, just increment a counter + self.cur += 1; + Some((None, self.cur)) } } } diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs index cc48edfab71..dd0ea9d8ad9 100644 --- a/src/uu/cut/src/cut.rs +++ b/src/uu/cut/src/cut.rs @@ -153,27 +153,24 @@ fn cut_fields_explicit_out_delim( print_delim = true; } - match delim_search.next() { + if let Some((first, last)) = delim_search.next() { // print the current field up to the next field delim - Some((first, last)) => { - let segment = &line[low_idx..first]; + let segment = &line[low_idx..first]; - out.write_all(segment)?; + out.write_all(segment)?; - low_idx = last; - fields_pos = high + 1; - } - None => { - // this is the last field in the line, so print the rest - let segment = &line[low_idx..]; + low_idx = last; + fields_pos = high + 1; + } else { + // this is the last field in the line, so print the rest + let segment = &line[low_idx..]; - out.write_all(segment)?; + out.write_all(segment)?; - if line[line.len() - 1] == newline_char { - return Ok(true); - } - break; + if line[line.len() - 1] == newline_char { + return Ok(true); } + break; } } } @@ -227,26 +224,23 @@ fn cut_fields_implicit_out_delim( } } - match delim_search.nth(high - low) { - Some((first, _)) => { - let segment = &line[low_idx..first]; + if let Some((first, _)) = delim_search.nth(high - low) { + let segment = &line[low_idx..first]; - out.write_all(segment)?; + out.write_all(segment)?; - print_delim = true; - low_idx = first; - fields_pos = high + 1; - } - None => { - let segment = &line[low_idx..line.len()]; + print_delim = true; + low_idx = first; + fields_pos = high + 1; + } else { + let segment = &line[low_idx..line.len()]; - out.write_all(segment)?; + out.write_all(segment)?; - if line[line.len() - 1] == newline_char { - return Ok(true); - } - break; + if line[line.len() - 1] == newline_char { + return Ok(true); } + break; } } out.write_all(&[newline_char])?; diff --git a/src/uu/dircolors/src/dircolors.rs b/src/uu/dircolors/src/dircolors.rs index 32e2d34a7ac..72e18d55d4f 100644 --- a/src/uu/dircolors/src/dircolors.rs +++ b/src/uu/dircolors/src/dircolors.rs @@ -92,30 +92,27 @@ pub fn generate_type_output(fmt: &OutputFmt) -> String { } fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String { - match fmt { - OutputFmt::Display => { - let mut display_parts = vec![]; - let type_output = generate_type_output(fmt); - display_parts.push(type_output); - for &(extension, code) in FILE_COLORS { - let prefix = if extension.starts_with('*') { "" } else { "*" }; - let formatted_extension = format!("\x1b[{code}m{prefix}{extension}\t{code}\x1b[0m"); - display_parts.push(formatted_extension); - } - display_parts.join("\n") + if let OutputFmt::Display = fmt { + let mut display_parts = vec![]; + let type_output = generate_type_output(fmt); + display_parts.push(type_output); + for &(extension, code) in FILE_COLORS { + let prefix = if extension.starts_with('*') { "" } else { "*" }; + let formatted_extension = format!("\x1b[{code}m{prefix}{extension}\t{code}\x1b[0m"); + display_parts.push(formatted_extension); } - _ => { - // existing logic for other formats - 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 (prefix, suffix) = get_colors_format_strings(fmt); - let ls_colors = parts.join(sep); - format!("{prefix}{}:{ls_colors}:{suffix}", generate_type_output(fmt),) + display_parts.join("\n") + } else { + // existing logic for other formats + 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 (prefix, suffix) = get_colors_format_strings(fmt); + let ls_colors = parts.join(sep); + format!("{prefix}{}:{ls_colors}:{suffix}", generate_type_output(fmt),) } } diff --git a/src/uu/expand/src/expand.rs b/src/uu/expand/src/expand.rs index ec8a3704fb2..685cb44ac98 100644 --- a/src/uu/expand/src/expand.rs +++ b/src/uu/expand/src/expand.rs @@ -320,9 +320,10 @@ fn open(path: &OsString) -> UResult>> { fn next_tabstop(tabstops: &[usize], col: usize, remaining_mode: &RemainingMode) -> usize { let num_tabstops = tabstops.len(); match remaining_mode { - RemainingMode::Plus => match tabstops[0..num_tabstops - 1].iter().find(|&&t| t > col) { - Some(t) => t - col, - None => { + RemainingMode::Plus => { + if let Some(t) = tabstops[0..num_tabstops - 1].iter().find(|&&t| t > col) { + t - col + } else { let step_size = tabstops[num_tabstops - 1]; let last_fixed_tabstop = tabstops[num_tabstops - 2]; let characters_since_last_tabstop = col - last_fixed_tabstop; @@ -330,11 +331,14 @@ fn next_tabstop(tabstops: &[usize], col: usize, remaining_mode: &RemainingMode) let steps_required = 1 + characters_since_last_tabstop / step_size; steps_required * step_size - characters_since_last_tabstop } - }, - RemainingMode::Slash => match tabstops[0..num_tabstops - 1].iter().find(|&&t| t > col) { - Some(t) => t - col, - None => tabstops[num_tabstops - 1] - col % tabstops[num_tabstops - 1], - }, + } + RemainingMode::Slash => { + if let Some(t) = tabstops[0..num_tabstops - 1].iter().find(|&&t| t > col) { + t - col + } else { + tabstops[num_tabstops - 1] - col % tabstops[num_tabstops - 1] + } + } RemainingMode::None => { if num_tabstops == 1 { tabstops[0] - col % tabstops[0] diff --git a/src/uu/groups/src/groups.rs b/src/uu/groups/src/groups.rs index d6ecc9ec4ac..d82d43fb102 100644 --- a/src/uu/groups/src/groups.rs +++ b/src/uu/groups/src/groups.rs @@ -36,13 +36,12 @@ enum GroupsError { impl UError for GroupsError {} fn infallible_gid2grp(gid: &u32) -> String { - match gid2grp(*gid) { - Ok(grp) => grp, - Err(_) => { - // The `show!()` macro sets the global exit code for the program. - show!(GroupsError::GroupNotFound(*gid)); - gid.to_string() - } + if let Ok(grp) = gid2grp(*gid) { + grp + } else { + // The `show!()` macro sets the global exit code for the program. + show!(GroupsError::GroupNotFound(*gid)); + gid.to_string() } } diff --git a/src/uu/id/src/id.rs b/src/uu/id/src/id.rs index e6ab3a696cd..59123196870 100644 --- a/src/uu/id/src/id.rs +++ b/src/uu/id/src/id.rs @@ -216,22 +216,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { for i in 0..=users.len() { let possible_pw = if state.user_specified { - match Passwd::locate(users[i].as_str()) { - Ok(p) => Some(p), - Err(_) => { - show_error!( - "{}", - translate!("id-error-no-such-user", - "user" => users[i].quote() - ) - ); - set_exit_code(1); - if i + 1 >= users.len() { - break; - } - - continue; + if let Ok(p) = Passwd::locate(users[i].as_str()) { + Some(p) + } else { + show_error!( + "{}", + translate!("id-error-no-such-user", + "user" => users[i].quote() + ) + ); + set_exit_code(1); + if i + 1 >= users.len() { + break; } + + continue; } } else { None diff --git a/src/uu/ln/src/ln.rs b/src/uu/ln/src/ln.rs index c20a2fc888c..541586625f9 100644 --- a/src/uu/ln/src/ln.rs +++ b/src/uu/ln/src/ln.rs @@ -319,27 +319,22 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings) } } target_dir.to_path_buf() - } else { - match srcpath.as_os_str().to_str() { - Some(name) => { - match Path::new(name).file_name() { - Some(basename) => target_dir.join(basename), - // This can be None only for "." or "..". Trying - // to create a link with such name will fail with - // EEXIST, which agrees with the behavior of GNU - // coreutils. - None => target_dir.join(name), - } - } - None => { - show_error!( - "{}", - translate!("ln-error-cannot-stat", "path" => srcpath.quote()) - ); - all_successful = false; - continue; - } + } else if let Some(name) = srcpath.as_os_str().to_str() { + match Path::new(name).file_name() { + Some(basename) => target_dir.join(basename), + // This can be None only for "." or "..". Trying + // to create a link with such name will fail with + // EEXIST, which agrees with the behavior of GNU + // coreutils. + None => target_dir.join(name), } + } else { + show_error!( + "{}", + translate!("ln-error-cannot-stat", "path" => srcpath.quote()) + ); + all_successful = false; + continue; }; if linked_destinations.contains(&targetpath) { diff --git a/src/uu/logname/src/logname.rs b/src/uu/logname/src/logname.rs index 6684bd9f446..8790fea3cf8 100644 --- a/src/uu/logname/src/logname.rs +++ b/src/uu/logname/src/logname.rs @@ -26,9 +26,10 @@ fn get_userlogin() -> Option { pub fn uumain(args: impl uucore::Args) -> UResult<()> { let _ = uucore::clap_localization::handle_clap_result(uu_app(), args)?; - match get_userlogin() { - Some(userlogin) => writeln!(stdout(), "{userlogin}")?, - None => show_error!("{}", translate!("logname-error-no-login-name")), + if let Some(userlogin) = get_userlogin() { + writeln!(stdout(), "{userlogin}")?; + } else { + show_error!("{}", translate!("logname-error-no-login-name")); } Ok(()) diff --git a/src/uu/ls/src/ls.rs b/src/uu/ls/src/ls.rs index c2b5534ac4e..d952abafd94 100644 --- a/src/uu/ls/src/ls.rs +++ b/src/uu/ls/src/ls.rs @@ -194,9 +194,10 @@ enum LsError { translate!("ls-error-cannot-open-file-permission-denied", "path" => .0.quote()) }, }, - _ => match .1.raw_os_error().unwrap_or(1) { - 9 => translate!("ls-error-cannot-open-directory-bad-descriptor", "path" => .0.quote()), - _ => translate!("ls-error-unknown-io-error", "path" => .0.quote(), "error" => format!("{:?}", .1)), + _ => if 9 == .1.raw_os_error().unwrap_or(1) { + translate!("ls-error-cannot-open-directory-bad-descriptor", "path" => .0.quote()) + } else { + translate!("ls-error-unknown-io-error", "path" => .0.quote(), "error" => format!("{:?}", .1)) }, })] IOErrorContext(PathBuf, std::io::Error, bool), @@ -827,17 +828,17 @@ fn parse_width(width_match: Option<&String>) -> Result { } }; - let parse_width_from_env = - |columns: OsString| match columns.to_str().and_then(|s| s.parse().ok()) { - Some(columns) => columns, - None => { - show_error!( - "{}", - translate!("ls-invalid-columns-width", "width" => columns.quote()) - ); - DEFAULT_TERM_WIDTH - } - }; + let parse_width_from_env = |columns: OsString| { + if let Some(columns) = columns.to_str().and_then(|s| s.parse().ok()) { + columns + } else { + show_error!( + "{}", + translate!("ls-invalid-columns-width", "width" => columns.quote()) + ); + DEFAULT_TERM_WIDTH + } + }; let calculate_term_size = || match terminal_size::terminal_size() { Some((width, _)) => width.0, @@ -958,8 +959,8 @@ impl Config { let (file_size_block_size, block_size) = if !opt_si && !opt_hr && !raw_block_size.is_empty() { - match parse_size_non_zero_u64(&raw_block_size.to_string_lossy()) { - Ok(size) => match (is_env_var_blocksize, opt_kb) { + if let Ok(size) = parse_size_non_zero_u64(&raw_block_size.to_string_lossy()) { + match (is_env_var_blocksize, opt_kb) { (true, true) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE), (true, false) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, size), (false, true) => { @@ -971,20 +972,19 @@ impl Config { } } (false, false) => (size, size), - }, - Err(_) => { - // only fail if invalid block size was specified with --block-size, - // ignore invalid block size from env vars - if let Some(invalid_block_size) = opt_block_size { - return Err(Box::new(LsError::BlockSizeParseError( - invalid_block_size.clone(), - ))); - } - if is_env_var_blocksize { - (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE) - } else { - (DEFAULT_BLOCK_SIZE, DEFAULT_BLOCK_SIZE) - } + } + } else { + // only fail if invalid block size was specified with --block-size, + // ignore invalid block size from env vars + if let Some(invalid_block_size) = opt_block_size { + return Err(Box::new(LsError::BlockSizeParseError( + invalid_block_size.clone(), + ))); + } + if is_env_var_blocksize { + (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE) + } else { + (DEFAULT_BLOCK_SIZE, DEFAULT_BLOCK_SIZE) } } } else if env_var_posixly_correct.is_some() { @@ -1047,14 +1047,13 @@ impl Config { .into_iter() .flatten() { - match parse_glob::from_str(pattern) { - Ok(p) => { - ignore_patterns.push(p); - } - Err(_) => show_warning!( + if let Ok(p) = parse_glob::from_str(pattern) { + ignore_patterns.push(p); + } else { + show_warning!( "{}", translate!("ls-invalid-ignore-pattern", "pattern" => pattern.quote()) - ), + ); } } @@ -1064,14 +1063,13 @@ impl Config { .into_iter() .flatten() { - match parse_glob::from_str(pattern) { - Ok(p) => { - ignore_patterns.push(p); - } - Err(_) => show_warning!( + if let Ok(p) = parse_glob::from_str(pattern) { + ignore_patterns.push(p); + } else { + show_warning!( "{}", translate!("ls-invalid-hide-pattern", "pattern" => pattern.quote()) - ), + ); } } } @@ -2235,12 +2233,11 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> { continue; } - let show_dir_contents = match path_data.file_type() { - Some(ft) => !config.directory && ft.is_dir(), - None => { - set_exit_code(1); - false - } + let show_dir_contents = if let Some(ft) = path_data.file_type() { + !config.directory && ft.is_dir() + } else { + set_exit_code(1); + false }; if show_dir_contents { diff --git a/src/uu/more/src/more.rs b/src/uu/more/src/more.rs index 6c93dce6939..f31521a6e08 100644 --- a/src/uu/more/src/more.rs +++ b/src/uu/more/src/more.rs @@ -568,21 +568,20 @@ impl<'a> Pager<'a> { if self.pattern.is_none() { return Ok(()); } - match self.search_pattern_in_file() { - Some(line) => self.upper_mark = line, - None => { - self.pattern = None; - write!( - self.stdout, - "\r{}{} ({}){}", - Attribute::Reverse, - translate!("more-error-pattern-not-found"), - translate!("more-press-return"), - Attribute::Reset, - )?; - self.stdout.flush()?; - self.wait_for_enter_key()?; - } + if let Some(line) = self.search_pattern_in_file() { + self.upper_mark = line; + } else { + self.pattern = None; + write!( + self.stdout, + "\r{}{} ({}){}", + Attribute::Reverse, + translate!("more-error-pattern-not-found"), + translate!("more-press-return"), + Attribute::Reset, + )?; + self.stdout.flush()?; + self.wait_for_enter_key()?; } Ok(()) } diff --git a/src/uu/mv/src/hardlink.rs b/src/uu/mv/src/hardlink.rs index 1402047d5db..d5758031c4e 100644 --- a/src/uu/mv/src/hardlink.rs +++ b/src/uu/mv/src/hardlink.rs @@ -305,12 +305,11 @@ pub fn with_optional_hardlink_context( where F: FnOnce(&mut HardlinkTracker, &HardlinkGroupScanner) -> R, { - match (tracker, scanner) { - (Some(tracker), Some(scanner)) => operation(tracker, scanner), - _ => { - let (mut dummy_tracker, dummy_scanner) = create_hardlink_context(); - operation(&mut dummy_tracker, &dummy_scanner) - } + if let (Some(tracker), Some(scanner)) = (tracker, scanner) { + operation(tracker, scanner) + } else { + let (mut dummy_tracker, dummy_scanner) = create_hardlink_context(); + operation(&mut dummy_tracker, &dummy_scanner) } } diff --git a/src/uu/mv/src/mv.rs b/src/uu/mv/src/mv.rs index bedac3af931..f96a6f65ec6 100644 --- a/src/uu/mv/src/mv.rs +++ b/src/uu/mv/src/mv.rs @@ -641,12 +641,11 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, options: &Options) pb.set_message(msg); } - let targetpath = match sourcepath.file_name() { - Some(name) => target_dir.join(name), - None => { - show!(MvError::NoSuchFile(sourcepath.quote().to_string())); - continue; - } + let targetpath = if let Some(name) = sourcepath.file_name() { + target_dir.join(name) + } else { + show!(MvError::NoSuchFile(sourcepath.quote().to_string())); + continue; }; if moved_destinations.contains(&targetpath) && options.backup != BackupMode::Numbered { @@ -683,9 +682,10 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, options: &Options) let e = e.map_err_context(|| { translate!("mv-error-cannot-move", "source" => sourcepath.quote(), "target" => targetpath.quote()) }); - match display_manager { - Some(ref pb) => pb.suspend(|| show!(e)), - None => show!(e), + if let Some(ref pb) = display_manager { + pb.suspend(|| show!(e)); + } else { + show!(e); } } Ok(()) => (), @@ -789,11 +789,10 @@ fn rename( } if opts.verbose { - let message = match backup_path { - Some(path) => { - translate!("mv-verbose-renamed-with-backup", "from" => from.quote(), "to" => to.quote(), "backup" => path.quote()) - } - None => translate!("mv-verbose-renamed", "from" => from.quote(), "to" => to.quote()), + let message = if let Some(path) = backup_path { + translate!("mv-verbose-renamed-with-backup", "from" => from.quote(), "to" => to.quote(), "backup" => path.quote()) + } else { + translate!("mv-verbose-renamed", "from" => from.quote(), "to" => to.quote()) }; match display_manager { diff --git a/src/uu/nice/src/nice.rs b/src/uu/nice/src/nice.rs index 5c9192c9668..1abb7e96ff1 100644 --- a/src/uu/nice/src/nice.rs +++ b/src/uu/nice/src/nice.rs @@ -119,35 +119,32 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { )); } - let adjustment = match matches.get_one::(options::ADJUSTMENT) { - Some(nstr) => { - if !matches.contains_id(options::COMMAND) { - return Err(UUsageError::new( - 125, - translate!("nice-error-command-required-with-adjustment"), - )); - } - match nstr.parse::() { - Ok(num) => num, - Err(e) => match e.kind() { - IntErrorKind::PosOverflow => NICE_BOUND_NO_OVERFLOW, - IntErrorKind::NegOverflow => -NICE_BOUND_NO_OVERFLOW, - _ => { - return Err(USimpleError::new( - 125, - translate!("nice-error-invalid-number", "value" => nstr.clone(), "error" => e), - )); - } - }, - } + let adjustment = if let Some(nstr) = matches.get_one::(options::ADJUSTMENT) { + if !matches.contains_id(options::COMMAND) { + return Err(UUsageError::new( + 125, + translate!("nice-error-command-required-with-adjustment"), + )); } - None => { - if !matches.contains_id(options::COMMAND) { - writeln!(stdout(), "{niceness}")?; - return Ok(()); - } - 10_i32 + match nstr.parse::() { + Ok(num) => num, + Err(e) => match e.kind() { + IntErrorKind::PosOverflow => NICE_BOUND_NO_OVERFLOW, + IntErrorKind::NegOverflow => -NICE_BOUND_NO_OVERFLOW, + _ => { + return Err(USimpleError::new( + 125, + translate!("nice-error-invalid-number", "value" => nstr.clone(), "error" => e), + )); + } + }, + } + } else { + if !matches.contains_id(options::COMMAND) { + writeln!(stdout(), "{niceness}")?; + return Ok(()); } + 10_i32 }; niceness += adjustment; diff --git a/src/uu/numfmt/src/numfmt.rs b/src/uu/numfmt/src/numfmt.rs index 8da2eea8e5b..2691697a063 100644 --- a/src/uu/numfmt/src/numfmt.rs +++ b/src/uu/numfmt/src/numfmt.rs @@ -314,19 +314,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { print_debug_warnings(&options, &matches); } - let result = match matches.get_many::(NUMBER) { - Some(values) => { - let byte_args: Vec<&[u8]> = values - .map(|s| os_str_as_bytes(s).map_err(|e| e.to_string())) - .collect::, _>>() - .map_err(NumfmtError::IllegalArgument)?; - handle_args(byte_args.into_iter(), &options) - } - None => { - let stdin = std::io::stdin(); - let mut locked_stdin = stdin.lock(); - handle_buffer(&mut locked_stdin, &options) - } + let result = if let Some(values) = matches.get_many::(NUMBER) { + let byte_args: Vec<&[u8]> = values + .map(|s| os_str_as_bytes(s).map_err(|e| e.to_string())) + .collect::, _>>() + .map_err(NumfmtError::IllegalArgument)?; + handle_args(byte_args.into_iter(), &options) + } else { + let stdin = std::io::stdin(); + let mut locked_stdin = stdin.lock(); + handle_buffer(&mut locked_stdin, &options) }; match result { diff --git a/src/uu/od/src/parse_inputs.rs b/src/uu/od/src/parse_inputs.rs index 8f5e6434b65..b6f763b2e52 100644 --- a/src/uu/od/src/parse_inputs.rs +++ b/src/uu/od/src/parse_inputs.rs @@ -206,15 +206,14 @@ pub fn parse_offset_operand(s: &str) -> Result { match u64::from_str_radix(&s[start..len], radix) { Ok(i) => { // Check for overflow during multiplication - match i.checked_mul(multiply) { - Some(result) => Ok(result), - None => { - let err = std::io::Error::from_raw_os_error(libc::ERANGE); - let msg = err.to_string(); - // Strip "(os error N)" if present to match Perl's $! - let msg = msg.split(" (os error").next().unwrap_or(&msg).to_string(); - Err(msg) - } + if let Some(result) = i.checked_mul(multiply) { + Ok(result) + } else { + let err = std::io::Error::from_raw_os_error(libc::ERANGE); + let msg = err.to_string(); + // Strip "(os error N)" if present to match Perl's $! + let msg = msg.split(" (os error").next().unwrap_or(&msg).to_string(); + Err(msg) } } Err(e) => { diff --git a/src/uu/paste/src/paste.rs b/src/uu/paste/src/paste.rs index 7a8aaab632d..5d6ae5ed93d 100644 --- a/src/uu/paste/src/paste.rs +++ b/src/uu/paste/src/paste.rs @@ -125,14 +125,12 @@ fn paste( output.clear(); loop { - match input_source.read_until(line_ending_byte, &mut output)? { - 0 => break, - _ => { - remove_trailing_line_ending_byte(line_ending_byte, &mut output); - - delimiter_state.write_delimiter(&mut output); - } + if input_source.read_until(line_ending_byte, &mut output)? == 0 { + break; } + remove_trailing_line_ending_byte(line_ending_byte, &mut output); + + delimiter_state.write_delimiter(&mut output); } delimiter_state.remove_trailing_delimiter(&mut output); diff --git a/src/uu/pinky/src/platform/unix.rs b/src/uu/pinky/src/platform/unix.rs index cbf01b83721..8f69ae72939 100644 --- a/src/uu/pinky/src/platform/unix.rs +++ b/src/uu/pinky/src/platform/unix.rs @@ -177,20 +177,17 @@ impl Pinky { let mesg; let last_change; - match pts_path.metadata() { - #[allow(clippy::unnecessary_cast)] - Ok(meta) => { - mesg = if meta.mode() & S_IWGRP as u32 == 0 { - '*' - } else { - ' ' - }; - last_change = meta.atime(); - } - _ => { - mesg = '?'; - last_change = 0; - } + #[allow(clippy::unnecessary_cast)] + if let Ok(meta) = pts_path.metadata() { + mesg = if (meta.mode() & (S_IWGRP as u32)) == 0 { + '*' + } else { + ' ' + }; + last_change = meta.atime(); + } else { + mesg = '?'; + last_change = 0; } print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user()); diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs index 29373a511f8..24f76423b56 100644 --- a/src/uu/seq/src/seq.rs +++ b/src/uu/seq/src/seq.rs @@ -154,52 +154,51 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { // If a format was passed on the command line, use that. // If not, use some default format based on parameters precision. - let (format, padding, fast_allowed) = match options.format { - Some(str) => ( + let (format, padding, fast_allowed) = if let Some(str) = options.format { + ( Format::::parse(str)?, 0, false, - ), - None => { - let precision = select_precision(&first, &increment, &last); - - let padding = if options.equal_width { - let precision_value = precision.unwrap_or(0); - first - .num_integral_digits - .max(increment.num_integral_digits) - .max(last.num_integral_digits) - + if precision_value > 0 { - precision_value + 1 - } else { - 0 - } - } else { - 0 - }; - - let formatter = match precision { - // format with precision: decimal floats and integers - Some(precision) => num_format::Float { - variant: FloatVariant::Decimal, - width: padding, - alignment: num_format::NumberAlignment::RightZero, - precision: Some(precision), - ..Default::default() - }, - // format without precision: hexadecimal floats - None => num_format::Float { - variant: FloatVariant::Shortest, - ..Default::default() - }, - }; - // Allow fast printing if precision is 0 (integer inputs), `print_seq` will do further checks. - ( - Format::from_formatter(formatter), - padding, - precision == Some(0), - ) - } + ) + } else { + let precision = select_precision(&first, &increment, &last); + + let padding = if options.equal_width { + let precision_value = precision.unwrap_or(0); + first + .num_integral_digits + .max(increment.num_integral_digits) + .max(last.num_integral_digits) + + if precision_value > 0 { + precision_value + 1 + } else { + 0 + } + } else { + 0 + }; + + let formatter = match precision { + // format with precision: decimal floats and integers + Some(precision) => num_format::Float { + variant: FloatVariant::Decimal, + width: padding, + alignment: num_format::NumberAlignment::RightZero, + precision: Some(precision), + ..Default::default() + }, + // format without precision: hexadecimal floats + None => num_format::Float { + variant: FloatVariant::Shortest, + ..Default::default() + }, + }; + // Allow fast printing if precision is 0 (integer inputs), `print_seq` will do further checks. + ( + Format::from_formatter(formatter), + padding, + precision == Some(0), + ) }; let result = print_seq( diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs index fcab096e2e0..1941691f94a 100644 --- a/src/uu/split/src/split.rs +++ b/src/uu/split/src/split.rs @@ -1188,18 +1188,15 @@ where } } - match kth_chunk { - Some(chunk_number) => { - if i == chunk_number { - stdout_writer.write_all(buf)?; - break; - } - } - None => { - let idx = (i - 1) as usize; - let writer = out_files.get_writer(idx, settings)?; - writer.write_all(buf)?; + if let Some(chunk_number) = kth_chunk { + if i == chunk_number { + stdout_writer.write_all(buf)?; + break; } + } else { + let idx = (i - 1) as usize; + let writer = out_files.get_writer(idx, settings)?; + writer.write_all(buf)?; } } else { break; @@ -1300,18 +1297,15 @@ where } let bytes = line.as_slice(); - match kth_chunk { - Some(kth) => { - if chunk_number == kth { - stdout_writer.write_all(bytes)?; - } - } - None => { - // Should write into a file - let idx = (chunk_number - 1) as usize; - let writer = out_files.get_writer(idx, settings)?; - custom_write_all(bytes, writer, settings)?; + if let Some(kth) = kth_chunk { + if chunk_number == kth { + stdout_writer.write_all(bytes)?; } + } else { + // Should write into a file + let idx = (chunk_number - 1) as usize; + let writer = out_files.get_writer(idx, settings)?; + custom_write_all(bytes, writer, settings)?; } // Advance to the next chunk if the current one is filled. diff --git a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs index da0e43fef0c..d3cc05a3175 100644 --- a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs +++ b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs @@ -191,12 +191,9 @@ fn set_buffer(stream: *mut FILE, value: &str) { "0" => (_IONBF, 0_usize), "L" => (_IOLBF, 0_usize), input => { - let buff_size: usize = match input.parse() { - Ok(num) => num, - Err(_) => { - eprintln!("failed to allocate a {value} byte stdio buffer"); - std::process::exit(1); - } + let Ok(buff_size) = input.parse::() else { + eprintln!("failed to allocate a {value} byte stdio buffer"); + std::process::exit(1); }; (_IOFBF, buff_size as size_t) } diff --git a/src/uu/stty/src/stty.rs b/src/uu/stty/src/stty.rs index 1d40a1a1a49..7b668c8d354 100644 --- a/src/uu/stty/src/stty.rs +++ b/src/uu/stty/src/stty.rs @@ -485,10 +485,12 @@ fn invalid_speed(arg: &str, speed: &str) -> Result> { /// GNU uses different error messages if values overflow or underflow a u8, /// this function returns the appropriate error message in the case of overflow or underflow, or u8 on success fn parse_u8_or_err(arg: &str) -> Result { - arg.parse::().map_err(|e| match e.kind() { - IntErrorKind::PosOverflow => translate!("stty-error-invalid-integer-argument-value-too-large", "value" => format!("'{arg}'")), - _ => translate!("stty-error-invalid-integer-argument", - "value" => format!("'{arg}'")), + arg.parse::().map_err(|e| { + if let IntErrorKind::PosOverflow = e.kind() { + translate!("stty-error-invalid-integer-argument-value-too-large", "value" => format!("'{arg}'")) + } else { + translate!("stty-error-invalid-integer-argument", "value" => format!("'{arg}'")) + } }) } @@ -567,16 +569,15 @@ impl WrappedPrinter { /// If term_size is None (typically when output is piped), falls back to /// the COLUMNS environment variable or a default width of 80 columns. fn new(term_size: Option<&TermSize>) -> Self { - let columns = match term_size { - Some(term_size) => term_size.columns, - None => { - const DEFAULT_TERM_WIDTH: u16 = 80; - - std::env::var_os("COLUMNS") - .and_then(|s| s.to_str()?.parse().ok()) - .filter(|&c| c > 0) - .unwrap_or(DEFAULT_TERM_WIDTH) - } + let columns = if let Some(term_size) = term_size { + term_size.columns + } else { + const DEFAULT_TERM_WIDTH: u16 = 80; + + std::env::var_os("COLUMNS") + .and_then(|s| s.to_str()?.parse().ok()) + .filter(|&c| c > 0) + .unwrap_or(DEFAULT_TERM_WIDTH) }; Self { diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 77c9030b100..ad568db7628 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -277,47 +277,44 @@ fn tail_stdin( return Ok(()); } - match input.resolve() { + if let Some(path) = input.resolve() { // fifo - Some(path) => { - let mut stdin_offset = 0; - if cfg!(unix) { - // Save the current seek position/offset of a stdin redirected file. - // This is needed to pass "gnu/tests/tail-2/start-middle.sh" - if let Ok(mut stdin_handle) = Handle::stdin() { - if let Ok(offset) = stdin_handle.as_file_mut().stream_position() { - stdin_offset = offset; - } + let mut stdin_offset = 0; + if cfg!(unix) { + // Save the current seek position/offset of a stdin redirected file. + // This is needed to pass "gnu/tests/tail-2/start-middle.sh" + if let Ok(mut stdin_handle) = Handle::stdin() { + if let Ok(offset) = stdin_handle.as_file_mut().stream_position() { + stdin_offset = offset; } } - tail_file( - settings, - header_printer, - input, - &path, - observer, - stdin_offset, - )?; } + tail_file( + settings, + header_printer, + input, + &path, + observer, + stdin_offset, + )?; + } else { // pipe - None => { - header_printer.print_input(input); - if paths::stdin_is_bad_fd() { - set_exit_code(1); + header_printer.print_input(input); + if paths::stdin_is_bad_fd() { + set_exit_code(1); + show_error!( + "{}", + translate!("tail-error-cannot-fstat", "file" => translate!("tail-stdin-header"), "error" => translate!("tail-bad-fd")) + ); + if settings.follow.is_some() { show_error!( "{}", - translate!("tail-error-cannot-fstat", "file" => translate!("tail-stdin-header"), "error" => translate!("tail-bad-fd")) + translate!("tail-error-reading-file", "file" => translate!("tail-stdin-header"), "error" => translate!("tail-bad-fd")) ); - if settings.follow.is_some() { - show_error!( - "{}", - translate!("tail-error-reading-file", "file" => translate!("tail-stdin-header"), "error" => translate!("tail-bad-fd")) - ); - } - } else { - let mut reader = BufReader::new(stdin()); - unbounded_tail(&mut reader, settings)?; } + } else { + let mut reader = BufReader::new(stdin()); + unbounded_tail(&mut reader, settings)?; } } diff --git a/src/uu/test/src/parser.rs b/src/uu/test/src/parser.rs index c1c06e4c581..f391752512a 100644 --- a/src/uu/test/src/parser.rs +++ b/src/uu/test/src/parser.rs @@ -341,16 +341,15 @@ impl Parser { .map(|token| Symbol::new(Some(token))) .collect(); - match peek4.as_slice() { + if let [Symbol::Literal(_), Symbol::BoolOp(_), Symbol::Literal(_)] = + peek4.as_slice() + { // we peeked ahead 4 but there were only 3 tokens left - [Symbol::Literal(_), Symbol::BoolOp(_), Symbol::Literal(_)] => { - self.expr()?; - self.stack.push(Symbol::Bang); - } - _ => { - self.term()?; - self.stack.push(Symbol::Bang); - } + self.expr()?; + self.stack.push(Symbol::Bang); + } else { + self.term()?; + self.stack.push(Symbol::Bang); } } } diff --git a/src/uu/tty/src/tty.rs b/src/uu/tty/src/tty.rs index 5bf5199a073..e2c541cff26 100644 --- a/src/uu/tty/src/tty.rs +++ b/src/uu/tty/src/tty.rs @@ -41,12 +41,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { let name = nix::unistd::ttyname(std::io::stdin()); - let write_result = match name { - Ok(name) => stdout.write_all_os(name.as_os_str()), - Err(_) => { - set_exit_code(1); - writeln!(stdout, "{}", translate!("tty-not-a-tty")) - } + let write_result = if let Ok(name) = name { + stdout.write_all_os(name.as_os_str()) + } else { + set_exit_code(1); + writeln!(stdout, "{}", translate!("tty-not-a-tty")) }; if write_result.is_err() || stdout.flush().is_err() { diff --git a/src/uu/wc/src/utf8/mod.rs b/src/uu/wc/src/utf8/mod.rs index 5407a06fa98..d6efb86ebd5 100644 --- a/src/uu/wc/src/utf8/mod.rs +++ b/src/uu/wc/src/utf8/mod.rs @@ -76,20 +76,15 @@ impl Incomplete { let consumed = valid_up_to.checked_sub(initial_buffer_len).unwrap(); self.buffer_len = valid_up_to as u8; (consumed, Some(Ok(()))) + } else if let Some(invalid_sequence_length) = error.error_len() { + let consumed = invalid_sequence_length + .checked_sub(initial_buffer_len) + .unwrap(); + self.buffer_len = invalid_sequence_length as u8; + (consumed, Some(Err(()))) } else { - match error.error_len() { - Some(invalid_sequence_length) => { - let consumed = invalid_sequence_length - .checked_sub(initial_buffer_len) - .unwrap(); - self.buffer_len = invalid_sequence_length as u8; - (consumed, Some(Err(()))) - } - None => { - self.buffer_len = spliced.len() as u8; - (copied_from_input, None) - } - } + self.buffer_len = spliced.len() as u8; + (copied_from_input, None) } } } diff --git a/src/uu/wc/src/utf8/read.rs b/src/uu/wc/src/utf8/read.rs index 518248bdac1..6205ff070d6 100644 --- a/src/uu/wc/src/utf8/read.rs +++ b/src/uu/wc/src/utf8/read.rs @@ -79,17 +79,13 @@ impl BufReadDecoder { if valid_up_to > 0 { break (BytesSource::BufRead(valid_up_to), Ok(())); } - match error.error_len() { - Some(invalid_sequence_length) => { - break (BytesSource::BufRead(invalid_sequence_length), Err(())); - } - None => { - self.bytes_consumed = buf.len(); - self.incomplete = Incomplete::new(buf); - // need more input bytes - continue; - } + if let Some(invalid_sequence_length) = error.error_len() { + break (BytesSource::BufRead(invalid_sequence_length), Err(())); } + self.bytes_consumed = buf.len(); + self.incomplete = Incomplete::new(buf); + // need more input bytes + continue; } } } else { diff --git a/src/uu/who/src/platform/unix.rs b/src/uu/who/src/platform/unix.rs index 5cd27f26b92..5db18f23e03 100644 --- a/src/uu/who/src/platform/unix.rs +++ b/src/uu/who/src/platform/unix.rs @@ -354,23 +354,20 @@ impl Who { p.push(ut.tty_device().as_str()); let mesg; let last_change; - match p.metadata() { - Ok(meta) => { - #[cfg(all( - not(target_os = "android"), - not(target_os = "freebsd"), - not(target_vendor = "apple") - ))] - let iwgrp = S_IWGRP; - #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))] - let iwgrp = S_IWGRP as u32; - mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' }; - last_change = meta.atime(); - } - _ => { - mesg = '?'; - last_change = 0; - } + if let Ok(meta) = p.metadata() { + #[cfg(all( + not(target_os = "android"), + not(target_os = "freebsd"), + not(target_vendor = "apple") + ))] + let iwgrp = S_IWGRP; + #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))] + let iwgrp = S_IWGRP as u32; + mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' }; + last_change = meta.atime(); + } else { + mesg = '?'; + last_change = 0; } let idle = if last_change == 0 { diff --git a/src/uucore/src/lib/features/format/num_format.rs b/src/uucore/src/lib/features/format/num_format.rs index 1fa07977eec..da263ad96eb 100644 --- a/src/uucore/src/lib/features/format/num_format.rs +++ b/src/uucore/src/lib/features/format/num_format.rs @@ -257,8 +257,8 @@ impl Formatter<&ExtendedBigDecimal> for Float { let mut alignment = self.alignment; - let s = match abs { - ExtendedBigDecimal::BigDecimal(bd) => match self.variant { + let s = if let ExtendedBigDecimal::BigDecimal(bd) = abs { + match self.variant { FloatVariant::Decimal => { format_float_decimal(&bd, self.precision, self.force_decimal) } @@ -271,14 +271,13 @@ impl Formatter<&ExtendedBigDecimal> for Float { FloatVariant::Hexadecimal => { format_float_hexadecimal(&bd, self.precision, self.case, self.force_decimal) } - }, - _ => { - // Pad non-finite numbers with spaces, not zeros. - if alignment == NumberAlignment::RightZero { - alignment = NumberAlignment::RightSpace; - } - format_float_non_finite(&abs, self.case) } + } else { + // Pad non-finite numbers with spaces, not zeros. + if alignment == NumberAlignment::RightZero { + alignment = NumberAlignment::RightSpace; + } + format_float_non_finite(&abs, self.case) }; let sign_indicator = get_sign_indicator(self.positive_sign, negative); diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs index 8d307b53cd0..3c3ac52ad36 100644 --- a/src/uucore/src/lib/features/fsext.rs +++ b/src/uucore/src/lib/features/fsext.rs @@ -900,15 +900,14 @@ pub fn statfs(path: &OsStr) -> Result { Ok(p) => { let mut buffer: StatFs = unsafe { mem::zeroed() }; unsafe { - match statfs_fn(p.as_ptr(), &raw mut buffer) { - 0 => Ok(buffer), - _ => { - let errno = IOError::last_os_error().raw_os_error().unwrap_or(0); - Err(CStr::from_ptr(strerror(errno)) - .to_str() - .map_err(|_| "Error message contains invalid UTF-8".to_owned())? - .to_owned()) - } + if statfs_fn(p.as_ptr(), &raw mut buffer) == 0 { + Ok(buffer) + } else { + let errno = IOError::last_os_error().raw_os_error().unwrap_or(0); + Err(CStr::from_ptr(strerror(errno)) + .to_str() + .map_err(|_| "Error message contains invalid UTF-8".to_owned())? + .to_owned()) } } } diff --git a/src/uucore/src/lib/features/time.rs b/src/uucore/src/lib/features/time.rs index d6f44434f78..bc5d9ec665d 100644 --- a/src/uucore/src/lib/features/time.rs +++ b/src/uucore/src/lib/features/time.rs @@ -57,33 +57,32 @@ pub fn format_system_time( mode: FormatSystemTimeFallback, ) -> UResult<()> { let zoned: Result = time.try_into(); - match zoned { - Ok(zoned) => format_zoned(out, zoned, fmt), - Err(_) => { - // Assume that if we cannot build a Zoned element, the timestamp is - // out of reasonable range, just print it then. - // TODO: The range allowed by jiff is different from what GNU accepts, - // but it still far enough in the future/past to be unlikely to matter: - // jiff: Year between -9999 to 9999 (UTC) [-377705023201..=253402207200] - // GNU: Year fits in signed 32 bits (timezone dependent) - let (mut secs, mut nsecs) = system_time_to_sec(time); - match mode { - FormatSystemTimeFallback::Integer => out.write_all(secs.to_string().as_bytes())?, - FormatSystemTimeFallback::IntegerError => { - let str = secs.to_string(); - show_error!("time '{str}' is out of range"); - out.write_all(str.as_bytes())?; - } - FormatSystemTimeFallback::Float => { - if secs < 0 && nsecs != 0 { - secs -= 1; - nsecs = 1_000_000_000 - nsecs; - } - out.write_fmt(format_args!("{secs}.{nsecs:09}"))?; + if let Ok(zoned) = zoned { + format_zoned(out, zoned, fmt) + } else { + // Assume that if we cannot build a Zoned element, the timestamp is + // out of reasonable range, just print it then. + // TODO: The range allowed by jiff is different from what GNU accepts, + // but it still far enough in the future/past to be unlikely to matter: + // jiff: Year between -9999 to 9999 (UTC) [-377705023201..=253402207200] + // GNU: Year fits in signed 32 bits (timezone dependent) + let (mut secs, mut nsecs) = system_time_to_sec(time); + match mode { + FormatSystemTimeFallback::Integer => out.write_all(secs.to_string().as_bytes())?, + FormatSystemTimeFallback::IntegerError => { + let str = secs.to_string(); + show_error!("time '{str}' is out of range"); + out.write_all(str.as_bytes())?; + } + FormatSystemTimeFallback::Float => { + if secs < 0 && nsecs != 0 { + secs -= 1; + nsecs = 1_000_000_000 - nsecs; } + out.write_fmt(format_args!("{secs}.{nsecs:09}"))?; } - Ok(()) } + Ok(()) } } diff --git a/src/uucore/src/lib/mods/locale.rs b/src/uucore/src/lib/mods/locale.rs index 0b92b7bfc19..b670f897620 100644 --- a/src/uucore/src/lib/mods/locale.rs +++ b/src/uucore/src/lib/mods/locale.rs @@ -412,24 +412,21 @@ pub fn setup_localization(p: &str) -> Result<(), LocalizationError> { }); // Load common strings along with utility-specific strings - match get_locales_dir(p) { - Ok(locales_dir) => { - // Load both utility-specific and common strings - init_localization(&locale, &locales_dir, p) - } - Err(_) => { - // No locales directory found, use embedded English with common strings directly - let default_locale = LanguageIdentifier::from_str(DEFAULT_LOCALE) - .expect("Default locale should always be valid"); - let english_bundle = create_english_bundle_from_embedded(&default_locale, p)?; - let localizer = Localizer::new(english_bundle); - - LOCALIZER.with(|lock| { - lock.set(localizer) - .map_err(|_| LocalizationError::Bundle("Localizer already initialized".into())) - })?; - Ok(()) - } + if let Ok(locales_dir) = get_locales_dir(p) { + // Load both utility-specific and common strings + init_localization(&locale, &locales_dir, p) + } else { + // No locales directory found, use embedded English with common strings directly + let default_locale = LanguageIdentifier::from_str(DEFAULT_LOCALE) + .expect("Default locale should always be valid"); + let english_bundle = create_english_bundle_from_embedded(&default_locale, p)?; + let localizer = Localizer::new(english_bundle); + + LOCALIZER.with(|lock| { + lock.set(localizer) + .map_err(|_| LocalizationError::Bundle("Localizer already initialized".into())) + })?; + Ok(()) } }