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

Convert all try!() to ?

Browse source
This commit is contained in:
Alex Lyon 2019-04-28 02:00:19 -07:00
parent c851e00dbd
commit c7d115b1ad
13 changed files with 34 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/chmod/chmod.rs
View file

@ -196,7 +196,7 @@ impl Chmoder {
}
};
match self.fmode {
Some(mode) => try!(self.change_file(fperm, mode, file, name)),
Some(mode) => self.change_file(fperm, mode, file, name)?,
None => {
let cmode_unwrapped = self.cmode.clone().unwrap();
for mode in cmode_unwrapped.split(',') {
@ -209,7 +209,7 @@ impl Chmoder {
};
match result {
Ok(mode) => {
try!(self.change_file(fperm, mode, file, name));
self.change_file(fperm, mode, file, name)?;
fperm = mode;
}
Err(f) => {

2
src/cksum/cksum.rs
View file

@ -58,7 +58,7 @@ fn cksum(fname: &str) -> io::Result<(u32, usize)> {
let mut rd: Box<Read> = match fname {
"-" => Box::new(stdin()),
_ => {
file = try!(File::open(&Path::new(fname)));
file = File::open(&Path::new(fname))?;
Box::new(BufReader::new(file))
}
};

2
src/comm/comm.rs
View file

@ -117,7 +117,7 @@ fn open_file(name: &str) -> io::Result<LineReader> {
match name {
"-" => Ok(LineReader::Stdin(stdin())),
_ => {
let f = try!(File::open(&Path::new(name)));
let f = File::open(&Path::new(name))?;
Ok(LineReader::FileIn(BufReader::new(f)))
}
}

4
src/cp/cp.rs
View file

@ -1179,8 +1179,8 @@ pub fn localize_to_target(root: &Path, source: &Path, target: &Path) -> CopyResu
pub fn paths_refer_to_same_file(p1: &Path, p2: &Path) -> io::Result<bool> {
// We have to take symlinks and relative paths into account.
let pathbuf1 = try!(canonicalize(p1, CanonicalizeMode::Normal));
let pathbuf2 = try!(canonicalize(p2, CanonicalizeMode::Normal));
let pathbuf1 = canonicalize(p1, CanonicalizeMode::Normal)?;
let pathbuf2 = canonicalize(p2, CanonicalizeMode::Normal)?;
Ok(pathbuf1 == pathbuf2)
}

10
src/ln/ln.rs
View file

@ -269,9 +269,9 @@ fn link(src: &PathBuf, dst: &PathBuf, settings: &Settings) -> Result<()> {
if !read_yes() {
return Ok(());
}
try!(fs::remove_file(dst))
fs::remove_file(dst)?
}
OverwriteMode::Force => try!(fs::remove_file(dst)),
OverwriteMode::Force => fs::remove_file(dst)?,
};
backup_path = match settings.backup {
@ -281,14 +281,14 @@ fn link(src: &PathBuf, dst: &PathBuf, settings: &Settings) -> Result<()> {
BackupMode::ExistingBackup => Some(existing_backup_path(dst, &settings.suffix)),
};
if let Some(ref p) = backup_path {
try!(fs::rename(dst, p));
fs::rename(dst, p)?;
}
}
if settings.symbolic {
try!(symlink(src, dst));
symlink(src, dst)?;
} else {
try!(fs::hard_link(src, dst));
fs::hard_link(src, dst)?;
}
if settings.verbose {

6
src/od/formatteriteminfo.rs
View file

@ -33,15 +33,15 @@ impl fmt::Debug for FormatWriter {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&FormatWriter::IntWriter(ref p) => {
try!(f.write_str("IntWriter:"));
f.write_str("IntWriter:")?;
fmt::Pointer::fmt(p, f)
}
&FormatWriter::FloatWriter(ref p) => {
try!(f.write_str("FloatWriter:"));
f.write_str("FloatWriter:")?;
fmt::Pointer::fmt(p, f)
}
&FormatWriter::MultibyteWriter(ref p) => {
try!(f.write_str("MultibyteWriter:"));
f.write_str("MultibyteWriter:")?;
fmt::Pointer::fmt(&(*p as *const ()), f)
}
}

12
src/shred/shred.rs
View file

@ -491,24 +491,24 @@ fn do_pass(
given_file_size: Option<u64>,
exact: bool,
) -> Result<(), io::Error> {
try!(file.seek(SeekFrom::Start(0)));
file.seek(SeekFrom::Start(0))?;
// Use the given size or the whole file if not specified
let size: u64 = given_file_size.unwrap_or(try!(get_file_size(path)));
let size: u64 = given_file_size.unwrap_or(get_file_size(path)?);
let generator = BytesGenerator::new(size, generator_type, exact);
for block in generator {
try!(file.write_all(&*block));
file.write_all(&*block)?;
}
try!(file.sync_data());
file.sync_data()?;
Ok(())
}
fn get_file_size(path: &Path) -> Result<u64, io::Error> {
let size: u64 = try!(fs::metadata(path)).len();
let size: u64 = fs::metadata(path)?.len();
Ok(size)
}
@ -574,7 +574,7 @@ fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::
let renamed_path: Option<PathBuf> = wipe_name(&path, verbose);
match renamed_path {
Some(rp) => {
try!(fs::remove_file(rp));
fs::remove_file(rp)?;
}
None => (),
}

2
src/stat/stat.rs
View file

@ -468,7 +468,7 @@ impl Stater {
let default_tokens = if fmtstr.is_empty() {
Stater::generate_tokens(&Stater::default_fmt(showfs, terse, false), use_printf).unwrap()
} else {
try!(Stater::generate_tokens(&fmtstr, use_printf))
Stater::generate_tokens(&fmtstr, use_printf)?
};
let default_dev_tokens =
Stater::generate_tokens(&Stater::default_fmt(showfs, terse, true), use_printf).unwrap();

6
src/stdbuf/stdbuf.rs
View file

@ -172,9 +172,9 @@ fn parse_options(
return Ok(OkMsg::Version);
}
let mut modified = false;
options.stdin = try!(check_option(&matches, "input", &mut modified).ok_or(ErrMsg::Fatal));
options.stdout = try!(check_option(&matches, "output", &mut modified).ok_or(ErrMsg::Fatal));
options.stderr = try!(check_option(&matches, "error", &mut modified).ok_or(ErrMsg::Fatal));
options.stdin = check_option(&matches, "input", &mut modified).ok_or(ErrMsg::Fatal)?;
options.stdout = check_option(&matches, "output", &mut modified).ok_or(ErrMsg::Fatal)?;
options.stderr = check_option(&matches, "error", &mut modified).ok_or(ErrMsg::Fatal)?;
if matches.free.len() != 1 {
return Err(ErrMsg::Retry);

2
src/sum/sum.rs
View file

@ -68,7 +68,7 @@ fn open(name: &str) -> Result<Box<Read>> {
match name {
"-" => Ok(Box::new(stdin()) as Box<Read>),
_ => {
let f = try!(File::open(&Path::new(name)));
let f = File::open(&Path::new(name))?;
Ok(Box::new(f) as Box<Read>)
}
}

4
src/tee/tee.rs Executable file → Normal file
View file

@ -131,14 +131,14 @@ struct MultiWriter {
impl Write for MultiWriter {
fn write(&mut self, buf: &[u8]) -> Result<usize> {
for writer in &mut self.writers {
try!(writer.write_all(buf));
writer.write_all(buf)?;
}
Ok(buf.len())
}
fn flush(&mut self) -> Result<()> {
for writer in &mut self.writers {
try!(writer.flush());
writer.flush()?;
}
Ok(())
}

2
src/wc/wc.rs
View file

@ -144,7 +144,7 @@ fn wc(files: Vec<String>, settings: &Settings) -> StdResult<(), i32> {
let mut max_width: usize = 0;
for path in &files {
let mut reader = try!(open(&path[..]));
let mut reader = open(&path[..])?;
let mut line_count: usize = 0;
let mut word_count: usize = 0;

12
tests/common/util.rs Executable file → Normal file
View file

@ -162,16 +162,16 @@ pub fn log_info<T: AsRef<str>, U: AsRef<str>>(msg: T, par: U) {
}
pub fn recursive_copy(src: &Path, dest: &Path) -> Result<()> {
if try!(fs::metadata(src)).is_dir() {
if fs::metadata(src)?.is_dir() {
for entry in try!(fs::read_dir(src)) {
let entry = try!(entry);
let entry = entry?;
let mut new_dest = PathBuf::from(dest);
new_dest.push(entry.file_name());
if try!(fs::metadata(entry.path())).is_dir() {
try!(fs::create_dir(&new_dest));
try!(recursive_copy(&entry.path(), &new_dest));
if fs::metadata(entry.path())?.is_dir() {
fs::create_dir(&new_dest)?;
recursive_copy(&entry.path(), &new_dest)?;
} else {
try!(fs::copy(&entry.path(), new_dest));
fs::copy(&entry.path(), new_dest)?;
}
}
}