This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8955

rhg: fix `clippy` warnings
ClosedPublic

Authored by acezar on Aug 26 2020, 9:23 AM.

Details

Reviewers
marmoute
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGfbc373b7cbc3: rhg: fix `clippy` warnings

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

acezar created this revision.Aug 26 2020, 9:23 AM
acezar retitled this revision from rhg: fix clippy warnings to rhg: fix `clippy` warnings.Aug 26 2020, 9:44 AM
marmoute accepted this revision.Aug 26 2020, 3:23 PM
marmoute added a subscriber: marmoute.

I would have split it by error types, but that seems fine anyway. There are few errors and few different types.

Alphare accepted this revision.Aug 28 2020, 4:19 AM
pulkit accepted this revision.Sep 11 2020, 5:03 AM
This revision is now accepted and ready to land.Sep 11 2020, 5:03 AM
acezar added a commit: rHGfbc373b7cbc3: rhg: fix `clippy` warnings.Sep 11 2020, 5:46 AM
Closed by commit rHGfbc373b7cbc3: rhg: fix `clippy` warnings (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/rhg/src/error.rs (2 lines)
Mrust/rhg/src/ui.rs (22 lines)

Diff 22622

rust/rhg/src/error.rs

/// The error type for the Command trait /// The error type for the Command trait
#[derive(Debug)] #[derive(Debug)]
pub struct CommandError { pub struct CommandError {
pub kind: CommandErrorKind, pub kind: CommandErrorKind,
} }
impl CommandError { impl CommandError {
/// Exist the process with the corresponding exit code. /// Exist the process with the corresponding exit code.
pub fn exit(&self) -> () { pub fn exit(&self) {
std::process::exit(self.kind.get_exit_code()) std::process::exit(self.kind.get_exit_code())
} }
/// Return the message corresponding to the command error if any /// Return the message corresponding to the command error if any
pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> { pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
self.kind.get_error_message_bytes() self.kind.get_error_message_bytes()
} }
} }

rust/rhg/src/ui.rs

pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> { pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
StdoutBuffer::new(self.stdout.lock()) StdoutBuffer::new(self.stdout.lock())
} }
/// Write bytes to stdout /// Write bytes to stdout
pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stdout = self.stdout.lock(); let mut stdout = self.stdout.lock();
stdout stdout.write_all(bytes).or_else(handle_stdout_error)?;
.write_all(bytes)
.or_else(|e| handle_stdout_error(e))?;
stdout.flush().or_else(|e| handle_stdout_error(e)) stdout.flush().or_else(handle_stdout_error)
} }
/// Write bytes to stderr /// Write bytes to stderr
pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stderr = self.stderr.lock(); let mut stderr = self.stderr.lock();
stderr stderr.write_all(bytes).or_else(handle_stderr_error)?;
.write_all(bytes)
.or_else(|e| handle_stderr_error(e))?;
stderr.flush().or_else(|e| handle_stderr_error(e)) stderr.flush().or_else(handle_stderr_error)
} }
} }
/// A buffered stdout writer for faster batch printing operations. /// A buffered stdout writer for faster batch printing operations.
pub struct StdoutBuffer<W: Write> { pub struct StdoutBuffer<W: Write> {
buf: io::BufWriter<W>, buf: io::BufWriter<W>,
} }
impl<W: Write> StdoutBuffer<W> { impl<W: Write> StdoutBuffer<W> {
pub fn new(writer: W) -> Self { pub fn new(writer: W) -> Self {
let buf = io::BufWriter::new(writer); let buf = io::BufWriter::new(writer);
Self { buf } Self { buf }
} }
/// Write bytes to stdout buffer /// Write bytes to stdout buffer
pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> {
self.buf self.buf.write_all(bytes).or_else(handle_stdout_error)
.write_all(bytes)
.or_else(|e| handle_stdout_error(e))
} }
/// Flush bytes to stdout /// Flush bytes to stdout
pub fn flush(&mut self) -> Result<(), UiError> { pub fn flush(&mut self) -> Result<(), UiError> {
self.buf.flush().or_else(|e| handle_stdout_error(e)) self.buf.flush().or_else(handle_stdout_error)
} }
} }
/// Sometimes writing to stdout is not possible, try writing to stderr to /// Sometimes writing to stdout is not possible, try writing to stderr to
/// signal that failure, otherwise just bail. /// signal that failure, otherwise just bail.
fn handle_stdout_error(error: io::Error) -> Result<(), UiError> { fn handle_stdout_error(error: io::Error) -> Result<(), UiError> {
if let ErrorKind::BrokenPipe = error.kind() { if let ErrorKind::BrokenPipe = error.kind() {
// This makes `| head` work for example // This makes `| head` work for example
return Ok(()); return Ok(());
} }
let mut stderr = io::stderr(); let mut stderr = io::stderr();
stderr stderr
.write_all(&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat()) .write_all(&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat())
.map_err(|e| UiError::StderrError(e))?; .map_err(UiError::StderrError)?;
stderr.flush().map_err(|e| UiError::StderrError(e))?; stderr.flush().map_err(UiError::StderrError)?;
Err(UiError::StdoutError(error)) Err(UiError::StdoutError(error))
} }
/// Sometimes writing to stderr is not possible. /// Sometimes writing to stderr is not possible.
fn handle_stderr_error(error: io::Error) -> Result<(), UiError> { fn handle_stderr_error(error: io::Error) -> Result<(), UiError> {
// A broken pipe should not result in a error // A broken pipe should not result in a error
// like with `| head` for example // like with `| head` for example
if let ErrorKind::BrokenPipe = error.kind() { if let ErrorKind::BrokenPipe = error.kind() {
return Ok(()); return Ok(());
} }
Err(UiError::StdoutError(error)) Err(UiError::StdoutError(error))
} }