rhg: Add support for --config CLI arguments

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

rust/hg-core/src/config/config.rs

@@ -1,341 +1,344 b''
 // config.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use super::layer;
 use crate::config::layer::{
     ConfigError, ConfigLayer, ConfigParseError, ConfigValue,
 };
 use crate::utils::files::get_bytes_from_path;
 use format_bytes::{write_bytes, DisplayBytes};
 use std::env;
 use std::path::{Path, PathBuf};
 
 use crate::errors::{HgResultExt, IoResultExt};
 
 /// Holds the config values for the current repository
 /// TODO update this docstring once we support more sources
 pub struct Config {
     layers: Vec<layer::ConfigLayer>,
 }
 
 impl DisplayBytes for Config {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         for (index, layer) in self.layers.iter().rev().enumerate() {
             write_bytes!(
                 out,
                 b"==== Layer {} (trusted: {}) ====\n{}",
                 index,
                 if layer.trusted {
                     &b"yes"[..]
                 } else {
                     &b"no"[..]
                 },
                 layer
             )?;
         }
         Ok(())
     }
 }
 
 pub enum ConfigSource {
     /// Absolute path to a config file
     AbsPath(PathBuf),
     /// Already parsed (from the CLI, env, Python resources, etc.)
     Parsed(layer::ConfigLayer),
 }
 
 pub fn parse_bool(v: &[u8]) -> Option<bool> {
     match v.to_ascii_lowercase().as_slice() {
         b"1" | b"yes" | b"true" | b"on" | b"always" => Some(true),
         b"0" | b"no" | b"false" | b"off" | b"never" => Some(false),
         _ => None,
     }
 }
 
 impl Config {
     /// Load system and user configuration from various files.
     ///
     /// This is also affected by some environment variables.
-    ///
-    /// TODO: add a parameter for `--config` CLI arguments
-    pub fn load() -> Result<Self, ConfigError> {
+    pub fn load(
+        cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
+    ) -> Result<Self, ConfigError> {
         let mut config = Self { layers: Vec::new() };
         let opt_rc_path = env::var_os("HGRCPATH");
         // HGRCPATH replaces system config
         if opt_rc_path.is_none() {
             config.add_system_config()?
         }
         config.add_for_environment_variable("EDITOR", b"ui", b"editor");
         config.add_for_environment_variable("VISUAL", b"ui", b"editor");
         config.add_for_environment_variable("PAGER", b"pager", b"pager");
         // HGRCPATH replaces user config
         if opt_rc_path.is_none() {
             config.add_user_config()?
         }
         if let Some(rc_path) = &opt_rc_path {
             for path in env::split_paths(rc_path) {
                 if !path.as_os_str().is_empty() {
                     if path.is_dir() {
                         config.add_trusted_dir(&path)?
                     } else {
                         config.add_trusted_file(&path)?
                     }
                 }
             }
         }
+        if let Some(layer) = ConfigLayer::parse_cli_args(cli_config_args)? {
+            config.layers.push(layer)
+        }
         Ok(config)
     }
 
     fn add_trusted_dir(&mut self, path: &Path) -> Result<(), ConfigError> {
         if let Some(entries) = std::fs::read_dir(path)
             .for_file(path)
             .io_not_found_as_none()?
         {
             for entry in entries {
                 let file_path = entry.for_file(path)?.path();
                 if file_path.extension() == Some(std::ffi::OsStr::new("rc")) {
                     self.add_trusted_file(&file_path)?
                 }
             }
         }
         Ok(())
     }
 
     fn add_trusted_file(&mut self, path: &Path) -> Result<(), ConfigError> {
         if let Some(data) =
             std::fs::read(path).for_file(path).io_not_found_as_none()?
         {
             self.layers.extend(ConfigLayer::parse(path, &data)?)
         }
         Ok(())
     }
 
     fn add_for_environment_variable(
         &mut self,
         var: &str,
         section: &[u8],
         key: &[u8],
     ) {
         if let Some(value) = env::var_os(var) {
             let origin = layer::ConfigOrigin::Environment(var.into());
             let mut layer = ConfigLayer::new(origin);
             layer.add(
                 section.to_owned(),
                 key.to_owned(),
                 // `value` is not a path but this works for any `OsStr`:
                 get_bytes_from_path(value),
                 None,
             );
             self.layers.push(layer)
         }
     }
 
     #[cfg(unix)] // TODO: other platforms
     fn add_system_config(&mut self) -> Result<(), ConfigError> {
         let mut add_for_prefix = |prefix: &Path| -> Result<(), ConfigError> {
             let etc = prefix.join("etc").join("mercurial");
             self.add_trusted_file(&etc.join("hgrc"))?;
             self.add_trusted_dir(&etc.join("hgrc.d"))
         };
         let root = Path::new("/");
         // TODO: use `std::env::args_os().next().unwrap()` a.k.a. argv[0]
         // instead? TODO: can this be a relative path?
         let hg = crate::utils::current_exe()?;
         // TODO: this order (per-installation then per-system) matches
         // `systemrcpath()` in `mercurial/scmposix.py`, but
         // `mercurial/helptext/config.txt` suggests it should be reversed
         if let Some(installation_prefix) = hg.parent().and_then(Path::parent) {
             if installation_prefix != root {
                 add_for_prefix(&installation_prefix)?
             }
         }
         add_for_prefix(root)?;
         Ok(())
     }
 
     #[cfg(unix)] // TODO: other plateforms
     fn add_user_config(&mut self) -> Result<(), ConfigError> {
         let opt_home = home::home_dir();
         if let Some(home) = &opt_home {
             self.add_trusted_file(&home.join(".hgrc"))?
         }
         let darwin = cfg!(any(target_os = "macos", target_os = "ios"));
         if !darwin {
             if let Some(config_home) = env::var_os("XDG_CONFIG_HOME")
                 .map(PathBuf::from)
                 .or_else(|| opt_home.map(|home| home.join(".config")))
             {
                 self.add_trusted_file(&config_home.join("hg").join("hgrc"))?
             }
         }
         Ok(())
     }
 
     /// Loads in order, which means that the precedence is the same
     /// as the order of `sources`.
     pub fn load_from_explicit_sources(
         sources: Vec<ConfigSource>,
     ) -> Result<Self, ConfigError> {
         let mut layers = vec![];
 
         for source in sources.into_iter() {
             match source {
                 ConfigSource::Parsed(c) => layers.push(c),
                 ConfigSource::AbsPath(c) => {
                     // TODO check if it should be trusted
                     // mercurial/ui.py:427
                     let data = match std::fs::read(&c) {
                         Err(_) => continue, // same as the python code
                         Ok(data) => data,
                     };
                     layers.extend(ConfigLayer::parse(&c, &data)?)
                 }
             }
         }
 
         Ok(Config { layers })
     }
 
     /// Loads the per-repository config into a new `Config` which is combined
     /// with `self`.
     pub(crate) fn combine_with_repo(
         &self,
         repo_config_files: &[PathBuf],
     ) -> Result<Self, ConfigError> {
         let (cli_layers, other_layers) = self
             .layers
             .iter()
             .cloned()
             .partition(ConfigLayer::is_from_command_line);
 
         let mut repo_config = Self {
             layers: other_layers,
         };
         for path in repo_config_files {
             // TODO: check if this file should be trusted:
             // `mercurial/ui.py:427`
             repo_config.add_trusted_file(path)?;
         }
         repo_config.layers.extend(cli_layers);
         Ok(repo_config)
     }
 
     /// Returns an `Err` if the first value found is not a valid boolean.
     /// Otherwise, returns an `Ok(option)`, where `option` is the boolean if
     /// found, or `None`.
     pub fn get_option(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<bool>, ConfigParseError> {
         match self.get_inner(&section, &item) {
             Some((layer, v)) => match parse_bool(&v.bytes) {
                 Some(b) => Ok(Some(b)),
                 None => Err(ConfigParseError {
                     origin: layer.origin.to_owned(),
                     line: v.line,
                     bytes: v.bytes.to_owned(),
                 }),
             },
             None => Ok(None),
         }
     }
 
     /// Returns the corresponding boolean in the config. Returns `Ok(false)`
     /// if the value is not found, an `Err` if it's not a valid boolean.
     pub fn get_bool(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<bool, ConfigError> {
         Ok(self.get_option(section, item)?.unwrap_or(false))
     }
 
     /// Returns the raw value bytes of the first one found, or `None`.
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> {
         self.get_inner(section, item)
             .map(|(_, value)| value.bytes.as_ref())
     }
 
     /// Returns the layer and the value of the first one found, or `None`.
     fn get_inner(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<(&ConfigLayer, &ConfigValue)> {
         for layer in self.layers.iter().rev() {
             if !layer.trusted {
                 continue;
             }
             if let Some(v) = layer.get(&section, &item) {
                 return Some((&layer, v));
             }
         }
         None
     }
 
     /// Get raw values bytes from all layers (even untrusted ones) in order
     /// of precedence.
     #[cfg(test)]
     fn get_all(&self, section: &[u8], item: &[u8]) -> Vec<&[u8]> {
         let mut res = vec![];
         for layer in self.layers.iter().rev() {
             if let Some(v) = layer.get(&section, &item) {
                 res.push(v.bytes.as_ref());
             }
         }
         res
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     use std::fs::File;
     use std::io::Write;
 
     #[test]
     fn test_include_layer_ordering() {
         let tmpdir = tempfile::tempdir().unwrap();
         let tmpdir_path = tmpdir.path();
         let mut included_file =
             File::create(&tmpdir_path.join("included.rc")).unwrap();
 
         included_file.write_all(b"[section]\nitem=value1").unwrap();
         let base_config_path = tmpdir_path.join("base.rc");
         let mut config_file = File::create(&base_config_path).unwrap();
         let data =
             b"[section]\nitem=value0\n%include included.rc\nitem=value2";
         config_file.write_all(data).unwrap();
 
         let sources = vec![ConfigSource::AbsPath(base_config_path)];
         let config = Config::load_from_explicit_sources(sources)
             .expect("expected valid config");
 
         let (_, value) = config.get_inner(b"section", b"item").unwrap();
         assert_eq!(
             value,
             &ConfigValue {
                 bytes: b"value2".to_vec(),
                 line: Some(4)
             }
         );
 
         let value = config.get(b"section", b"item").unwrap();
         assert_eq!(value, b"value2",);
         assert_eq!(
             config.get_all(b"section", b"item"),
             [b"value2", b"value1", b"value0"]
         );
     }
 }

rust/hg-core/src/config/layer.rs

@@ -1,255 +1,298 b''
 // layer.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::errors::{HgError, IoResultExt};
 use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};
 use format_bytes::{write_bytes, DisplayBytes};
 use lazy_static::lazy_static;
 use regex::bytes::Regex;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 lazy_static! {
     static ref SECTION_RE: Regex = make_regex(r"^\[([^\[]+)\]");
     static ref ITEM_RE: Regex = make_regex(r"^([^=\s][^=]*?)\s*=\s*((.*\S)?)");
     /// Continuation whitespace
     static ref CONT_RE: Regex = make_regex(r"^\s+(\S|\S.*\S)\s*$");
     static ref EMPTY_RE: Regex = make_regex(r"^(;|#|\s*$)");
     static ref COMMENT_RE: Regex = make_regex(r"^(;|#)");
     /// A directive that allows for removing previous entries
     static ref UNSET_RE: Regex = make_regex(r"^%unset\s+(\S+)");
     /// A directive that allows for including other config files
     static ref INCLUDE_RE: Regex = make_regex(r"^%include\s+(\S|\S.*\S)\s*$");
 }
 
 /// All config values separated by layers of precedence.
 /// Each config source may be split in multiple layers if `%include` directives
 /// are used.
 /// TODO detail the general precedence
 #[derive(Clone)]
 pub struct ConfigLayer {
     /// Mapping of the sections to their items
     sections: HashMap<Vec<u8>, ConfigItem>,
     /// All sections (and their items/values) in a layer share the same origin
     pub origin: ConfigOrigin,
     /// Whether this layer comes from a trusted user or group
     pub trusted: bool,
 }
 
 impl ConfigLayer {
     pub fn new(origin: ConfigOrigin) -> Self {
         ConfigLayer {
             sections: HashMap::new(),
             trusted: true, // TODO check
             origin,
         }
     }
 
+    /// Parse `--config` CLI arguments and return a layer if there’s any
+    pub(crate) fn parse_cli_args(
+        cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
+    ) -> Result<Option<Self>, ConfigError> {
+        fn parse_one(arg: &[u8]) -> Option<(Vec<u8>, Vec<u8>, Vec<u8>)> {
+            use crate::utils::SliceExt;
+
+            let (section_and_item, value) = split_2(arg, b'=')?;
+            let (section, item) = split_2(section_and_item.trim(), b'.')?;
+            Some((
+                section.to_owned(),
+                item.to_owned(),
+                value.trim().to_owned(),
+            ))
+        }
+
+        fn split_2(bytes: &[u8], separator: u8) -> Option<(&[u8], &[u8])> {
+            let mut iter = bytes.splitn(2, |&byte| byte == separator);
+            let a = iter.next()?;
+            let b = iter.next()?;
+            Some((a, b))
+        }
+
+        let mut layer = Self::new(ConfigOrigin::CommandLine);
+        for arg in cli_config_args {
+            let arg = arg.as_ref();
+            if let Some((section, item, value)) = parse_one(arg) {
+                layer.add(section, item, value, None);
+            } else {
+                Err(HgError::abort(format!(
+                    "malformed --config option: \"{}\" \
+                    (use --config section.name=value)",
+                    String::from_utf8_lossy(arg),
+                )))?
+            }
+        }
+        if layer.sections.is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some(layer))
+        }
+    }
+
     /// Returns whether this layer comes from `--config` CLI arguments
     pub(crate) fn is_from_command_line(&self) -> bool {
         if let ConfigOrigin::CommandLine = self.origin {
             true
         } else {
             false
         }
     }
 
     /// Add an entry to the config, overwriting the old one if already present.
     pub fn add(
         &mut self,
         section: Vec<u8>,
         item: Vec<u8>,
         value: Vec<u8>,
         line: Option<usize>,
     ) {
         self.sections
             .entry(section)
             .or_insert_with(|| HashMap::new())
             .insert(item, ConfigValue { bytes: value, line });
     }
 
     /// Returns the config value in `<section>.<item>` if it exists
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&ConfigValue> {
         Some(self.sections.get(section)?.get(item)?)
     }
 
     pub fn is_empty(&self) -> bool {
         self.sections.is_empty()
     }
 
     /// Returns a `Vec` of layers in order of precedence (so, in read order),
     /// recursively parsing the `%include` directives if any.
     pub fn parse(src: &Path, data: &[u8]) -> Result<Vec<Self>, ConfigError> {
         let mut layers = vec![];
 
         // Discard byte order mark if any
         let data = if data.starts_with(b"\xef\xbb\xbf") {
             &data[3..]
         } else {
             data
         };
 
         // TODO check if it's trusted
         let mut current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
 
         let mut lines_iter =
             data.split(|b| *b == b'\n').enumerate().peekable();
         let mut section = b"".to_vec();
 
         while let Some((index, bytes)) = lines_iter.next() {
             if let Some(m) = INCLUDE_RE.captures(&bytes) {
                 let filename_bytes = &m[1];
                 // `Path::parent` only fails for the root directory,
                 // which `src` can’t be since we’ve managed to open it as a
                 // file.
                 let dir = src
                     .parent()
                     .expect("Path::parent fail on a file we’ve read");
                 // `Path::join` with an absolute argument correctly ignores the
                 // base path
                 let filename = dir.join(&get_path_from_bytes(&filename_bytes));
                 let data = std::fs::read(&filename).for_file(&filename)?;
                 layers.push(current_layer);
                 layers.extend(Self::parse(&filename, &data)?);
                 current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
             } else if let Some(_) = EMPTY_RE.captures(&bytes) {
             } else if let Some(m) = SECTION_RE.captures(&bytes) {
                 section = m[1].to_vec();
             } else if let Some(m) = ITEM_RE.captures(&bytes) {
                 let item = m[1].to_vec();
                 let mut value = m[2].to_vec();
                 loop {
                     match lines_iter.peek() {
                         None => break,
                         Some((_, v)) => {
                             if let Some(_) = COMMENT_RE.captures(&v) {
                             } else if let Some(_) = CONT_RE.captures(&v) {
                                 value.extend(b"\n");
                                 value.extend(&m[1]);
                             } else {
                                 break;
                             }
                         }
                     };
                     lines_iter.next();
                 }
                 current_layer.add(
                     section.clone(),
                     item,
                     value,
                     Some(index + 1),
                 );
             } else if let Some(m) = UNSET_RE.captures(&bytes) {
                 if let Some(map) = current_layer.sections.get_mut(&section) {
                     map.remove(&m[1]);
                 }
             } else {
                 return Err(ConfigParseError {
                     origin: ConfigOrigin::File(src.to_owned()),
                     line: Some(index + 1),
                     bytes: bytes.to_owned(),
                 }
                 .into());
             }
         }
         if !current_layer.is_empty() {
             layers.push(current_layer);
         }
         Ok(layers)
     }
 }
 
 impl DisplayBytes for ConfigLayer {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         let mut sections: Vec<_> = self.sections.iter().collect();
         sections.sort_by(|e0, e1| e0.0.cmp(e1.0));
 
         for (section, items) in sections.into_iter() {
             let mut items: Vec<_> = items.into_iter().collect();
             items.sort_by(|e0, e1| e0.0.cmp(e1.0));
 
             for (item, config_entry) in items {
                 write_bytes!(
                     out,
                     b"{}.{}={} # {}\n",
                     section,
                     item,
                     &config_entry.bytes,
                     &self.origin,
                 )?
             }
         }
         Ok(())
     }
 }
 
 /// Mapping of section item to value.
 /// In the following:
 /// ```text
 /// [ui]
 /// paginate=no
 /// ```
 /// "paginate" is the section item and "no" the value.
 pub type ConfigItem = HashMap<Vec<u8>, ConfigValue>;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ConfigValue {
     /// The raw bytes of the value (be it from the CLI, env or from a file)
     pub bytes: Vec<u8>,
     /// Only present if the value comes from a file, 1-indexed.
     pub line: Option<usize>,
 }
 
 #[derive(Clone, Debug)]
 pub enum ConfigOrigin {
     /// From a configuration file
     File(PathBuf),
     /// From a `--config` CLI argument
     CommandLine,
     /// From environment variables like `$PAGER` or `$EDITOR`
     Environment(Vec<u8>),
     /* TODO cli
      * TODO defaults (configitems.py)
      * TODO extensions
      * TODO Python resources?
      * Others? */
 }
 
 impl DisplayBytes for ConfigOrigin {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         match self {
             ConfigOrigin::File(p) => out.write_all(&get_bytes_from_path(p)),
             ConfigOrigin::CommandLine => out.write_all(b"--config"),
             ConfigOrigin::Environment(e) => write_bytes!(out, b"${}", e),
         }
     }
 }
 
 #[derive(Debug)]
 pub struct ConfigParseError {
     pub origin: ConfigOrigin,
     pub line: Option<usize>,
     pub bytes: Vec<u8>,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum ConfigError {
     Parse(ConfigParseError),
     Other(HgError),
 }
 
 fn make_regex(pattern: &'static str) -> Regex {
     Regex::new(pattern).expect("expected a valid regex")
 }

rust/rhg/src/main.rs

@@ -1,116 +1,137 b''
 extern crate log;
 use clap::App;
 use clap::AppSettings;
 use clap::Arg;
 use clap::ArgMatches;
 use format_bytes::format_bytes;
 use std::path::Path;
 
 mod error;
 mod exitcode;
 mod ui;
 use error::CommandError;
 
 fn add_global_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
     app.arg(
         Arg::with_name("repository")
             .help("repository root directory")
             .short("-R")
             .long("--repository")
             .value_name("REPO")
             .takes_value(true),
     )
+    .arg(
+        Arg::with_name("config")
+            .help("set/override config option (use 'section.name=value')")
+            .long("--config")
+            .value_name("CONFIG")
+            .takes_value(true)
+            // Ok: `--config section.key1=val --config section.key2=val2`
+            .multiple(true)
+            // Not ok: `--config section.key1=val section.key2=val2`
+            .number_of_values(1),
+    )
 }
 
 fn main() {
     env_logger::init();
     let app = App::new("rhg")
         .setting(AppSettings::AllowInvalidUtf8)
         .setting(AppSettings::SubcommandRequired)
         .setting(AppSettings::VersionlessSubcommands)
         .version("0.0.1");
     let app = add_global_args(app);
     let app = add_subcommand_args(app);
 
     let ui = ui::Ui::new();
 
     let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {
         let _ = ui.writeln_stderr_str(&err.message);
         std::process::exit(exitcode::UNIMPLEMENTED)
     });
 
     let (subcommand_name, subcommand_matches) = matches.subcommand();
     let run = subcommand_run_fn(subcommand_name)
         .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");
     let args = subcommand_matches
         .expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired");
 
     // Global arguments can be in either based on e.g. `hg -R ./foo log` v.s.
     // `hg log -R ./foo`
-    let global_arg =
+    let value_of_global_arg =
         |name| args.value_of_os(name).or_else(|| matches.value_of_os(name));
+    // For arguments where multiple occurences are allowed, return a
+    // possibly-iterator of all values.
+    let values_of_global_arg = |name: &str| {
+        let a = matches.values_of_os(name).into_iter().flatten();
+        let b = args.values_of_os(name).into_iter().flatten();
+        a.chain(b)
+    };
 
-    let repo_path = global_arg("repository").map(Path::new);
+    let repo_path = value_of_global_arg("repository").map(Path::new);
     let result = (|| -> Result<(), CommandError> {
-        let config = hg::config::Config::load()?;
+        let config_args = values_of_global_arg("config")
+            // `get_bytes_from_path` works for OsStr the same as for Path
+            .map(hg::utils::files::get_bytes_from_path);
+        let config = hg::config::Config::load(config_args)?;
         run(&ui, &config, repo_path, args)
     })();
 
     let exit_code = match 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)
 }
 
 macro_rules! subcommands {
     ($( $command: ident )+) => {
         mod commands {
             $(
                 pub mod $command;
             )+
         }
 
         fn add_subcommand_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
             app
             $(
                 .subcommand(add_global_args(commands::$command::args()))
             )+
         }
 
         fn subcommand_run_fn(name: &str) -> Option<fn(
             &ui::Ui,
             &hg::config::Config,
             Option<&Path>,
             &ArgMatches,
         ) -> Result<(), CommandError>> {
             match name {
                 $(
                     stringify!($command) => Some(commands::$command::run),
                 )+
                 _ => None,
             }
         }
     };
 }
 
 subcommands! {
     cat
     debugdata
     debugrequirements
     files
     root
 }