This is an archive of the discontinued Mercurial Phabricator instance.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	25505		Feb 8 2021, 5:44 PM	★	★
Diff 2	25509		Feb 9 2021, 3:07 AM	★	★
Diff 3	25562	rHG87fd7f47850a3028044ed4f7c32e18c01893470c	Feb 8 2021, 5:08 PM	★	★

Commit	Parents	Author	Summary	Date
1d85eaec7d0a	ea610720d5d1	Simon Sapin		Feb 8 2021, 5:08 PM

Status	Author	Revision
Closed	SimonSapin	D9972 rhg: add limited support for the `config` sub-command
Closed	SimonSapin	D9971 rhg: Add support for --config CLI arguments
Closed	SimonSapin	D9970 rhg: Add support for -R and --repository command-line arguments
Closed	SimonSapin	D9969 rhg: Replace subcommand boilerplate with a macro
Closed	SimonSapin	D9968 rhg: Move subcommand CLI arguments definitions to respective modules
Closed	SimonSapin	D9967 rhg: replace command structs with functions
Closed	SimonSapin	D9966 rust: Use the DisplayBytes trait in config printing
Closed	SimonSapin	D9964 rhg: Parse per-repository configuration
Closed	SimonSapin	D9963 rhg: Abort based on config on share-safe mismatch
Closed	SimonSapin	D9962 rhg: Parse system and user configuration at program start
Closed	SimonSapin	D9961 rust: Parse system and user configuration
Closed	SimonSapin	D9960 rust: Remove unnecessary check for absolute path before joining
Closed	SimonSapin	D9959 rust: replace read_whole_file with std::fs::read

Diff 25505

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.

This is an archive of the discontinued Mercurial Phabricator instance.

rhg: Add support for --config CLI argumentsClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 25505

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

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

rust/rhg/src/main.rs

rhg: Add support for --config CLI arguments
ClosedPublic

Revision Contents
Changeset List