( )⚙ 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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 32143

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.