This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8777

rhg: Ask the error message from `CommandError`
AbandonedPublic

Authored by acezar on Jul 21 2020, 10:06 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

Avoid repeating the display part of the same error in different commands.
For example, a lot of commands while use the FindRoot Operation, rather than
having to display the same error message in different command, the command can
just return the proper error which know what is the appropriate message to
display.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 22008

rust/rhg/src/commands/root.rs

Returns 0 on success. Returns 0 on success.
"; ";
pub struct RootCommand { pub struct RootCommand {
ui: Ui, ui: Ui,
} }
impl RootCommand { impl RootCommand {
pub fn new() -> Self { pub fn new(ui: Ui) -> Self {
RootCommand { ui: Ui::new() } RootCommand { ui }
} }
fn display_found_path(
&self,
path_buf: PathBuf,
) -> Result<(), CommandError> {
let bytes = get_bytes_from_path(path_buf);
// TODO use formating macro
self.ui.write_stdout(&[bytes.as_slice(), b"\n"].concat())?;
Ok(())
} }
fn display_error(&self, error: FindRootError) -> Result<(), CommandError> { impl Command for RootCommand {
match error.kind { fn run(&self) -> Result<(), CommandError> {
let path_buf =
FindRoot::new().run().map_err(|err| match err.kind {
FindRootErrorKind::RootNotFound(path) => { FindRootErrorKind::RootNotFound(path) => {
let bytes = get_bytes_from_path(path); CommandErrorKind::RootNotFound(path)
// TODO use formating macro
self.ui.write_stderr(
&[
b"abort: no repository found in '",
bytes.as_slice(),
b"' (.hg not found)!\n",
]
.concat(),
)?;
Err(CommandErrorKind::RootNotFound.into())
} }
FindRootErrorKind::GetCurrentDirError(e) => { FindRootErrorKind::GetCurrentDirError(e) => {
// TODO use formating macro CommandErrorKind::CurrentDirNotFound(e)
self.ui.write_stderr(
&[
b"abort: error getting current working directory: ",
e.to_string().as_bytes(),
b"\n",
]
.concat(),
)?;
Err(CommandErrorKind::CurrentDirNotFound.into())
}
}
}
} }
})?;
impl Command for RootCommand { let bytes = get_bytes_from_path(path_buf);
fn run(&self) -> Result<(), CommandError> {
match FindRoot::new().run() { // TODO use formating macro
Ok(path_buf) => self.display_found_path(path_buf), self.ui.write_stdout(&[bytes.as_slice(), b"\n"].concat())?;
Err(e) => self.display_error(e),
} Ok(())
} }
} }

rust/rhg/src/error.rs

use crate::exitcode; use crate::exitcode;
use crate::ui::UiError; use crate::ui::UiError;
use hg::utils::files::get_bytes_from_path;
use std::convert::From; use std::convert::From;
use std::path::PathBuf;
/// The kind of command error /// The kind of command error
#[derive(Debug, PartialEq)] #[derive(Debug)]
pub enum CommandErrorKind { pub enum CommandErrorKind {
/// The root of the repository cannot be found /// The root of the repository cannot be found
RootNotFound, RootNotFound(PathBuf),
/// The current directory cannot be found /// The current directory cannot be found
CurrentDirNotFound, CurrentDirNotFound(std::io::Error),
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError, StdoutError,
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError, StderrError,
} }
impl CommandErrorKind { impl CommandErrorKind {
pub fn get_exit_code(&self) -> exitcode::ExitCode { pub fn get_exit_code(&self) -> exitcode::ExitCode {
match self { match self {
CommandErrorKind::RootNotFound => exitcode::ABORT, CommandErrorKind::RootNotFound(_) => exitcode::ABORT,
CommandErrorKind::CurrentDirNotFound => exitcode::ABORT, CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT,
CommandErrorKind::StdoutError => exitcode::ABORT, CommandErrorKind::StdoutError => exitcode::ABORT,
CommandErrorKind::StderrError => exitcode::ABORT, CommandErrorKind::StderrError => exitcode::ABORT,
} }
} }
pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
match self {
// TODO use formating macro
CommandErrorKind::RootNotFound(path) => {
let bytes = get_bytes_from_path(path);
Some(
[
b"abort: no repository found in '",
bytes.as_slice(),
b"' (.hg not found)!\n",
]
.concat(),
)
}
// TODO use formating macro
CommandErrorKind::CurrentDirNotFound(e) => Some(
[
b"abort: error getting current working directory: ",
e.to_string().as_bytes(),
b"\n",
]
.concat(),
),
_ => None,
}
}
} }
/// The error type for the Command trait /// The error type for the Command trait
#[derive(Debug, PartialEq)] #[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())
} }
pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
self.kind.get_error_message_bytes()
}
} }
impl From<CommandErrorKind> for CommandError { impl From<CommandErrorKind> for CommandError {
fn from(kind: CommandErrorKind) -> Self { fn from(kind: CommandErrorKind) -> Self {
CommandError { kind } CommandError { kind }
} }
} }

rust/rhg/src/main.rs

.subcommand( .subcommand(
SubCommand::with_name("root").about(commands::root::HELP_TEXT), SubCommand::with_name("root").about(commands::root::HELP_TEXT),
); );
let matches = app.clone().get_matches_safe().unwrap_or_else(|_| { let matches = app.clone().get_matches_safe().unwrap_or_else(|_| {
std::process::exit(exitcode::UNIMPLEMENTED_COMMAND) std::process::exit(exitcode::UNIMPLEMENTED_COMMAND)
}); });
let ui = ui::Ui::new();
let command_result = match matches.subcommand_name() { let command_result = match matches.subcommand_name() {
Some(name) => match name { Some(name) => match name {
"root" => commands::root::RootCommand::new().run(), "root" => commands::root::RootCommand::new(ui).run(),
_ => std::process::exit(exitcode::UNIMPLEMENTED_COMMAND), _ => std::process::exit(exitcode::UNIMPLEMENTED_COMMAND),
}, },
_ => { _ => {
match app.print_help() { match app.print_help() {
Ok(_) => std::process::exit(exitcode::OK), Ok(_) => std::process::exit(exitcode::OK),
Err(_) => std::process::exit(exitcode::ABORT), Err(_) => std::process::exit(exitcode::ABORT),
}; };
} }
}; };
match command_result { match command_result {
Ok(_) => std::process::exit(exitcode::OK), Ok(_) => std::process::exit(exitcode::OK),
Err(e) => e.exit(), Err(e) => {
let message = e.get_error_message_bytes();
if let Some(msg) = message {
match ui.write_stderr(&msg) {
Ok(_) => (),
Err(_) => std::process::exit(exitcode::ABORT),
};
};
e.exit()
}
} }
} }

rust/rhg/src/ui.rs

use std::io; use std::io;
use std::io::Write; use std::io::Write;
#[derive(Copy, Clone)]
pub struct Ui {} pub struct Ui {}
/// The kind of user interface error /// The kind of user interface error
pub enum UiError { pub enum UiError {
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError(io::Error), StdoutError(io::Error),
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError(io::Error), StderrError(io::Error),