This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8865

rhg: ask the error message from `CommandError`
ClosedPublic

Authored by acezar on Aug 3 2020, 10:25 AM.

Details

Reviewers
Alphare
indygreg
Group Reviewers
hg-reviewers
Commits
rHG47997afadf08: rhg: ask the error message from `CommandError`
Summary

Avoid repeating the display of the same error messages in different commands.

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 3 2020, 10:25 AM
Alphare accepted this revision.Aug 3 2020, 11:08 AM
acezar updated this revision to Diff 22249.Aug 4 2020, 4:58 AM
indygreg accepted this revision.Aug 8 2020, 3:59 PM
This revision is now accepted and ready to land.Aug 8 2020, 3:59 PM
acezar added a commit: rHG47997afadf08: rhg: ask the error message from `CommandError`.Aug 8 2020, 4:30 PM
Closed by commit rHG47997afadf08: rhg: ask the error message from `CommandError` (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22360

rust/rhg/src/commands.rs

pub mod root; pub mod root;
use crate::error::CommandError; use crate::error::CommandError;
/// The common trait for rhg commands /// The common trait for rhg commands
/// ///
/// Normalize the interface of the commands provided by rhg /// Normalize the interface of the commands provided by rhg
pub trait Command { pub trait Command<'a> {
fn run(&self) -> Result<(), CommandError>; fn run(&self) -> Result<(), CommandError>;
} }

rust/rhg/src/commands/root.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{FindRoot, FindRootError, FindRootErrorKind}; use hg::operations::{FindRoot, FindRootErrorKind};
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
use std::path::PathBuf;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct RootCommand { pub struct RootCommand<'a> {
ui: Ui, ui: &'a Ui,
} }
impl RootCommand { impl<'a> RootCommand<'a> {
pub fn new() -> Self { pub fn new(ui: &'a 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<'a> Command<'a> for RootCommand<'a> {
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,
} }
} }
/// Return the message corresponding to the error kind if any
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())
} }
/// Return the message corresponding to the command error if any
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()
}
} }
} }