( )⚙ D12164 rhg: Pass a &Config to Ui::new

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12164

rhg: Pass a &Config to Ui::new
ClosedPublic

Authored by SimonSapin on Feb 10 2022, 2:18 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1aaf11e35aec: rhg: Pass a &Config to Ui::new
Summary

When a Ui object is needed to print errors about configuration-loading errors,
an empty (default) configuration is used.

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 10 2022, 2:18 PM
SimonSapin updated this revision to Diff 32143.Feb 11 2022, 6:42 AM
Alphare accepted this revision.Feb 12 2022, 6:19 PM
This revision is now accepted and ready to land.Feb 12 2022, 6:19 PM
SimonSapin added a commit: rHG1aaf11e35aec: rhg: Pass a &Config to Ui::new.Feb 14 2022, 5:24 AM
Closed by commit rHG1aaf11e35aec: rhg: Pass a &Config to Ui::new (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32156

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

String::from_utf8_lossy(&self.item), String::from_utf8_lossy(&self.item),
self.expected_type, self.expected_type,
String::from_utf8_lossy(&self.value) String::from_utf8_lossy(&self.value)
) )
} }
} }
impl Config { impl Config {
/// The configuration to use when printing configuration-loading errors
pub fn empty() -> Self {
Self { layers: Vec::new() }
}
/// 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_non_repo() -> Result<Self, ConfigError> { pub fn load_non_repo() -> 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() {

rust/rhg/src/main.rs

fn main() { fn main() {
// Run this first, before we find out if the blackbox extension is even // Run this first, before we find out if the blackbox extension is even
// 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 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 initial_current_dir = early_args.cwd.map(|cwd| {
let cwd = get_path_from_bytes(&cwd); let cwd = get_path_from_bytes(&cwd);
std::env::current_dir() std::env::current_dir()
.and_then(|initial| { .and_then(|initial| {
std::env::set_current_dir(cwd)?; std::env::set_current_dir(cwd)?;
Ok(initial) Ok(initial)
}) })
.unwrap_or_else(|error| { .unwrap_or_else(|error| {
exit( exit(
&None, &None,
&ui, &Ui::new(&Config::empty()),
OnUnsupported::Abort, OnUnsupported::Abort,
Err(CommandError::abort(format!( Err(CommandError::abort(format!(
"abort: {}: '{}'", "abort: {}: '{}'",
error, error,
cwd.display() cwd.display()
))), ))),
false, false,
) )
}) })
}); });
let mut non_repo_config = let mut non_repo_config =
Config::load_non_repo().unwrap_or_else(|error| { Config::load_non_repo().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( exit(
&initial_current_dir, &initial_current_dir,
&ui, &Ui::new(&Config::empty()),
on_unsupported, on_unsupported,
Err(error.into()), Err(error.into()),
false, false,
) )
}); });
non_repo_config non_repo_config
.load_cli_args_config(early_args.config) .load_cli_args_config(early_args.config)
.unwrap_or_else(|error| { .unwrap_or_else(|error| {
exit( exit(
&initial_current_dir, &initial_current_dir,
&ui, &Ui::new(&non_repo_config),
OnUnsupported::from_config(&non_repo_config), OnUnsupported::from_config(&non_repo_config),
Err(error.into()), Err(error.into()),
non_repo_config non_repo_config
.get_bool(b"ui", b"detailed-exit-code") .get_bool(b"ui", b"detailed-exit-code")
.unwrap_or(false), .unwrap_or(false),
) )
}); });
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, &initial_current_dir,
&ui, &Ui::new(&non_repo_config),
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
), ),
}), }),
// TODO: show a warning or combine with original error if // TODO: show a warning or combine with original error if
{ {
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, &initial_current_dir,
&ui, &Ui::new(&non_repo_config),
OnUnsupported::from_config(&non_repo_config), OnUnsupported::from_config(&non_repo_config),
Err(error.into()), Err(error.into()),
// TODO: show a warning or combine with original error if // TODO: show a warning or combine with original error if
// `get_bool` returns an error // `get_bool` returns an error
non_repo_config non_repo_config
.get_bool(b"ui", b"detailed-exit-code") .get_bool(b"ui", b"detailed-exit-code")
.unwrap_or(false), .unwrap_or(false),
), ),
}; };
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 ui = Ui::new(&config);
let on_unsupported = OnUnsupported::from_config(config); let on_unsupported = OnUnsupported::from_config(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,
); );

rust/rhg/src/ui.rs

use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config;
use hg::utils::files::get_bytes_from_os_string; use hg::utils::files::get_bytes_from_os_string;
use std::borrow::Cow; use std::borrow::Cow;
use std::env; use std::env;
use std::io; use std::io;
use std::io::{ErrorKind, Write}; use std::io::{ErrorKind, Write};
#[derive(Debug)] #[derive(Debug)]
pub struct Ui { pub struct Ui {
stdout: std::io::Stdout, stdout: std::io::Stdout,
stderr: std::io::Stderr, stderr: std::io::Stderr,
} }
/// The kind of user interface error /// The kind of user interface error
pub enum UiError { pub enum UiError {
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError(io::Error), StdoutError(io::Error),
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError(io::Error), StderrError(io::Error),
} }
/// The commandline user interface /// The commandline user interface
impl Ui { impl Ui {
pub fn new() -> Self { pub fn new(_config: &Config) -> Self {
Ui { Ui {
stdout: std::io::stdout(), stdout: std::io::stdout(),
stderr: std::io::stderr(), stderr: std::io::stderr(),
} }
} }
/// Returns a buffered handle on stdout for faster batch printing /// Returns a buffered handle on stdout for faster batch printing
/// operations. /// operations.