rhg: simplify `FindRootError` handling

Differential Revision: https://phab.mercurial-scm.org/D8867

rust/rhg/src/commands/root.rs

@@ -1,42 +1,34
 use crate::commands::Command;
-use crate::error::{CommandError, CommandErrorKind};
+use crate::error::CommandError;
 use crate::ui::Ui;
-use hg::operations::{FindRoot, FindRootErrorKind};
+use hg::operations::FindRoot;
 use hg::utils::files::get_bytes_from_path;
 
 pub const HELP_TEXT: &str = "
 Print the root directory of the current repository.
 
 Returns 0 on success.
 ";
 
 pub struct RootCommand<'a> {
     ui: &'a Ui,
 }
 
 impl<'a> RootCommand<'a> {
     pub fn new(ui: &'a Ui) -> Self {
         RootCommand { ui }
     }
 }
 
 impl<'a> Command<'a> for RootCommand<'a> {
     fn run(&self) -> Result<(), CommandError> {
-        let path_buf =
-            FindRoot::new().run().map_err(|err| match err.kind {
-                FindRootErrorKind::RootNotFound(path) => {
-                    CommandErrorKind::RootNotFound(path)
-                }
-                FindRootErrorKind::GetCurrentDirError(e) => {
-                    CommandErrorKind::CurrentDirNotFound(e)
-                }
-            })?;
+        let path_buf = FindRoot::new().run()?;
 
         let bytes = get_bytes_from_path(path_buf);
 
         // TODO use formating macro
         self.ui.write_stdout(&[bytes.as_slice(), b"\n"].concat())?;
 
         Ok(())
     }
 }

rust/rhg/src/error.rs

@@ -1,92 +1,106
 use crate::exitcode;
 use crate::ui::UiError;
+use hg::operations::{FindRootError, FindRootErrorKind};
 use hg::utils::files::get_bytes_from_path;
 use std::convert::From;
 use std::path::PathBuf;
 
 /// The kind of command error
 #[derive(Debug)]
 pub enum CommandErrorKind {
     /// The root of the repository cannot be found
     RootNotFound(PathBuf),
     /// The current directory cannot be found
     CurrentDirNotFound(std::io::Error),
     /// The standard output stream cannot be written to
     StdoutError,
     /// The standard error stream cannot be written to
     StderrError,
 }
 
 impl CommandErrorKind {
     pub fn get_exit_code(&self) -> exitcode::ExitCode {
         match self {
             CommandErrorKind::RootNotFound(_) => exitcode::ABORT,
             CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT,
             CommandErrorKind::StdoutError => 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
 #[derive(Debug)]
 pub struct CommandError {
     pub kind: CommandErrorKind,
 }
 
 impl CommandError {
     /// Exist the process with the corresponding exit code.
     pub fn exit(&self) -> () {
         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 {
     fn from(kind: CommandErrorKind) -> Self {
         CommandError { kind }
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(error: UiError) -> Self {
         CommandError {
             kind: match error {
                 UiError::StdoutError(_) => CommandErrorKind::StdoutError,
                 UiError::StderrError(_) => CommandErrorKind::StderrError,
             },
         }
     }
 }
+
+impl From<FindRootError> for CommandError {
+    fn from(err: FindRootError) -> Self {
+        match err.kind {
+            FindRootErrorKind::RootNotFound(path) => CommandError {
+                kind: CommandErrorKind::RootNotFound(path),
+            },
+            FindRootErrorKind::GetCurrentDirError(e) => CommandError {
+                kind: CommandErrorKind::CurrentDirNotFound(e),
+            },
+        }
+    }
+}