This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9971

rhg: Add support for --config CLI arguments
ClosedPublic

Authored by SimonSapin on Feb 8 2021, 5:44 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG2e5dd18d6dc3: rhg: Add support for --config CLI arguments
rHG87fd7f47850a: rhg: Add support for --config CLI arguments

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Feb 8 2021, 5:44 PM
SimonSapin updated this revision to Diff 25509.Feb 9 2021, 3:07 AM
Alphare accepted this revision.Feb 9 2021, 4:28 AM
Alphare added a subscriber: Alphare.

I see that tests are added in the next patch, which makes sense considering we've avoided needing config so far.

SimonSapin added a commit: rHG87fd7f47850a: rhg: Add support for --config CLI arguments.Feb 11 2021, 11:37 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG87fd7f47850a: rhg: Add support for --config CLI arguments (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25562

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

_ => None, _ => None,
} }
} }
impl Config { impl Config {
/// Load system and user configuration from various files. /// Load system and user configuration from various files.
/// ///
/// This is also affected by some environment variables. /// This is also affected by some environment variables.
/// pub fn load(
/// TODO: add a parameter for `--config` CLI arguments cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
pub fn load() -> Result<Self, ConfigError> { ) -> Result<Self, ConfigError> {
let mut config = Self { layers: Vec::new() }; let mut config = Self { layers: Vec::new() };
let opt_rc_path = env::var_os("HGRCPATH"); let opt_rc_path = env::var_os("HGRCPATH");
// HGRCPATH replaces system config // HGRCPATH replaces system config
if opt_rc_path.is_none() { if opt_rc_path.is_none() {
config.add_system_config()? config.add_system_config()?
} }
config.add_for_environment_variable("EDITOR", b"ui", b"editor"); 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("VISUAL", b"ui", b"editor");
config.add_for_environment_variable("PAGER", b"pager", b"pager"); config.add_for_environment_variable("PAGER", b"pager", b"pager");
// HGRCPATH replaces user config // HGRCPATH replaces user config
if opt_rc_path.is_none() { if opt_rc_path.is_none() {
config.add_user_config()? config.add_user_config()?
} }
if let Some(rc_path) = &opt_rc_path { if let Some(rc_path) = &opt_rc_path {
for path in env::split_paths(rc_path) { for path in env::split_paths(rc_path) {
if !path.as_os_str().is_empty() { if !path.as_os_str().is_empty() {
if path.is_dir() { if path.is_dir() {
config.add_trusted_dir(&path)? config.add_trusted_dir(&path)?
} else { } else {
config.add_trusted_file(&path)? config.add_trusted_file(&path)?
} }
} }
} }
} }
if let Some(layer) = ConfigLayer::parse_cli_args(cli_config_args)? {
config.layers.push(layer)
}
Ok(config) Ok(config)
} }
fn add_trusted_dir(&mut self, path: &Path) -> Result<(), ConfigError> { fn add_trusted_dir(&mut self, path: &Path) -> Result<(), ConfigError> {
if let Some(entries) = std::fs::read_dir(path) if let Some(entries) = std::fs::read_dir(path)
.for_file(path) .for_file(path)
.io_not_found_as_none()? .io_not_found_as_none()?
{ {

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

pub fn new(origin: ConfigOrigin) -> Self { pub fn new(origin: ConfigOrigin) -> Self {
ConfigLayer { ConfigLayer {
sections: HashMap::new(), sections: HashMap::new(),
trusted: true, // TODO check trusted: true, // TODO check
origin, 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 /// Returns whether this layer comes from `--config` CLI arguments
pub(crate) fn is_from_command_line(&self) -> bool { pub(crate) fn is_from_command_line(&self) -> bool {
if let ConfigOrigin::CommandLine = self.origin { if let ConfigOrigin::CommandLine = self.origin {
true true
} else { } else {
false false
} }
} }

rust/rhg/src/main.rs

app.arg( app.arg(
Arg::with_name("repository") Arg::with_name("repository")
.help("repository root directory") .help("repository root directory")
.short("-R") .short("-R")
.long("--repository") .long("--repository")
.value_name("REPO") .value_name("REPO")
.takes_value(true), .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() { fn main() {
env_logger::init(); env_logger::init();
let app = App::new("rhg") let app = App::new("rhg")
.setting(AppSettings::AllowInvalidUtf8) .setting(AppSettings::AllowInvalidUtf8)
.setting(AppSettings::SubcommandRequired) .setting(AppSettings::SubcommandRequired)
.setting(AppSettings::VersionlessSubcommands) .setting(AppSettings::VersionlessSubcommands)
let (subcommand_name, subcommand_matches) = matches.subcommand(); let (subcommand_name, subcommand_matches) = matches.subcommand();
let run = subcommand_run_fn(subcommand_name) let run = subcommand_run_fn(subcommand_name)
.expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired"); .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");
let args = subcommand_matches let args = subcommand_matches
.expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired"); .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. // Global arguments can be in either based on e.g. `hg -R ./foo log` v.s.
// `hg log -R ./foo` // `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)); |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 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) run(&ui, &config, repo_path, args)
})(); })();
let exit_code = match result { let exit_code = match result {
Ok(_) => exitcode::OK, Ok(_) => exitcode::OK,
// Exit with a specific code and no error message to let a potential // Exit with a specific code and no error message to let a potential
// wrapper script fallback to Python-based Mercurial. // wrapper script fallback to Python-based Mercurial.