rhg: pass `ui` to `Command` `run`

Allow implementation of `From<clap::ArgMatches> for Command`

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

rust/rhg/src/commands.rs

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

rust/rhg/src/commands/files.rs

@@ -1,60 +1,58 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::Ui;
 use hg::operations::{ListTrackedFiles, ListTrackedFilesErrorKind};
 use hg::utils::files::{get_bytes_from_path, relativize_path};
 use hg::utils::hg_path::HgPathBuf;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
-pub struct FilesCommand<'a> {
-    ui: &'a Ui,
-}
+pub struct FilesCommand {}
 
-impl<'a> FilesCommand<'a> {
-    pub fn new(ui: &'a Ui) -> Self {
-        FilesCommand { ui }
+impl FilesCommand {
+    pub fn new() -> Self {
+        FilesCommand {}
     }
 }
 
-impl<'a> Command<'a> for FilesCommand<'a> {
-    fn run(&self) -> Result<(), CommandError> {
+impl Command for FilesCommand {
+    fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         let operation_builder = ListTrackedFiles::new()?;
         let operation = operation_builder.load().map_err(|err| {
             CommandErrorKind::Abort(Some(
                 [b"abort: ", err.to_string().as_bytes(), b"\n"]
                     .concat()
                     .to_vec(),
             ))
         })?;
         let files = operation.run().map_err(|err| match err.kind {
             ListTrackedFilesErrorKind::ParseError(_) => {
                 CommandErrorKind::Abort(Some(
                     // TODO find a better error message
                     b"abort: parse error\n".to_vec(),
                 ))
             }
         })?;
 
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
         let rooted_cwd = cwd
             .strip_prefix(operation_builder.get_root())
             .expect("cwd was already checked within the repository");
         let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
 
-        let mut stdout = self.ui.stdout_buffer();
+        let mut stdout = ui.stdout_buffer();
 
         for file in files {
             stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
             stdout.write_all(b"\n")?;
         }
         stdout.flush()?;
 
         Ok(())
     }
 }

rust/rhg/src/commands/root.rs

@@ -1,34 +1,32 b''
 use crate::commands::Command;
 use crate::error::CommandError;
 use crate::ui::Ui;
 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,
-}
+pub struct RootCommand {}
 
-impl<'a> RootCommand<'a> {
-    pub fn new(ui: &'a Ui) -> Self {
-        RootCommand { ui }
+impl RootCommand {
+    pub fn new() -> Self {
+        RootCommand {}
     }
 }
 
-impl<'a> Command<'a> for RootCommand<'a> {
-    fn run(&self) -> Result<(), CommandError> {
+impl Command for RootCommand {
+    fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         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())?;
+        ui.write_stdout(&[bytes.as_slice(), b"\n"].concat())?;
 
         Ok(())
     }
 }

rust/rhg/src/main.rs

@@ -1,57 +1,57 b''
 use clap::App;
 use clap::AppSettings;
 use clap::SubCommand;
 
 mod commands;
 mod error;
 mod exitcode;
 mod ui;
 use commands::Command;
 
 fn main() {
     let mut app = App::new("rhg")
         .setting(AppSettings::AllowInvalidUtf8)
         .setting(AppSettings::SubcommandRequired)
         .setting(AppSettings::VersionlessSubcommands)
         .version("0.0.1")
         .subcommand(
             SubCommand::with_name("root").about(commands::root::HELP_TEXT),
         )
         .subcommand(
             SubCommand::with_name("files").about(commands::files::HELP_TEXT),
         );
 
     let matches = app.clone().get_matches_safe().unwrap_or_else(|_| {
         std::process::exit(exitcode::UNIMPLEMENTED_COMMAND)
     });
 
     let ui = ui::Ui::new();
 
     let command_result = match matches.subcommand_name() {
         Some(name) => match name {
-            "root" => commands::root::RootCommand::new(&ui).run(),
-            "files" => commands::files::FilesCommand::new(&ui).run(),
+            "root" => commands::root::RootCommand::new().run(&ui),
+            "files" => commands::files::FilesCommand::new().run(&ui),
             _ => std::process::exit(exitcode::UNIMPLEMENTED_COMMAND),
         },
         _ => {
             match app.print_help() {
                 Ok(_) => std::process::exit(exitcode::OK),
                 Err(_) => std::process::exit(exitcode::ABORT),
             };
         }
     };
 
     match command_result {
         Ok(_) => std::process::exit(exitcode::OK),
         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()
         }
     }
 }