RGBCube/uutils-coreutils
1
Fork 0
mirror of https://github.com/RGBCube/uutils-coreutils synced 2025-07-27 11:07:44 +00:00
Code Issues Activity

fix some clippy warnings (#4229)

Browse source 
* fix some clippy warnings

* Fix the last two
This commit is contained in:
Sylvestre Ledru 2022-12-14 15:42:07 +01:00 • committed by GitHub
parent e4bed1c087
commit c5728a61b4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 73 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

22
build.rs
View file

@ -7,7 +7,7 @@ use std::path::Path;
pub fn main() { pub fn main() {
if let Ok(profile) = env::var("PROFILE") { if let Ok(profile) = env::var("PROFILE") {
println!("cargo:rustc-cfg=build={:?}", profile); println!("cargo:rustc-cfg=build={profile:?}");
} }
const ENV_FEATURE_PREFIX: &str = "CARGO_FEATURE_"; const ENV_FEATURE_PREFIX: &str = "CARGO_FEATURE_";
@ -45,7 +45,7 @@ pub fn main() {
let mut phf_map = phf_codegen::Map::<&str>::new(); let mut phf_map = phf_codegen::Map::<&str>::new();
for krate in &crates { for krate in &crates {
let map_value = format!("({krate}::uumain, {krate}::uu_app)", krate = krate); let map_value = format!("({krate}::uumain, {krate}::uu_app)");
match krate.as_ref() { match krate.as_ref() {
// 'test' is named uu_test to avoid collision with rust core crate 'test'. // 'test' is named uu_test to avoid collision with rust core crate 'test'.
// It can also be invoked by name '[' for the '[ expr ] syntax'. // It can also be invoked by name '[' for the '[ expr ] syntax'.
@ -57,22 +57,14 @@ pub fn main() {
phf_map.entry(&k[OVERRIDE_PREFIX.len()..], &map_value); phf_map.entry(&k[OVERRIDE_PREFIX.len()..], &map_value);
} }
"false" | "true" => { "false" | "true" => {
phf_map.entry( phf_map.entry(krate, &format!("(r#{krate}::uumain, r#{krate}::uu_app)"));
krate,
&format!("(r#{krate}::uumain, r#{krate}::uu_app)", krate = krate),
);
} }
"hashsum" => { "hashsum" => {
phf_map.entry( phf_map.entry(krate, &format!("({krate}::uumain, {krate}::uu_app_custom)"));
krate,
&format!("({krate}::uumain, {krate}::uu_app_custom)", krate = krate),
);
let map_value = format!("({krate}::uumain, {krate}::uu_app_common)", krate = krate); let map_value = format!("({krate}::uumain, {krate}::uu_app_common)");
let map_value_bits = let map_value_bits = format!("({krate}::uumain, {krate}::uu_app_bits)");
format!("({krate}::uumain, {krate}::uu_app_bits)", krate = krate); let map_value_b3sum = format!("({krate}::uumain, {krate}::uu_app_b3sum)");
let map_value_b3sum =
format!("({krate}::uumain, {krate}::uu_app_b3sum)", krate = krate);
phf_map.entry("md5sum", &map_value); phf_map.entry("md5sum", &map_value);
phf_map.entry("sha1sum", &map_value); phf_map.entry("sha1sum", &map_value);
phf_map.entry("sha224sum", &map_value); phf_map.entry("sha224sum", &map_value);

6
src/bin/coreutils.rs
View file

@ -20,8 +20,8 @@ const VERSION: &str = env!("CARGO_PKG_VERSION");
include!(concat!(env!("OUT_DIR"), "/uutils_map.rs")); include!(concat!(env!("OUT_DIR"), "/uutils_map.rs"));
fn usage<T>(utils: &UtilityMap<T>, name: &str) { fn usage<T>(utils: &UtilityMap<T>, name: &str) {
println!("{} {} (multi-call binary)\n", name, VERSION); println!("{name} {VERSION} (multi-call binary)\n");
println!("Usage: {} [function [arguments...]]\n", name); println!("Usage: {name} [function [arguments...]]\n");
println!("Currently defined functions:\n"); println!("Currently defined functions:\n");
#[allow(clippy::map_clone)] #[allow(clippy::map_clone)]
let mut utils: Vec<&str> = utils.keys().map(|&s| s).collect(); let mut utils: Vec<&str> = utils.keys().map(|&s| s).collect();
@ -153,7 +153,7 @@ fn gen_completions<T: uucore::Args>(
.get_matches_from(std::iter::once(OsString::from("completion")).chain(args)); .get_matches_from(std::iter::once(OsString::from("completion")).chain(args));
let utility = matches.get_one::<String>("utility").unwrap(); let utility = matches.get_one::<String>("utility").unwrap();
let shell = matches.get_one::<Shell>("shell").unwrap().to_owned(); let shell = *matches.get_one::<Shell>("shell").unwrap();
let mut command = if utility == "coreutils" { let mut command = if utility == "coreutils" {
gen_coreutils_app(util_map) gen_coreutils_app(util_map)

2
tests/common/macros.rs
View file

@ -3,7 +3,7 @@
// * For the full copyright and license information, please view the LICENSE // * For the full copyright and license information, please view the LICENSE
// * file that was distributed with this source code. // * file that was distributed with this source code.
/// Platform-independent helper for constructing a PathBuf from individual elements /// Platform-independent helper for constructing a `PathBuf` from individual elements
#[macro_export] #[macro_export]
macro_rules! path_concat { macro_rules! path_concat {
($e:expr, ..$n:expr) => {{ ($e:expr, ..$n:expr) => {{

122
tests/common/util.rs
View file

@ -147,7 +147,7 @@ impl CmdResult {
} }
/// Returns the program's exit code /// Returns the program's exit code
/// Panics if not run or has not finished yet for example when run with run_no_wait() /// Panics if not run or has not finished yet for example when run with `run_no_wait()`
pub fn code(&self) -> i32 { pub fn code(&self) -> i32 {
self.code self.code
.expect("Program must be run first or has not finished, yet") .expect("Program must be run first or has not finished, yet")
@ -158,7 +158,7 @@ impl CmdResult {
self self
} }
/// Returns the program's TempDir /// Returns the program's `TempDir`
/// Panics if not present /// Panics if not present
pub fn tmpd(&self) -> Rc<TempDir> { pub fn tmpd(&self) -> Rc<TempDir> {
match &self.tmpd { match &self.tmpd {
@ -201,7 +201,7 @@ impl CmdResult {
} }
/// asserts that the command resulted in empty (zero-length) stderr stream output /// asserts that the command resulted in empty (zero-length) stderr stream output
/// generally, it's better to use stdout_only() instead, /// generally, it's better to use `stdout_only()` instead,
/// but you might find yourself using this function if /// but you might find yourself using this function if
/// 1. you can not know exactly what stdout will be or /// 1. you can not know exactly what stdout will be or
/// 2. you know that stdout will also be empty /// 2. you know that stdout will also be empty
@ -215,8 +215,8 @@ impl CmdResult {
} }
/// asserts that the command resulted in empty (zero-length) stderr stream output /// asserts that the command resulted in empty (zero-length) stderr stream output
/// unless asserting there was neither stdout or stderr, stderr_only is usually a better choice /// unless asserting there was neither stdout or stderr, `stderr_only` is usually a better choice
/// generally, it's better to use stderr_only() instead, /// generally, it's better to use `stderr_only()` instead,
/// but you might find yourself using this function if /// but you might find yourself using this function if
/// 1. you can not know exactly what stderr will be or /// 1. you can not know exactly what stderr will be or
/// 2. you know that stderr will also be empty /// 2. you know that stderr will also be empty
@ -236,7 +236,7 @@ impl CmdResult {
/// asserts that the command resulted in stdout stream output that equals the /// asserts that the command resulted in stdout stream output that equals the
/// passed in value, trailing whitespace are kept to force strict comparison (#1235) /// passed in value, trailing whitespace are kept to force strict comparison (#1235)
/// stdout_only is a better choice unless stderr may or will be non-empty /// `stdout_only()` is a better choice unless stderr may or will be non-empty
pub fn stdout_is<T: AsRef<str>>(&self, msg: T) -> &Self { pub fn stdout_is<T: AsRef<str>>(&self, msg: T) -> &Self {
assert_eq!(self.stdout_str(), String::from(msg.as_ref())); assert_eq!(self.stdout_str(), String::from(msg.as_ref()));
self self
@ -244,13 +244,12 @@ impl CmdResult {
/// like `stdout_is`, but succeeds if any elements of `expected` matches stdout. /// like `stdout_is`, but succeeds if any elements of `expected` matches stdout.
pub fn stdout_is_any<T: AsRef<str> + std::fmt::Debug>(&self, expected: &[T]) -> &Self { pub fn stdout_is_any<T: AsRef<str> + std::fmt::Debug>(&self, expected: &[T]) -> &Self {
if !expected.iter().any(|msg| self.stdout_str() == msg.as_ref()) { assert!(
panic!( expected.iter().any(|msg| self.stdout_str() == msg.as_ref()),
"stdout was {}\nExpected any of {:#?}", "stdout was {}\nExpected any of {:#?}",
self.stdout_str(), self.stdout_str(),
expected expected
); );
}
self self
} }
@ -268,7 +267,7 @@ impl CmdResult {
self self
} }
/// like stdout_is(...), but expects the contents of the file at the provided relative path /// like `stdout_is()`, but expects the contents of the file at the provided relative path
pub fn stdout_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self { pub fn stdout_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
let contents = read_scenario_fixture(&self.tmpd, file_rel_path); let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
self.stdout_is(String::from_utf8(contents).unwrap()) self.stdout_is(String::from_utf8(contents).unwrap())
@ -295,7 +294,7 @@ impl CmdResult {
self.stdout_is_bytes(contents) self.stdout_is_bytes(contents)
} }
/// like stdout_is_fixture(...), but replaces the data in fixture file based on values provided in template_vars /// like `stdout_is_fixture()`, but replaces the data in fixture file based on values provided in `template_vars`
/// command output /// command output
pub fn stdout_is_templated_fixture<T: AsRef<OsStr>>( pub fn stdout_is_templated_fixture<T: AsRef<OsStr>>(
&self, &self,
@ -329,7 +328,7 @@ impl CmdResult {
/// asserts that the command resulted in stderr stream output that equals the /// asserts that the command resulted in stderr stream output that equals the
/// passed in value, when both are trimmed of trailing whitespace /// passed in value, when both are trimmed of trailing whitespace
/// stderr_only is a better choice unless stdout may or will be non-empty /// `stderr_only` is a better choice unless stdout may or will be non-empty
pub fn stderr_is<T: AsRef<str>>(&self, msg: T) -> &Self { pub fn stderr_is<T: AsRef<str>>(&self, msg: T) -> &Self {
assert_eq!( assert_eq!(
self.stderr_str().trim_end(), self.stderr_str().trim_end(),
@ -345,7 +344,7 @@ impl CmdResult {
self self
} }
/// Like stdout_is_fixture, but for stderr /// Like `stdout_is_fixture`, but for stderr
pub fn stderr_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self { pub fn stderr_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
let contents = read_scenario_fixture(&self.tmpd, file_rel_path); let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
self.stderr_is(String::from_utf8(contents).unwrap()) self.stderr_is(String::from_utf8(contents).unwrap())
@ -367,7 +366,7 @@ impl CmdResult {
self.no_stderr().stdout_is_bytes(msg) self.no_stderr().stdout_is_bytes(msg)
} }
/// like stdout_only(...), but expects the contents of the file at the provided relative path /// like `stdout_only()`, but expects the contents of the file at the provided relative path
pub fn stdout_only_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self { pub fn stdout_only_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
let contents = read_scenario_fixture(&self.tmpd, file_rel_path); let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
self.stdout_only_bytes(contents) self.stdout_only_bytes(contents)
@ -399,8 +398,8 @@ impl CmdResult {
/// 1. the command resulted in stderr stream output that equals the /// 1. the command resulted in stderr stream output that equals the
/// the following format when both are trimmed of trailing whitespace /// the following format when both are trimmed of trailing whitespace
/// `"{util_name}: {msg}\nTry '{bin_path} {util_name} --help' for more information."` /// `"{util_name}: {msg}\nTry '{bin_path} {util_name} --help' for more information."`
/// This the expected format when a UUsageError is returned or when show_error! is called /// This the expected format when a `UUsageError` is returned or when `show_error!` is called
/// `msg` should be the same as the one provided to UUsageError::new or show_error! /// `msg` should be the same as the one provided to `UUsageError::new` or `show_error!`
/// ///
/// 2. the command resulted in empty (zero-length) stdout stream output /// 2. the command resulted in empty (zero-length) stdout stream output
pub fn usage_error<T: AsRef<str>>(&self, msg: T) -> &Self { pub fn usage_error<T: AsRef<str>>(&self, msg: T) -> &Self {
@ -448,16 +447,20 @@ impl CmdResult {
} }
pub fn stdout_matches(&self, regex: &regex::Regex) -> &Self { pub fn stdout_matches(&self, regex: &regex::Regex) -> &Self {
if !regex.is_match(self.stdout_str().trim()) { assert!(
panic!("Stdout does not match regex:\n{}", self.stdout_str()); regex.is_match(self.stdout_str().trim()),
} "Stdout does not match regex:\n{}",
self.stdout_str()
);
self self
} }
pub fn stdout_does_not_match(&self, regex: &regex::Regex) -> &Self { pub fn stdout_does_not_match(&self, regex: &regex::Regex) -> &Self {
if regex.is_match(self.stdout_str().trim()) { assert!(
panic!("Stdout matches regex:\n{}", self.stdout_str()); !regex.is_match(self.stdout_str().trim()),
} "Stdout matches regex:\n{}",
self.stdout_str()
);
self self
} }
} }
@ -552,7 +555,7 @@ impl AtPath {
let mut f = self.open(name); let mut f = self.open(name);
let mut contents = String::new(); let mut contents = String::new();
f.read_to_string(&mut contents) f.read_to_string(&mut contents)
.unwrap_or_else(|e| panic!("Couldn't read {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't read {name}: {e}"));
contents contents
} }
@ -560,20 +563,20 @@ impl AtPath {
let mut f = self.open(name); let mut f = self.open(name);
let mut contents = Vec::new(); let mut contents = Vec::new();
f.read_to_end(&mut contents) f.read_to_end(&mut contents)
.unwrap_or_else(|e| panic!("Couldn't read {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't read {name}: {e}"));
contents contents
} }
pub fn write(&self, name: &str, contents: &str) { pub fn write(&self, name: &str, contents: &str) {
log_info("write(default)", self.plus_as_string(name)); log_info("write(default)", self.plus_as_string(name));
std::fs::write(self.plus(name), contents) std::fs::write(self.plus(name), contents)
.unwrap_or_else(|e| panic!("Couldn't write {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't write {name}: {e}"));
} }
pub fn write_bytes(&self, name: &str, contents: &[u8]) { pub fn write_bytes(&self, name: &str, contents: &[u8]) {
log_info("write(default)", self.plus_as_string(name)); log_info("write(default)", self.plus_as_string(name));
std::fs::write(self.plus(name), contents) std::fs::write(self.plus(name), contents)
.unwrap_or_else(|e| panic!("Couldn't write {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't write {name}: {e}"));
} }
pub fn append(&self, name: &str, contents: &str) { pub fn append(&self, name: &str, contents: &str) {
@ -585,7 +588,7 @@ impl AtPath {
.open(self.plus(name)) .open(self.plus(name))
.unwrap(); .unwrap();
f.write_all(contents.as_bytes()) f.write_all(contents.as_bytes())
.unwrap_or_else(|e| panic!("Couldn't write(append) {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't write(append) {name}: {e}"));
} }
pub fn append_bytes(&self, name: &str, contents: &[u8]) { pub fn append_bytes(&self, name: &str, contents: &[u8]) {
@ -597,7 +600,7 @@ impl AtPath {
.open(self.plus(name)) .open(self.plus(name))
.unwrap(); .unwrap();
f.write_all(contents) f.write_all(contents)
.unwrap_or_else(|e| panic!("Couldn't write(append) to {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't write(append) to {name}: {e}"));
} }
pub fn truncate(&self, name: &str, contents: &str) { pub fn truncate(&self, name: &str, contents: &str) {
@ -609,30 +612,29 @@ impl AtPath {
.open(self.plus(name)) .open(self.plus(name))
.unwrap(); .unwrap();
f.write_all(contents.as_bytes()) f.write_all(contents.as_bytes())
.unwrap_or_else(|e| panic!("Couldn't write(truncate) {}: {}", name, e)); .unwrap_or_else(|e| panic!("Couldn't write(truncate) {name}: {e}"));
} }
pub fn rename(&self, source: &str, target: &str) { pub fn rename(&self, source: &str, target: &str) {
let source = self.plus(source); let source = self.plus(source);
let target = self.plus(target); let target = self.plus(target);
log_info("rename", format!("{:?} {:?}", source, target)); log_info("rename", format!("{source:?} {target:?}"));
std::fs::rename(&source, &target) std::fs::rename(&source, &target)
.unwrap_or_else(|e| panic!("Couldn't rename {:?} -> {:?}: {}", source, target, e)); .unwrap_or_else(|e| panic!("Couldn't rename {source:?} -> {target:?}: {e}"));
} }
pub fn remove(&self, source: &str) { pub fn remove(&self, source: &str) {
let source = self.plus(source); let source = self.plus(source);
log_info("remove", format!("{:?}", source)); log_info("remove", format!("{source:?}"));
std::fs::remove_file(&source) std::fs::remove_file(&source).unwrap_or_else(|e| panic!("Couldn't remove {source:?}: {e}"));
.unwrap_or_else(|e| panic!("Couldn't remove {:?}: {}", source, e));
} }
pub fn copy(&self, source: &str, target: &str) { pub fn copy(&self, source: &str, target: &str) {
let source = self.plus(source); let source = self.plus(source);
let target = self.plus(target); let target = self.plus(target);
log_info("copy", format!("{:?} {:?}", source, target)); log_info("copy", format!("{source:?} {target:?}"));
std::fs::copy(&source, &target) std::fs::copy(&source, &target)
.unwrap_or_else(|e| panic!("Couldn't copy {:?} -> {:?}: {}", source, target, e)); .unwrap_or_else(|e| panic!("Couldn't copy {source:?} -> {target:?}: {e}"));
} }
pub fn rmdir(&self, dir: &str) { pub fn rmdir(&self, dir: &str) {
@ -959,7 +961,7 @@ impl UCommand {
env_clear: bool, env_clear: bool,
) -> Self { ) -> Self {
let bin_path = bin_path.as_ref(); let bin_path = bin_path.as_ref();
let util_name = util_name.as_ref().map(|un| un.as_ref()); let util_name = util_name.as_ref().map(std::convert::AsRef::as_ref);
let mut ucmd = Self { let mut ucmd = Self {
tmpd: None, tmpd: None,
@ -1079,7 +1081,7 @@ impl UCommand {
self self
} }
/// like pipe_in(...), but uses the contents of the file at the provided relative path as the piped in data /// like `pipe_in()`, but uses the contents of the file at the provided relative path as the piped in data
pub fn pipe_in_fixture<S: AsRef<OsStr>>(&mut self, file_rel_path: S) -> &mut Self { pub fn pipe_in_fixture<S: AsRef<OsStr>>(&mut self, file_rel_path: S) -> &mut Self {
let contents = read_scenario_fixture(&self.tmpd, file_rel_path); let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
self.pipe_in(contents) self.pipe_in(contents)
@ -1192,7 +1194,7 @@ impl UCommand {
/// Spawns the command, feeding the passed in stdin, waits for the result /// Spawns the command, feeding the passed in stdin, waits for the result
/// and returns a command result. /// and returns a command result.
/// It is recommended that, instead of this, you use a combination of pipe_in() /// It is recommended that, instead of this, you use a combination of `pipe_in()`
/// with succeeds() or fails() /// with succeeds() or fails()
pub fn run_piped_stdin<T: Into<Vec<u8>>>(&mut self, input: T) -> CmdResult { pub fn run_piped_stdin<T: Into<Vec<u8>>>(&mut self, input: T) -> CmdResult {
self.pipe_in(input).run() self.pipe_in(input).run()
@ -1216,7 +1218,7 @@ impl UCommand {
pub fn get_full_fixture_path(&self, file_rel_path: &str) -> String { pub fn get_full_fixture_path(&self, file_rel_path: &str) -> String {
let tmpdir_path = self.tmpd.as_ref().unwrap().path(); let tmpdir_path = self.tmpd.as_ref().unwrap().path();
format!("{}/{}", tmpdir_path.to_str().unwrap(), file_rel_path) format!("{}/{file_rel_path}", tmpdir_path.to_str().unwrap())
} }
} }
@ -1229,7 +1231,7 @@ struct CapturedOutput {
} }
impl CapturedOutput { impl CapturedOutput {
/// Creates a new instance of CapturedOutput /// Creates a new instance of `CapturedOutput`
fn new(output: tempfile::NamedTempFile) -> Self { fn new(output: tempfile::NamedTempFile) -> Self {
Self { Self {
current_file: output.reopen().unwrap(), current_file: output.reopen().unwrap(),
@ -1411,7 +1413,7 @@ impl<'a> UChildAssertion<'a> {
self.uchild.stderr_all() self.uchild.stderr_all()
), ),
Ok(None) => {} Ok(None) => {}
Err(error) => panic!("Assertion failed with error '{:?}'", error), Err(error) => panic!("Assertion failed with error '{error:?}'"),
} }
self self
@ -1430,7 +1432,7 @@ impl<'a> UChildAssertion<'a> {
self.uchild.stdout_all(), self.uchild.stdout_all(),
self.uchild.stderr_all()), self.uchild.stderr_all()),
Ok(_) => {}, Ok(_) => {},
Err(error) => panic!("Assertion failed with error '{:?}'", error), Err(error) => panic!("Assertion failed with error '{error:?}'"),
} }
self self
@ -1780,7 +1782,7 @@ impl UChild {
match writer.write_all(&content).and_then(|_| writer.flush()) { match writer.write_all(&content).and_then(|_| writer.flush()) {
Err(error) if !ignore_stdin_write_error => Err(io::Error::new( Err(error) if !ignore_stdin_write_error => Err(io::Error::new(
io::ErrorKind::Other, io::ErrorKind::Other,
format!("failed to write to stdin of child: {}", error), format!("failed to write to stdin of child: {error}"),
)), )),
Ok(_) | Err(_) => Ok(()), Ok(_) | Err(_) => Ok(()),
} }
@ -1832,7 +1834,7 @@ impl UChild {
match stdin.write_all(&data.into()).and_then(|_| stdin.flush()) { match stdin.write_all(&data.into()).and_then(|_| stdin.flush()) {
Err(error) if !self.ignore_stdin_write_error => Err(io::Error::new( Err(error) if !self.ignore_stdin_write_error => Err(io::Error::new(
io::ErrorKind::Other, io::ErrorKind::Other,
format!("failed to write to stdin of child: {}", error), format!("failed to write to stdin of child: {error}"),
)), )),
Ok(_) | Err(_) => Ok(()), Ok(_) | Err(_) => Ok(()),
} }
@ -1894,7 +1896,7 @@ pub fn whoami() -> String {
std::env::var("USER") std::env::var("USER")
.or_else(|_| std::env::var("USERNAME")) .or_else(|_| std::env::var("USERNAME"))
.unwrap_or_else(|e| { .unwrap_or_else(|e| {
println!("{}: {}, using \"nobody\" instead", UUTILS_WARNING, e); println!("{UUTILS_WARNING}: {e}, using \"nobody\" instead");
"nobody".to_string() "nobody".to_string()
}) })
} }
@ -1965,33 +1967,33 @@ pub fn check_coreutil_version(
// id (GNU coreutils) 8.32.162-4eda // id (GNU coreutils) 8.32.162-4eda
let util_name = &host_name_for(util_name); let util_name = &host_name_for(util_name);
log_info("run", format!("{} --version", util_name)); log_info("run", format!("{util_name} --version"));
let version_check = match Command::new(util_name.as_ref()) let version_check = match Command::new(util_name.as_ref())
.env("LC_ALL", "C") .env("LC_ALL", "C")
.arg("--version") .arg("--version")
.output() .output()
{ {
Ok(s) => s, Ok(s) => s,
Err(e) => return Err(format!("{}: '{}' {}", UUTILS_WARNING, util_name, e)), Err(e) => return Err(format!("{UUTILS_WARNING}: '{util_name}' {e}")),
}; };
std::str::from_utf8(&version_check.stdout).unwrap() std::str::from_utf8(&version_check.stdout).unwrap()
.split('\n') .split('\n')
.collect::<Vec<_>>() .collect::<Vec<_>>()
.first() .first()
.map_or_else( .map_or_else(
|| Err(format!("{}: unexpected output format for reference coreutil: '{} --version'", UUTILS_WARNING, util_name)), || Err(format!("{UUTILS_WARNING}: unexpected output format for reference coreutil: '{util_name} --version'")),
|s| { |s| {
if s.contains(&format!("(GNU coreutils) {}", version_expected)) { if s.contains(&format!("(GNU coreutils) {version_expected}")) {
Ok(format!("{}: {}", UUTILS_INFO, s)) Ok(format!("{UUTILS_INFO}: {s}"))
} else if s.contains("(GNU coreutils)") { } else if s.contains("(GNU coreutils)") {
let version_found = parse_coreutil_version(s); let version_found = parse_coreutil_version(s);
let version_expected = version_expected.parse::<f32>().unwrap_or_default(); let version_expected = version_expected.parse::<f32>().unwrap_or_default();
if version_found > version_expected { if version_found > version_expected {
Ok(format!("{}: version for the reference coreutil '{}' is higher than expected; expected: {}, found: {}", UUTILS_INFO, util_name, version_expected, version_found)) Ok(format!("{UUTILS_INFO}: version for the reference coreutil '{util_name}' is higher than expected; expected: {version_expected}, found: {version_found}"))
} else { } else {
Err(format!("{}: version for the reference coreutil '{}' does not match; expected: {}, found: {}", UUTILS_WARNING, util_name, version_expected, version_found)) } Err(format!("{UUTILS_WARNING}: version for the reference coreutil '{util_name}' does not match; expected: {version_expected}, found: {version_found}")) }
} else { } else {
Err(format!("{}: no coreutils version string found for reference coreutils '{} --version'", UUTILS_WARNING, util_name)) Err(format!("{UUTILS_WARNING}: no coreutils version string found for reference coreutils '{util_name} --version'"))
} }
}, },
) )
@ -2125,10 +2127,10 @@ pub fn run_ucmd_as_root(
Err("Cannot run non-interactive sudo".to_string()) Err("Cannot run non-interactive sudo".to_string())
} }
Ok(_output) => Err("\"sudo whoami\" didn't return \"root\"".to_string()), Ok(_output) => Err("\"sudo whoami\" didn't return \"root\"".to_string()),
Err(e) => Err(format!("{}: {}", UUTILS_WARNING, e)), Err(e) => Err(format!("{UUTILS_WARNING}: {e}")),
} }
} else { } else {
Err(format!("{}: {}", UUTILS_INFO, "cannot run inside CI")) Err(format!("{UUTILS_INFO}: {}", "cannot run inside CI"))
} }
} }