rhg: add `--revision` argument to `rhg files`

Add the option to list the tracked files of a revision given its number
or full node id.

Benched on a clone of moz-central
where tip is 1671467:81deaa1a68ebb28db0490954034ab38ab269409d

files -r 81deaa1a68ebb28db0490954034ab38ab269409d > out.txt
hg  0m1.633s
rhg 0m0.157s

files -r 81deaa1a68ebb28db0490954034ab38ab269409d > /dev/null
hg  0m0.415s
rhg 0m0.143s

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

rust/rhg/src/commands/files.rs

@@ -1,69 +1,136 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
 use hg::operations::FindRoot;
 use hg::operations::{
     ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
     ListDirstateTrackedFilesErrorKind,
 };
+use hg::operations::{
+    ListRevTrackedFiles, ListRevTrackedFilesError,
+    ListRevTrackedFilesErrorKind,
+};
 use hg::utils::files::{get_bytes_from_path, relativize_path};
-use hg::utils::hg_path::HgPathBuf;
+use hg::utils::hg_path::{HgPath, HgPathBuf};
+use std::path::PathBuf;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
-pub struct FilesCommand {}
-
-impl FilesCommand {
-    pub fn new() -> Self {
-        FilesCommand {}
-    }
+pub struct FilesCommand<'a> {
+    rev: Option<&'a str>,
 }
 
-impl Command for FilesCommand {
-    fn run(&self, ui: &Ui) -> Result<(), CommandError> {
-        let root = FindRoot::new().run()?;
-        let mut operation = ListDirstateTrackedFiles::new(&root)
-            .map_err(map_dirstate_error)?;
-        let files = operation.run().map_err(map_dirstate_error)?;
+impl<'a> FilesCommand<'a> {
+    pub fn new(rev: Option<&'a str>) -> Self {
+        FilesCommand { rev }
+    }
 
+    fn display_files(
+        &self,
+        ui: &Ui,
+        root: &PathBuf,
+        files: impl IntoIterator<Item = &'a HgPath>,
+    ) -> Result<(), CommandError> {
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
         let rooted_cwd = cwd
             .strip_prefix(&root)
             .expect("cwd was already checked within the repository");
         let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
 
         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(())
     }
 }
 
-/// Convert operation errors to command errors
+impl<'a> Command for FilesCommand<'a> {
+    fn run(&self, ui: &Ui) -> Result<(), CommandError> {
+        let root = FindRoot::new().run()?;
+        if let Some(rev) = self.rev {
+            let mut operation = ListRevTrackedFiles::new(&root, rev)
+                .map_err(|e| map_rev_error(rev, e))?;
+            let files = operation.run().map_err(|e| map_rev_error(rev, e))?;
+            self.display_files(ui, &root, files)
+        } else {
+            let mut operation = ListDirstateTrackedFiles::new(&root)
+                .map_err(map_dirstate_error)?;
+            let files = operation.run().map_err(map_dirstate_error)?;
+            self.display_files(ui, &root, files)
+        }
+    }
+}
+
+/// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
+fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
+    CommandError {
+        kind: match err.kind {
+            ListRevTrackedFilesErrorKind::IoError(err) => {
+                CommandErrorKind::Abort(Some(
+                    utf8_to_local(&format!("abort: {}\n", err)).into(),
+                ))
+            }
+            ListRevTrackedFilesErrorKind::InvalidRevision => {
+                CommandErrorKind::Abort(Some(
+                    utf8_to_local(&format!(
+                        "abort: invalid revision identifier{}\n",
+                        rev
+                    ))
+                    .into(),
+                ))
+            }
+            ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) => {
+                CommandErrorKind::Abort(Some(
+                    utf8_to_local(&format!(
+                        "abort: unsupported revlog version {}\n",
+                        version
+                    ))
+                    .into(),
+                ))
+            }
+            ListRevTrackedFilesErrorKind::CorruptedRevlog => {
+                CommandErrorKind::Abort(Some(
+                    "abort: corrupted revlog\n".into(),
+                ))
+            }
+            ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) => {
+                CommandErrorKind::Abort(Some(
+                    utf8_to_local(&format!(
+                        "abort: unknow revlog dataformat {:?}\n",
+                        format
+                    ))
+                    .into(),
+                ))
+            }
+        },
+    }
+}
+
+/// Convert `ListDirstateTrackedFilesError` to `CommandError`
 fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListDirstateTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListDirstateTrackedFilesErrorKind::ParseError(_) => {
                 CommandErrorKind::Abort(Some(
                     // TODO find a better error message
                     b"abort: parse error\n".to_vec(),
                 ))
             }
         },
     }
 }

rust/rhg/src/main.rs

@@ -1,121 +1,141 b''
 extern crate log;
 use clap::App;
 use clap::AppSettings;
 use clap::Arg;
 use clap::ArgGroup;
 use clap::ArgMatches;
 use clap::SubCommand;
 use hg::operations::DebugDataKind;
 use std::convert::TryFrom;
 
 mod commands;
 mod error;
 mod exitcode;
 mod ui;
 use commands::Command;
 use error::CommandError;
 
 fn main() {
     env_logger::init();
     let 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),
+            SubCommand::with_name("files")
+                .arg(
+                    Arg::with_name("rev")
+                        .help("search the repository as it is in REV")
+                        .short("-r")
+                        .long("--revision")
+                        .value_name("REV")
+                        .takes_value(true),
+                )
+                .about(commands::files::HELP_TEXT),
         )
         .subcommand(
             SubCommand::with_name("debugdata")
                 .about(commands::debugdata::HELP_TEXT)
                 .arg(
                     Arg::with_name("changelog")
                         .help("open changelog")
                         .short("-c")
                         .long("--changelog"),
                 )
                 .arg(
                     Arg::with_name("manifest")
                         .help("open manifest")
                         .short("-m")
                         .long("--manifest"),
                 )
                 .group(
                     ArgGroup::with_name("")
                         .args(&["changelog", "manifest"])
                         .required(true),
                 )
                 .arg(
                     Arg::with_name("rev")
                         .help("revision")
                         .required(true)
                         .value_name("REV"),
                 ),
         );
 
     let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {
         let _ = ui::Ui::new().writeln_stderr_str(&err.message);
         std::process::exit(exitcode::UNIMPLEMENTED_COMMAND)
     });
 
     let ui = ui::Ui::new();
 
     let command_result = match_subcommand(matches, &ui);
 
     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()
         }
     }
 }
 
 fn match_subcommand(
     matches: ArgMatches,
     ui: &ui::Ui,
 ) -> Result<(), CommandError> {
     match matches.subcommand() {
         ("root", _) => commands::root::RootCommand::new().run(&ui),
-        ("files", _) => commands::files::FilesCommand::new().run(&ui),
+        ("files", Some(matches)) => {
+            commands::files::FilesCommand::try_from(matches)?.run(&ui)
+        }
         ("debugdata", Some(matches)) => {
             commands::debugdata::DebugDataCommand::try_from(matches)?.run(&ui)
         }
         _ => unreachable!(), // Because of AppSettings::SubcommandRequired,
     }
 }
 
+impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::files::FilesCommand<'a> {
+    type Error = CommandError;
+
+    fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
+        let rev = args.value_of("rev");
+        Ok(commands::files::FilesCommand::new(rev))
+    }
+}
+
 impl<'a> TryFrom<&'a ArgMatches<'_>>
     for commands::debugdata::DebugDataCommand<'a>
 {
     type Error = CommandError;
 
     fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
         let rev = args
             .value_of("rev")
             .expect("rev should be a required argument");
         let kind = match (
             args.is_present("changelog"),
             args.is_present("manifest"),
         ) {
             (true, false) => DebugDataKind::Changelog,
             (false, true) => DebugDataKind::Manifest,
             (true, true) => {
                 unreachable!("Should not happen since options are exclusive")
             }
             (false, false) => {
                 unreachable!("Should not happen since options are required")
             }
         };
         Ok(commands::debugdata::DebugDataCommand::new(rev, kind))
     }
 }