( )⚙ D8865 rhg: ask the error message from `CommandError`

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 22249

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()
}
} }
} }