( )⚙ D10134 rhg: Add support for --cwd

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10134

rhg: Add support for --cwd
ClosedPublic

Authored by SimonSapin on Mar 9 2021, 4:40 AM.

Details

Reviewers
marmoute
Alphare
Group Reviewers
hg-reviewers
Commits
rHG2255e7eb39e5: rhg: Add support for --cwd
Summary

This affect the meaning of relative paths in --repository,
which are resolved "early" by rhg in order to load config
which is needed before fallback to Python is considered.

An incorrect path could cause errors when loading a non-existent repo,
leading to failing tests even when fallback is enabled.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Mar 9 2021, 4:40 AM
baymax updated this revision to Diff 26193.Mar 9 2021, 8:40 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute accepted this revision.Mar 9 2021, 1:11 PM
Alphare accepted this revision.Mar 10 2021, 3:35 AM
SimonSapin edited the summary of this revision. (Show Details)Mar 12 2021, 5:07 PM
SimonSapin updated this revision to Diff 26295.
baymax updated this revision to Diff 26340.Mar 15 2021, 9:10 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

SimonSapin added a commit: rHG2255e7eb39e5: rhg: Add support for --cwd.Mar 16 2021, 5:46 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG2255e7eb39e5: rhg: Add support for --cwd (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/rhg/src/main.rs (62 lines)

Diff 26295

rust/rhg/src/main.rs

.value_name("CONFIG") .value_name("CONFIG")
.takes_value(true) .takes_value(true)
.global(true) .global(true)
// Ok: `--config section.key1=val --config section.key2=val2` // Ok: `--config section.key1=val --config section.key2=val2`
.multiple(true) .multiple(true)
// Not ok: `--config section.key1=val section.key2=val2` // Not ok: `--config section.key1=val section.key2=val2`
.number_of_values(1), .number_of_values(1),
) )
.arg(
Arg::with_name("cwd")
.help("change working directory")
.long("--cwd")
.value_name("DIR")
.takes_value(true)
.global(true),
)
.version("0.0.1"); .version("0.0.1");
let app = add_subcommand_args(app); let app = add_subcommand_args(app);
let matches = app.clone().get_matches_safe()?; let matches = app.clone().get_matches_safe()?;
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");
// enabled, in order to include everything in-between in the duration // enabled, in order to include everything in-between in the duration
// measurements. Reading config files can be slow if they’re on NFS. // measurements. Reading config files can be slow if they’re on NFS.
let process_start_time = blackbox::ProcessStartTime::now(); let process_start_time = blackbox::ProcessStartTime::now();
env_logger::init(); env_logger::init();
let ui = ui::Ui::new(); let ui = ui::Ui::new();
let early_args = EarlyArgs::parse(std::env::args_os()); let early_args = EarlyArgs::parse(std::env::args_os());
let initial_current_dir = early_args.cwd.map(|cwd| {
let cwd = get_path_from_bytes(&cwd);
std::env::current_dir()
.and_then(|initial| {
std::env::set_current_dir(cwd)?;
Ok(initial)
})
.unwrap_or_else(|error| {
exit(
&None,
&ui,
OnUnsupported::Abort,
Err(CommandError::abort(format!(
"abort: {}: '{}'",
error,
cwd.display()
))),
)
})
});
let non_repo_config = let non_repo_config =
Config::load(early_args.config).unwrap_or_else(|error| { Config::load(early_args.config).unwrap_or_else(|error| {
// Normally this is decided based on config, but we don’t have that // Normally this is decided based on config, but we don’t have that
// available. As of this writing config loading never returns an // available. As of this writing config loading never returns an
// "unsupported" error but that is not enforced by the type system. // "unsupported" error but that is not enforced by the type system.
let on_unsupported = OnUnsupported::Abort; let on_unsupported = OnUnsupported::Abort;
exit(&ui, on_unsupported, Err(error.into())) exit(&initial_current_dir, &ui, on_unsupported, Err(error.into()))
}); });
if let Some(repo_path_bytes) = &early_args.repo { if let Some(repo_path_bytes) = &early_args.repo {
lazy_static::lazy_static! { lazy_static::lazy_static! {
static ref SCHEME_RE: regex::bytes::Regex = static ref SCHEME_RE: regex::bytes::Regex =
// Same as `_matchscheme` in `mercurial/util.py` // Same as `_matchscheme` in `mercurial/util.py`
regex::bytes::Regex::new("^[a-zA-Z0-9+.\\-]+:").unwrap(); regex::bytes::Regex::new("^[a-zA-Z0-9+.\\-]+:").unwrap();
} }
if SCHEME_RE.is_match(&repo_path_bytes) { if SCHEME_RE.is_match(&repo_path_bytes) {
exit( exit(
&initial_current_dir,
&ui, &ui,
OnUnsupported::from_config(&non_repo_config), OnUnsupported::from_config(&non_repo_config),
Err(CommandError::UnsupportedFeature { Err(CommandError::UnsupportedFeature {
message: format_bytes!( message: format_bytes!(
b"URL-like --repository {}", b"URL-like --repository {}",
repo_path_bytes repo_path_bytes
), ),
}), }),
) )
} }
} }
let repo_path = early_args.repo.as_deref().map(get_path_from_bytes); let repo_path = early_args.repo.as_deref().map(get_path_from_bytes);
let repo_result = match Repo::find(&non_repo_config, repo_path) { let repo_result = match Repo::find(&non_repo_config, repo_path) {
Ok(repo) => Ok(repo), Ok(repo) => Ok(repo),
Err(RepoError::NotFound { at }) if repo_path.is_none() => { Err(RepoError::NotFound { at }) if repo_path.is_none() => {
// Not finding a repo is not fatal yet, if `-R` was not given // Not finding a repo is not fatal yet, if `-R` was not given
Err(NoRepoInCwdError { cwd: at }) Err(NoRepoInCwdError { cwd: at })
} }
Err(error) => exit( Err(error) => exit(
&initial_current_dir,
&ui, &ui,
OnUnsupported::from_config(&non_repo_config), OnUnsupported::from_config(&non_repo_config),
Err(error.into()), Err(error.into()),
), ),
}; };
let config = if let Ok(repo) = &repo_result { let config = if let Ok(repo) = &repo_result {
repo.config() repo.config()
} else { } else {
&non_repo_config &non_repo_config
}; };
let result = main_with_result( let result = main_with_result(
&process_start_time, &process_start_time,
&ui, &ui,
repo_result.as_ref(), repo_result.as_ref(),
config, config,
); );
exit(&ui, OnUnsupported::from_config(config), result) exit(
&initial_current_dir,
&ui,
OnUnsupported::from_config(config),
result,
)
} }
fn exit_code(result: &Result<(), CommandError>) -> i32 { fn exit_code(result: &Result<(), CommandError>) -> i32 {
match result { match result {
Ok(()) => exitcode::OK, Ok(()) => exitcode::OK,
Err(CommandError::Abort { .. }) => exitcode::ABORT, Err(CommandError::Abort { .. }) => exitcode::ABORT,
// 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.
Err(CommandError::UnsupportedFeature { .. }) => { Err(CommandError::UnsupportedFeature { .. }) => {
exitcode::UNIMPLEMENTED exitcode::UNIMPLEMENTED
} }
} }
} }
fn exit( fn exit(
initial_current_dir: &Option<PathBuf>,
ui: &Ui, ui: &Ui,
mut on_unsupported: OnUnsupported, mut on_unsupported: OnUnsupported,
result: Result<(), CommandError>, result: Result<(), CommandError>,
) -> ! { ) -> ! {
if let ( if let (
OnUnsupported::Fallback { executable }, OnUnsupported::Fallback { executable },
Err(CommandError::UnsupportedFeature { .. }), Err(CommandError::UnsupportedFeature { .. }),
) = (&on_unsupported, &result) ) = (&on_unsupported, &result)
{ {
let mut args = std::env::args_os(); let mut args = std::env::args_os();
let executable_path = get_path_from_bytes(&executable); let executable_path = get_path_from_bytes(&executable);
let this_executable = args.next().expect("exepcted argv[0] to exist"); let this_executable = args.next().expect("exepcted argv[0] to exist");
if executable_path == &PathBuf::from(this_executable) { if executable_path == &PathBuf::from(this_executable) {
// Avoid spawning infinitely many processes until resource // Avoid spawning infinitely many processes until resource
// exhaustion. // exhaustion.
let _ = ui.write_stderr(&format_bytes!( let _ = ui.write_stderr(&format_bytes!(
b"Blocking recursive fallback. The 'rhg.fallback-executable = {}' config \ b"Blocking recursive fallback. The 'rhg.fallback-executable = {}' config \
points to `rhg` itself.\n", points to `rhg` itself.\n",
executable executable
)); ));
on_unsupported = OnUnsupported::Abort on_unsupported = OnUnsupported::Abort
} else { } else {
// `args` is now `argv[1..]` since we’ve already consumed `argv[0]` // `args` is now `argv[1..]` since we’ve already consumed `argv[0]`
let result = Command::new(executable_path).args(args).status(); let mut command = Command::new(executable_path);
command.args(args);
if let Some(initial) = initial_current_dir {
command.current_dir(initial);
}
let result = command.status();
match result { match result {
Ok(status) => std::process::exit( Ok(status) => std::process::exit(
status.code().unwrap_or(exitcode::ABORT), status.code().unwrap_or(exitcode::ABORT),
), ),
Err(error) => { Err(error) => {
let _ = ui.write_stderr(&format_bytes!( let _ = ui.write_stderr(&format_bytes!(
b"tried to fall back to a '{}' sub-process but got error {}\n", b"tried to fall back to a '{}' sub-process but got error {}\n",
executable, format_bytes::Utf8(error) executable, format_bytes::Utf8(error)
/// ///
/// These arguments are still declared when we do use Clap later, so that Clap /// These arguments are still declared when we do use Clap later, so that Clap
/// does not return an error for their presence. /// does not return an error for their presence.
struct EarlyArgs { struct EarlyArgs {
/// Values of all `--config` arguments. (Possibly none) /// Values of all `--config` arguments. (Possibly none)
config: Vec<Vec<u8>>, config: Vec<Vec<u8>>,
/// Value of the `-R` or `--repository` argument, if any. /// Value of the `-R` or `--repository` argument, if any.
repo: Option<Vec<u8>>, repo: Option<Vec<u8>>,
/// Value of the `--cwd` argument, if any.
cwd: Option<Vec<u8>>,
} }
impl EarlyArgs { impl EarlyArgs {
fn parse(args: impl IntoIterator<Item = OsString>) -> Self { fn parse(args: impl IntoIterator<Item = OsString>) -> Self {
let mut args = args.into_iter().map(get_bytes_from_os_str); let mut args = args.into_iter().map(get_bytes_from_os_str);
let mut config = Vec::new(); let mut config = Vec::new();
let mut repo = None; let mut repo = None;
let mut cwd = None;
// Use `while let` instead of `for` so that we can also call // Use `while let` instead of `for` so that we can also call
// `args.next()` inside the loop. // `args.next()` inside the loop.
while let Some(arg) = args.next() { while let Some(arg) = args.next() {
if arg == b"--config" { if arg == b"--config" {
if let Some(value) = args.next() { if let Some(value) = args.next() {
config.push(value) config.push(value)
} }
} else if let Some(value) = arg.drop_prefix(b"--config=") { } else if let Some(value) = arg.drop_prefix(b"--config=") {
config.push(value.to_owned()) config.push(value.to_owned())
} }
if arg == b"--cwd" {
if let Some(value) = args.next() {
cwd = Some(value)
}
} else if let Some(value) = arg.drop_prefix(b"--cwd=") {
cwd = Some(value.to_owned())
}
if arg == b"--repository" || arg == b"-R" { if arg == b"--repository" || arg == b"-R" {
if let Some(value) = args.next() { if let Some(value) = args.next() {
repo = Some(value) repo = Some(value)
} }
} else if let Some(value) = arg.drop_prefix(b"--repository=") { } else if let Some(value) = arg.drop_prefix(b"--repository=") {
repo = Some(value.to_owned()) repo = Some(value.to_owned())
} else if let Some(value) = arg.drop_prefix(b"-R") { } else if let Some(value) = arg.drop_prefix(b"-R") {
repo = Some(value.to_owned()) repo = Some(value.to_owned())
} }
} }
Self { config, repo } Self { config, repo, cwd }
} }
} }
/// What to do when encountering some unsupported feature. /// What to do when encountering some unsupported feature.
/// ///
/// See `HgError::UnsupportedFeature` and `CommandError::UnsupportedFeature`. /// See `HgError::UnsupportedFeature` and `CommandError::UnsupportedFeature`.
enum OnUnsupported { enum OnUnsupported {
/// Print an error message describing what feature is not supported, /// Print an error message describing what feature is not supported,