rhg: Move subcommand CLI arguments definitions to respective modules

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

rust/rhg/src/commands/cat.rs

@@ -1,51 +1,73 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
+use clap::Arg;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::operations::cat;
 use hg::repo::Repo;
 use hg::utils::hg_path::HgPathBuf;
 use micro_timer::timed;
 use std::convert::TryFrom;
 
 pub const HELP_TEXT: &str = "
 Output the current or given revision of files
 ";
 
+pub fn args() -> clap::App<'static, 'static> {
+    clap::SubCommand::with_name("cat")
+        .arg(
+            Arg::with_name("rev")
+                .help("search the repository as it is in REV")
+                .short("-r")
+                .long("--revision")
+                .value_name("REV")
+                .takes_value(true),
+        )
+        .arg(
+            clap::Arg::with_name("files")
+                .required(true)
+                .multiple(true)
+                .empty_values(false)
+                .value_name("FILE")
+                .help("Activity to start: activity@category"),
+        )
+        .about(HELP_TEXT)
+}
+
 #[timed]
 pub fn run(
     ui: &Ui,
     config: &Config,
     args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let rev = args.value_of("rev");
     let file_args = match args.values_of("files") {
         Some(files) => files.collect(),
         None => vec![],
     };
 
     let repo = Repo::find(config)?;
     let cwd = hg::utils::current_dir()?;
 
     let mut files = vec![];
     for file in file_args.iter() {
         // TODO: actually normalize `..` path segments etc?
         let normalized = cwd.join(&file);
         let stripped = normalized
             .strip_prefix(&repo.working_directory_path())
             // TODO: error message for path arguments outside of the repo
             .map_err(|_| CommandError::abort(""))?;
         let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
             .map_err(|e| CommandError::abort(e.to_string()))?;
         files.push(hg_file);
     }
 
     match rev {
         Some(rev) => {
             let data = cat(&repo, rev, &files).map_err(|e| (e, rev))?;
             ui.write_stdout(&data)?;
             Ok(())
         }
         None => Err(CommandError::Unimplemented.into()),
     }
 }

rust/rhg/src/commands/debugdata.rs

@@ -1,42 +1,72 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
+use clap::Arg;
+use clap::ArgGroup;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::operations::{debug_data, DebugDataKind};
 use hg::repo::Repo;
 use micro_timer::timed;
 
 pub const HELP_TEXT: &str = "
 Dump the contents of a data file revision
 ";
 
+pub fn args() -> clap::App<'static, 'static> {
+    clap::SubCommand::with_name("debugdata")
+        .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"),
+        )
+        .about(HELP_TEXT)
+}
+
 #[timed]
 pub fn run(
     ui: &Ui,
     config: &Config,
     args: &ArgMatches,
 ) -> Result<(), CommandError> {
     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")
             }
         };
 
     let repo = Repo::find(config)?;
     let data = debug_data(&repo, rev, kind).map_err(|e| (e, rev))?;
 
     let mut stdout = ui.stdout_buffer();
     stdout.write_all(&data)?;
     stdout.flush()?;
 
     Ok(())
 }

rust/rhg/src/commands/debugrequirements.rs

@@ -1,26 +1,30 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::repo::Repo;
 
 pub const HELP_TEXT: &str = "
 Print the current repo requirements.
 ";
 
+pub fn args() -> clap::App<'static, 'static> {
+    clap::SubCommand::with_name("debugrequirements").about(HELP_TEXT)
+}
+
 pub fn run(
     ui: &Ui,
     config: &Config,
     _args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let repo = Repo::find(config)?;
     let mut output = String::new();
     let mut requirements: Vec<_> = repo.requirements().iter().collect();
     requirements.sort();
     for req in requirements {
         output.push_str(req);
         output.push('\n');
     }
     ui.write_stdout(output.as_bytes())?;
     Ok(())
 }

rust/rhg/src/commands/files.rs

@@ -1,55 +1,69 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
+use clap::Arg;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::operations::list_rev_tracked_files;
 use hg::operations::Dirstate;
 use hg::repo::Repo;
 use hg::utils::files::{get_bytes_from_path, relativize_path};
 use hg::utils::hg_path::{HgPath, HgPathBuf};
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
+pub fn args() -> clap::App<'static, 'static> {
+    clap::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(HELP_TEXT)
+}
+
 pub fn run(
     ui: &Ui,
     config: &Config,
     args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let rev = args.value_of("rev");
 
     let repo = Repo::find(config)?;
     if let Some(rev) = rev {
         let files =
             list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?;
         display_files(ui, &repo, files.iter())
     } else {
         let distate = Dirstate::new(&repo)?;
         let files = distate.tracked_files()?;
         display_files(ui, &repo, files)
     }
 }
 
 fn display_files<'a>(
     ui: &Ui,
     repo: &Repo,
     files: impl IntoIterator<Item = &'a HgPath>,
 ) -> Result<(), CommandError> {
     let cwd = hg::utils::current_dir()?;
     let rooted_cwd = cwd
         .strip_prefix(repo.working_directory_path())
         .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(())
 }

rust/rhg/src/commands/root.rs

@@ -1,24 +1,28 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::ArgMatches;
 use format_bytes::format_bytes;
 use hg::config::Config;
 use hg::repo::Repo;
 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 fn args() -> clap::App<'static, 'static> {
+    clap::SubCommand::with_name("root").about(HELP_TEXT)
+}
+
 pub fn run(
     ui: &Ui,
     config: &Config,
     _args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let repo = Repo::find(config)?;
     let bytes = get_bytes_from_path(repo.working_directory_path());
     ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
     Ok(())
 }

rust/rhg/src/main.rs

@@ -1,137 +1,73 b''
 extern crate log;
 use clap::App;
 use clap::AppSettings;
-use clap::Arg;
-use clap::ArgGroup;
 use clap::ArgMatches;
-use clap::SubCommand;
 use format_bytes::format_bytes;
 
 mod commands;
 mod error;
 mod exitcode;
 mod ui;
 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")
-                .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("cat")
-                .arg(
-                    Arg::with_name("rev")
-                        .help("search the repository as it is in REV")
-                        .short("-r")
-                        .long("--revision")
-                        .value_name("REV")
-                        .takes_value(true),
-                )
-                .arg(
-                    clap::Arg::with_name("files")
-                        .required(true)
-                        .multiple(true)
-                        .empty_values(false)
-                        .value_name("FILE")
-                        .help("Activity to start: activity@category"),
-                )
-                .about(commands::cat::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"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("debugrequirements")
-                .about(commands::debugrequirements::HELP_TEXT),
-        );
+        .subcommand(commands::root::args())
+        .subcommand(commands::files::args())
+        .subcommand(commands::cat::args())
+        .subcommand(commands::debugdata::args())
+        .subcommand(commands::debugrequirements::args());
 
     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)
     });
 
     let ui = ui::Ui::new();
 
     let command_result = match_subcommand(matches, &ui);
 
     let exit_code = match command_result {
         Ok(_) => exitcode::OK,
 
         // Exit with a specific code and no error message to let a potential
         // wrapper script fallback to Python-based Mercurial.
         Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED,
 
         Err(CommandError::Abort { message }) => {
             if !message.is_empty() {
                 // Ignore errors when writing to stderr, we’re already exiting
                 // with failure code so there’s not much more we can do.
                 let _ =
                     ui.write_stderr(&format_bytes!(b"abort: {}\n", message));
             }
             exitcode::ABORT
         }
     };
     std::process::exit(exit_code)
 }
 
 fn match_subcommand(
     matches: ArgMatches,
     ui: &ui::Ui,
 ) -> Result<(), CommandError> {
     let config = hg::config::Config::load()?;
 
     match matches.subcommand() {
         ("root", Some(matches)) => commands::root::run(ui, &config, matches),
         ("files", Some(matches)) => commands::files::run(ui, &config, matches),
         ("cat", Some(matches)) => commands::cat::run(ui, &config, matches),
         ("debugdata", Some(matches)) => {
             commands::debugdata::run(ui, &config, matches)
         }
         ("debugrequirements", Some(matches)) => {
             commands::debugrequirements::run(ui, &config, matches)
         }
         _ => unreachable!(), // Because of AppSettings::SubcommandRequired,
     }
 }