From 35f3975e174f081afb5f62e3d8ce003c243df292 Mon Sep 17 00:00:00 2001 From: Gabriele Belluardo Date: Tue, 17 Jun 2025 00:24:53 +0200 Subject: [PATCH] fix(clippy): redundant_else --- src/uu/cp/src/cp.rs | 36 ++++---- src/uu/cut/src/cut.rs | 3 +- src/uu/cut/src/matcher.rs | 3 +- src/uu/date/src/date.rs | 132 +++++++++++++-------------- src/uu/dirname/src/dirname.rs | 36 ++++---- src/uu/env/src/env.rs | 8 +- src/uu/fmt/src/linebreak.rs | 3 +- src/uu/pr/src/pr.rs | 3 +- src/uu/sort/src/chunks.rs | 12 +-- src/uu/split/src/split.rs | 42 ++++----- src/uu/tail/src/chunks.rs | 14 +-- src/uucore/src/lib/features/perms.rs | 89 +++++++++--------- 12 files changed, 189 insertions(+), 192 deletions(-) diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs index d2966c5c4..3385e27c1 100644 --- a/src/uu/cp/src/cp.rs +++ b/src/uu/cp/src/cp.rs @@ -1150,9 +1150,8 @@ impl Options { CpError::Error("SELinux was not enabled during the compile time!".to_owned()); if required { return Err(selinux_disabled_error); - } else { - show_error_if_needed(&selinux_disabled_error); } + show_error_if_needed(&selinux_disabled_error); } // Extract the SELinux related flags and options @@ -1925,10 +1924,9 @@ fn handle_existing_dest( source.quote() ) .into()); - } else { - is_dest_removed = dest.is_symlink(); - backup_dest(dest, &backup_path, is_dest_removed)?; } + is_dest_removed = dest.is_symlink(); + backup_dest(dest, &backup_path, is_dest_removed)?; } if !is_dest_removed { delete_dest_if_needed_and_allowed( @@ -2195,21 +2193,21 @@ fn handle_copy_mode( let dest_time = dest_metadata.modified()?; if src_time <= dest_time { return Ok(PerformedAction::Skipped); - } else { - options.overwrite.verify(dest, options.debug)?; - - copy_helper( - source, - dest, - options, - context, - source_is_symlink, - source_is_fifo, - symlinked_files, - #[cfg(unix)] - source_is_stream, - )?; } + + options.overwrite.verify(dest, options.debug)?; + + copy_helper( + source, + dest, + options, + context, + source_is_symlink, + source_is_fifo, + symlinked_files, + #[cfg(unix)] + source_is_stream, + )?; } } } else { diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs index 0c47cfada..c97a6b595 100644 --- a/src/uu/cut/src/cut.rs +++ b/src/uu/cut/src/cut.rs @@ -429,9 +429,8 @@ fn get_delimiters(matches: &ArgMatches) -> UResult<(Delimiter, Option<&[u8]>)> { 1, get_message("cut-error-delimiter-must-be-single-character"), )); - } else { - Delimiter::from(os_string) } + Delimiter::from(os_string) } } None => { diff --git a/src/uu/cut/src/matcher.rs b/src/uu/cut/src/matcher.rs index bb0c44d5b..b42941294 100644 --- a/src/uu/cut/src/matcher.rs +++ b/src/uu/cut/src/matcher.rs @@ -34,9 +34,8 @@ impl Matcher for ExactMatcher<'_> { || haystack[match_idx + 1..].starts_with(&self.needle[1..]) { return Some((match_idx, match_idx + self.needle.len())); - } else { - pos = match_idx + 1; } + pos = match_idx + 1; } None => { return None; diff --git a/src/uu/date/src/date.rs b/src/uu/date/src/date.rs index 379aba67f..5e72c87cf 100644 --- a/src/uu/date/src/date.rs +++ b/src/uu/date/src/date.rs @@ -204,81 +204,81 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { }; return set_system_datetime(date); - } else { - // Get the current time, either in the local time zone or UTC. - let now = if settings.utc { - Timestamp::now().to_zoned(TimeZone::UTC) - } else { - Zoned::now() - }; + } - // Iterate over all dates - whether it's a single date or a file. - let dates: Box> = match settings.date_source { - DateSource::Custom(ref input) => { - let date = parse_date(input); - let iter = std::iter::once(date); - Box::new(iter) - } - DateSource::Human(relative_time) => { - // Double check the result is overflow or not of the current_time + relative_time - // it may cause a panic of chrono::datetime::DateTime add - match now.checked_add(relative_time) { - Ok(date) => { - let iter = std::iter::once(Ok(date)); - Box::new(iter) - } - Err(_) => { - return Err(USimpleError::new( - 1, - format!("invalid date {relative_time}"), - )); - } + // Get the current time, either in the local time zone or UTC. + let now = if settings.utc { + Timestamp::now().to_zoned(TimeZone::UTC) + } else { + Zoned::now() + }; + + // Iterate over all dates - whether it's a single date or a file. + let dates: Box> = match settings.date_source { + DateSource::Custom(ref input) => { + let date = parse_date(input); + let iter = std::iter::once(date); + Box::new(iter) + } + DateSource::Human(relative_time) => { + // Double check the result is overflow or not of the current_time + relative_time + // it may cause a panic of chrono::datetime::DateTime add + match now.checked_add(relative_time) { + Ok(date) => { + let iter = std::iter::once(Ok(date)); + Box::new(iter) } - } - DateSource::Stdin => { - let lines = BufReader::new(std::io::stdin()).lines(); - let iter = lines.map_while(Result::ok).map(parse_date); - Box::new(iter) - } - DateSource::File(ref path) => { - if path.is_dir() { + Err(_) => { return Err(USimpleError::new( - 2, - format!("expected file, got directory {}", path.quote()), + 1, + format!("invalid date {relative_time}"), )); } - let file = File::open(path) - .map_err_context(|| path.as_os_str().to_string_lossy().to_string())?; - let lines = BufReader::new(file).lines(); - let iter = lines.map_while(Result::ok).map(parse_date); - Box::new(iter) } - DateSource::Now => { - let iter = std::iter::once(Ok(now)); - Box::new(iter) + } + DateSource::Stdin => { + let lines = BufReader::new(std::io::stdin()).lines(); + let iter = lines.map_while(Result::ok).map(parse_date); + Box::new(iter) + } + DateSource::File(ref path) => { + if path.is_dir() { + return Err(USimpleError::new( + 2, + format!("expected file, got directory {}", path.quote()), + )); } - }; + let file = File::open(path) + .map_err_context(|| path.as_os_str().to_string_lossy().to_string())?; + let lines = BufReader::new(file).lines(); + let iter = lines.map_while(Result::ok).map(parse_date); + Box::new(iter) + } + DateSource::Now => { + let iter = std::iter::once(Ok(now)); + Box::new(iter) + } + }; - let format_string = make_format_string(&settings); + let format_string = make_format_string(&settings); - // Format all the dates - for date in dates { - match date { - // TODO: Switch to lenient formatting. - Ok(date) => match strtime::format(format_string, &date) { - Ok(s) => println!("{s}"), - Err(e) => { - return Err(USimpleError::new( - 1, - format!("invalid format {format_string} ({e})"), - )); - } - }, - Err((input, _err)) => show!(USimpleError::new( - 1, - format!("invalid date {}", input.quote()) - )), - } + // Format all the dates + for date in dates { + match date { + // TODO: Switch to lenient formatting. + Ok(date) => match strtime::format(format_string, &date) { + Ok(s) => println!("{s}"), + Err(e) => { + return Err(USimpleError::new( + 1, + format!("invalid format {format_string} ({e})"), + )); + } + }, + Err((input, _err)) => show!(USimpleError::new( + 1, + format!("invalid date {}", input.quote()) + )), } } diff --git a/src/uu/dirname/src/dirname.rs b/src/uu/dirname/src/dirname.rs index e7ff417db..a7ae457b6 100644 --- a/src/uu/dirname/src/dirname.rs +++ b/src/uu/dirname/src/dirname.rs @@ -33,27 +33,27 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { if dirnames.is_empty() { return Err(UUsageError::new(1, get_message("dirname-missing-operand"))); - } else { - for path in &dirnames { - let p = Path::new(path); - match p.parent() { - Some(d) => { - if d.components().next().is_none() { - print!("."); - } else { - print_verbatim(d).unwrap(); - } - } - None => { - if p.is_absolute() || path == "/" { - print!("/"); - } else { - print!("."); - } + } + + for path in &dirnames { + let p = Path::new(path); + match p.parent() { + Some(d) => { + if d.components().next().is_none() { + print!("."); + } else { + print_verbatim(d).unwrap(); + } + } + None => { + if p.is_absolute() || path == "/" { + print!("/"); + } else { + print!("."); } } - print!("{line_ending}"); } + print!("{line_ending}"); } Ok(()) diff --git a/src/uu/env/src/env.rs b/src/uu/env/src/env.rs index dbf5f1d56..7bb877b72 100644 --- a/src/uu/env/src/env.rs +++ b/src/uu/env/src/env.rs @@ -594,9 +594,11 @@ impl EnvAppData { match cmd.status() { Ok(exit) if !exit.success() => { #[cfg(unix)] - if let Some(exit_code) = exit.code() { - return Err(exit_code.into()); - } else { + { + if let Some(exit_code) = exit.code() { + return Err(exit_code.into()); + } + // `exit.code()` returns `None` on Unix when the process is terminated by a signal. // See std::os::unix::process::ExitStatusExt for more information. This prints out // the interrupted process and the signal it received. diff --git a/src/uu/fmt/src/linebreak.rs b/src/uu/fmt/src/linebreak.rs index 6c34b0808..143228373 100644 --- a/src/uu/fmt/src/linebreak.rs +++ b/src/uu/fmt/src/linebreak.rs @@ -175,9 +175,8 @@ fn break_knuth_plass<'a, T: Clone + Iterator>>( fresh = true; } break; - } else { - write_with_spaces(word, slen, args.ostream)?; } + write_with_spaces(word, slen, args.ostream)?; } Ok((prev_punct, fresh)) }, diff --git a/src/uu/pr/src/pr.rs b/src/uu/pr/src/pr.rs index 4ca97e784..5219851df 100644 --- a/src/uu/pr/src/pr.rs +++ b/src/uu/pr/src/pr.rs @@ -1086,9 +1086,8 @@ fn write_columns( } if not_found_break && feed_line_present { break; - } else { - out.write_all(line_separator)?; } + out.write_all(line_separator)?; } Ok(lines_printed) diff --git a/src/uu/sort/src/chunks.rs b/src/uu/sort/src/chunks.rs index 18b2547dc..4b8ad4785 100644 --- a/src/uu/sort/src/chunks.rs +++ b/src/uu/sort/src/chunks.rs @@ -287,13 +287,13 @@ fn read_to_buffer( let end = last_line_end.unwrap(); // We want to include the separator here, because it shouldn't be carried over. return Ok((end + 1, true)); - } else { - // We need to read more lines - let len = buffer.len(); - // resize the vector to 10 KB more - buffer.resize(len + 1024 * 10, 0); - read_target = &mut buffer[len..]; } + + // We need to read more lines + let len = buffer.len(); + // resize the vector to 10 KB more + buffer.resize(len + 1024 * 10, 0); + read_target = &mut buffer[len..]; } else { // This file has been fully read. let mut leftover_len = read_target.len(); diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs index e026aaa2e..8736927a1 100644 --- a/src/uu/split/src/split.rs +++ b/src/uu/split/src/split.rs @@ -763,28 +763,28 @@ impl Write for ByteChunkWriter<'_> { let num_bytes_written = custom_write(buf, &mut self.inner, self.settings)?; self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64; return Ok(carryover_bytes_written + num_bytes_written); - } else { - // Write enough bytes to fill the current chunk. - // - // Conversion to usize is safe because we checked that - // self.num_bytes_remaining_in_current_chunk is lower than - // n, which is already usize. - let i = self.num_bytes_remaining_in_current_chunk as usize; - let num_bytes_written = custom_write(&buf[..i], &mut self.inner, self.settings)?; - self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64; - - // It's possible that the underlying writer did not - // write all the bytes. - if num_bytes_written < i { - return Ok(carryover_bytes_written + num_bytes_written); - } else { - // Move the window to look at only the remaining bytes. - buf = &buf[i..]; - - // Remember for the next iteration that we wrote these bytes. - carryover_bytes_written += num_bytes_written; - } } + + // Write enough bytes to fill the current chunk. + // + // Conversion to usize is safe because we checked that + // self.num_bytes_remaining_in_current_chunk is lower than + // n, which is already usize. + let i = self.num_bytes_remaining_in_current_chunk as usize; + let num_bytes_written = custom_write(&buf[..i], &mut self.inner, self.settings)?; + self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64; + + // It's possible that the underlying writer did not + // write all the bytes. + if num_bytes_written < i { + return Ok(carryover_bytes_written + num_bytes_written); + } + + // Move the window to look at only the remaining bytes. + buf = &buf[i..]; + + // Remember for the next iteration that we wrote these bytes. + carryover_bytes_written += num_bytes_written; } } fn flush(&mut self) -> io::Result<()> { diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 7d53b95d4..0811b4306 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -582,13 +582,13 @@ impl LinesChunkBuffer { if self.chunks.is_empty() { // chunks is empty when a file is empty so quitting early here return Ok(()); - } else { - let length = &self.chunks.len(); - let last = &mut self.chunks[length - 1]; - if !last.get_buffer().ends_with(&[self.delimiter]) { - last.lines += 1; - self.lines += 1; - } + } + + let length = &self.chunks.len(); + let last = &mut self.chunks[length - 1]; + if !last.get_buffer().ends_with(&[self.delimiter]) { + last.lines += 1; + self.lines += 1; } // skip unnecessary chunks and save the first chunk which may hold some lines we have to diff --git a/src/uucore/src/lib/features/perms.rs b/src/uucore/src/lib/features/perms.rs index d044fce81..52da95cd1 100644 --- a/src/uucore/src/lib/features/perms.rs +++ b/src/uucore/src/lib/features/perms.rs @@ -113,51 +113,52 @@ pub fn wrap_chown>( } } return Err(out); - } else { - let changed = dest_uid != meta.uid() || dest_gid != meta.gid(); - if changed { - match verbosity.level { - VerbosityLevel::Changes | VerbosityLevel::Verbose => { - let gid = meta.gid(); - out = if verbosity.groups_only { - format!( - "changed group of {} from {} to {}", - path.quote(), - entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()), - entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string()) - ) - } else { - let gid = meta.gid(); - let uid = meta.uid(); - format!( - "changed ownership of {} from {}:{} to {}:{}", - path.quote(), - entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()), - entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()), - entries::uid2usr(dest_uid).unwrap_or_else(|_| dest_uid.to_string()), - entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string()) - ) - }; - } - _ => (), - }; - } else if verbosity.level == VerbosityLevel::Verbose { - out = if verbosity.groups_only { - format!( - "group of {} retained as {}", - path.quote(), - entries::gid2grp(dest_gid).unwrap_or_default() - ) - } else { - format!( - "ownership of {} retained as {}:{}", - path.quote(), - entries::uid2usr(dest_uid).unwrap_or_else(|_| dest_uid.to_string()), - entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string()) - ) - }; - } } + + let changed = dest_uid != meta.uid() || dest_gid != meta.gid(); + if changed { + match verbosity.level { + VerbosityLevel::Changes | VerbosityLevel::Verbose => { + let gid = meta.gid(); + out = if verbosity.groups_only { + format!( + "changed group of {} from {} to {}", + path.quote(), + entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()), + entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string()) + ) + } else { + let gid = meta.gid(); + let uid = meta.uid(); + format!( + "changed ownership of {} from {}:{} to {}:{}", + path.quote(), + entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()), + entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()), + entries::uid2usr(dest_uid).unwrap_or_else(|_| dest_uid.to_string()), + entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string()) + ) + }; + } + _ => (), + }; + } else if verbosity.level == VerbosityLevel::Verbose { + out = if verbosity.groups_only { + format!( + "group of {} retained as {}", + path.quote(), + entries::gid2grp(dest_gid).unwrap_or_default() + ) + } else { + format!( + "ownership of {} retained as {}:{}", + path.quote(), + entries::uid2usr(dest_uid).unwrap_or_else(|_| dest_uid.to_string()), + entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string()) + ) + }; + } + Ok(out) }