This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9962

rhg: Parse system and user configuration at program start
ClosedPublic

Authored by SimonSapin on Feb 5 2021, 4:26 AM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGa6e4e4650bac: rhg: Parse system and user configuration at program start
Summary

… and pass it around up to Repo::find

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 5 2021, 4:26 AM
Alphare accepted this revision.Feb 8 2021, 9:26 AM
pulkit accepted this revision.Feb 10 2021, 7:12 AM
This revision is now accepted and ready to land.Feb 10 2021, 7:12 AM

Revision Contents
Changeset List

Diff 25529

rust/hg-core/src/repo.rs

use crate::config::Config;
use crate::errors::{HgError, IoResultExt}; use crate::errors::{HgError, IoResultExt};
use crate::requirements; use crate::requirements;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use memmap::{Mmap, MmapOptions}; use memmap::{Mmap, MmapOptions};
use std::collections::HashSet; use std::collections::HashSet;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// A repository on disk /// A repository on disk
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub(crate) struct Vfs<'a> { pub(crate) struct Vfs<'a> {
base: &'a Path, base: &'a Path,
} }
impl Repo { impl Repo {
/// Search the current directory and its ancestores for a repository: /// Search the current directory and its ancestores for a repository:
/// a working directory that contains a `.hg` sub-directory. /// a working directory that contains a `.hg` sub-directory.
pub fn find() -> Result<Self, RepoFindError> { pub fn find(_config: &Config) -> Result<Self, RepoFindError> {
let current_directory = crate::utils::current_dir()?; let current_directory = crate::utils::current_dir()?;
// ancestors() is inclusive: it first yields `current_directory` as-is. // ancestors() is inclusive: it first yields `current_directory` as-is.
for ancestor in current_directory.ancestors() { for ancestor in current_directory.ancestors() {
if ancestor.join(".hg").is_dir() { if ancestor.join(".hg").is_dir() {
return Ok(Self::new_at_path(ancestor.to_owned())?); return Ok(Self::new_at_path(ancestor.to_owned())?);
} }
} }
Err(RepoFindError::NotFoundInCurrentDirectoryOrAncestors { Err(RepoFindError::NotFoundInCurrentDirectoryOrAncestors {

rust/rhg/src/commands.rs

pub mod cat; pub mod cat;
pub mod debugdata; pub mod debugdata;
pub mod debugrequirements; pub mod debugrequirements;
pub mod files; pub mod files;
pub mod root; pub mod root;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::config::Config;
/// The common trait for rhg commands /// The common trait for rhg commands
/// ///
/// Normalize the interface of the commands provided by rhg /// Normalize the interface of the commands provided by rhg
pub trait Command { pub trait Command {
fn run(&self, ui: &Ui) -> Result<(), CommandError>; fn run(&self, ui: &Ui, config: &Config) -> Result<(), CommandError>;
} }

rust/rhg/src/commands/cat.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::config::Config;
use hg::operations::cat; use hg::operations::cat;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use micro_timer::timed; use micro_timer::timed;
use std::convert::TryFrom; use std::convert::TryFrom;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Output the current or given revision of files Output the current or given revision of files
fn display(&self, ui: &Ui, data: &[u8]) -> Result<(), CommandError> { fn display(&self, ui: &Ui, data: &[u8]) -> Result<(), CommandError> {
ui.write_stdout(data)?; ui.write_stdout(data)?;
Ok(()) Ok(())
} }
} }
impl<'a> Command for CatCommand<'a> { impl<'a> Command for CatCommand<'a> {
#[timed] #[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui, config: &Config) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find(config)?;
let cwd = hg::utils::current_dir()?; let cwd = hg::utils::current_dir()?;
let mut files = vec![]; let mut files = vec![];
for file in self.files.iter() { for file in self.files.iter() {
// TODO: actually normalize `..` path segments etc? // TODO: actually normalize `..` path segments etc?
let normalized = cwd.join(&file); let normalized = cwd.join(&file);
let stripped = normalized let stripped = normalized
.strip_prefix(&repo.working_directory_path()) .strip_prefix(&repo.working_directory_path())

rust/rhg/src/commands/debugdata.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::config::Config;
use hg::operations::{debug_data, DebugDataKind}; use hg::operations::{debug_data, DebugDataKind};
use hg::repo::Repo; use hg::repo::Repo;
use micro_timer::timed; use micro_timer::timed;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Dump the contents of a data file revision Dump the contents of a data file revision
"; ";
pub struct DebugDataCommand<'a> { pub struct DebugDataCommand<'a> {
rev: &'a str, rev: &'a str,
kind: DebugDataKind, kind: DebugDataKind,
} }
impl<'a> DebugDataCommand<'a> { impl<'a> DebugDataCommand<'a> {
pub fn new(rev: &'a str, kind: DebugDataKind) -> Self { pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
DebugDataCommand { rev, kind } DebugDataCommand { rev, kind }
} }
} }
impl<'a> Command for DebugDataCommand<'a> { impl<'a> Command for DebugDataCommand<'a> {
#[timed] #[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui, config: &Config) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find(config)?;
let data = debug_data(&repo, self.rev, self.kind) let data = debug_data(&repo, self.rev, self.kind)
.map_err(|e| (e, self.rev))?; .map_err(|e| (e, self.rev))?;
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
stdout.write_all(&data)?; stdout.write_all(&data)?;
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }

rust/rhg/src/commands/debugrequirements.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::config::Config;
use hg::repo::Repo; use hg::repo::Repo;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the current repo requirements. Print the current repo requirements.
"; ";
pub struct DebugRequirementsCommand {} pub struct DebugRequirementsCommand {}
impl DebugRequirementsCommand { impl DebugRequirementsCommand {
pub fn new() -> Self { pub fn new() -> Self {
DebugRequirementsCommand {} DebugRequirementsCommand {}
} }
} }
impl Command for DebugRequirementsCommand { impl Command for DebugRequirementsCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui, config: &Config) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find(config)?;
let mut output = String::new(); let mut output = String::new();
let mut requirements: Vec<_> = repo.requirements().iter().collect(); let mut requirements: Vec<_> = repo.requirements().iter().collect();
requirements.sort(); requirements.sort();
for req in requirements { for req in requirements {
output.push_str(req); output.push_str(req);
output.push('\n'); output.push('\n');
} }
ui.write_stdout(output.as_bytes())?; ui.write_stdout(output.as_bytes())?;
Ok(()) Ok(())
} }
} }

rust/rhg/src/commands/files.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::config::Config;
use hg::operations::list_rev_tracked_files; use hg::operations::list_rev_tracked_files;
use hg::operations::Dirstate; use hg::operations::Dirstate;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::files::{get_bytes_from_path, relativize_path}; use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::{HgPath, HgPathBuf}; use hg::utils::hg_path::{HgPath, HgPathBuf};
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
List tracked files. List tracked files.
stdout.write_all(b"\n")?; stdout.write_all(b"\n")?;
} }
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
impl<'a> Command for FilesCommand<'a> { impl<'a> Command for FilesCommand<'a> {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui, config: &Config) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find(config)?;
if let Some(rev) = self.rev { if let Some(rev) = self.rev {
let files = let files =
list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?; list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?;
self.display_files(ui, &repo, files.iter()) self.display_files(ui, &repo, files.iter())
} else { } else {
let distate = Dirstate::new(&repo)?; let distate = Dirstate::new(&repo)?;
let files = distate.tracked_files()?; let files = distate.tracked_files()?;
self.display_files(ui, &repo, files) self.display_files(ui, &repo, files)
} }
} }
} }

rust/rhg/src/commands/root.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct RootCommand {} pub struct RootCommand {}
impl RootCommand { impl RootCommand {
pub fn new() -> Self { pub fn new() -> Self {
RootCommand {} RootCommand {}
} }
} }
impl Command for RootCommand { impl Command for RootCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui, config: &Config) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find(config)?;
let bytes = get_bytes_from_path(repo.working_directory_path()); let bytes = get_bytes_from_path(repo.working_directory_path());
ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?; ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
Ok(()) Ok(())
} }
} }

rust/rhg/src/error.rs

use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::UiError; use crate::ui::UiError;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::{ConfigError, ConfigParseError};
use hg::errors::HgError; use hg::errors::HgError;
use hg::repo::RepoFindError; use hg::repo::RepoFindError;
use hg::revlog::revlog::RevlogError; use hg::revlog::revlog::RevlogError;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
use std::convert::From; use std::convert::From;
/// The kind of command error /// The kind of command error
#[derive(Debug)] #[derive(Debug)]
get_bytes_from_path(current_directory) get_bytes_from_path(current_directory)
), ),
}, },
RepoFindError::Other(error) => error.into(), RepoFindError::Other(error) => error.into(),
} }
} }
} }
impl From<ConfigError> for CommandError {
fn from(error: ConfigError) -> Self {
match error {
ConfigError::Parse(ConfigParseError {
origin,
line,
bytes,
}) => {
let line_message = if let Some(line_number) = line {
format_bytes!(
b" at line {}",
line_number.to_string().into_bytes()
)
} else {
Vec::new()
};
CommandError::Abort {
message: format_bytes!(
b"config parse error in {}{}: '{}'",
origin.to_bytes(),
line_message,
bytes
),
}
}
ConfigError::Other(error) => error.into(),
}
}
}
impl From<(RevlogError, &str)> for CommandError { impl From<(RevlogError, &str)> for CommandError {
fn from((err, rev): (RevlogError, &str)) -> CommandError { fn from((err, rev): (RevlogError, &str)) -> CommandError {
match err { match err {
RevlogError::InvalidRevision => CommandError::abort(format!( RevlogError::InvalidRevision => CommandError::abort(format!(
"invalid revision identifier {}", "invalid revision identifier {}",
rev rev
)), )),
RevlogError::AmbiguousPrefix => CommandError::abort(format!( RevlogError::AmbiguousPrefix => CommandError::abort(format!(
"ambiguous revision identifier {}", "ambiguous revision identifier {}",
rev rev
)), )),
RevlogError::Other(error) => error.into(), RevlogError::Other(error) => error.into(),
} }
} }
} }

rust/rhg/src/main.rs

}; };
std::process::exit(exit_code) std::process::exit(exit_code)
} }
fn match_subcommand( fn match_subcommand(
matches: ArgMatches, matches: ArgMatches,
ui: &ui::Ui, ui: &ui::Ui,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let config = hg::config::Config::load()?;
match matches.subcommand() { match matches.subcommand() {
("root", _) => commands::root::RootCommand::new().run(&ui), ("root", _) => commands::root::RootCommand::new().run(&ui, &config),
("files", Some(matches)) => { ("files", Some(matches)) => {
commands::files::FilesCommand::try_from(matches)?.run(&ui) commands::files::FilesCommand::try_from(matches)?.run(&ui, &config)
} }
("cat", Some(matches)) => { ("cat", Some(matches)) => {
commands::cat::CatCommand::try_from(matches)?.run(&ui) commands::cat::CatCommand::try_from(matches)?.run(&ui, &config)
} }
("debugdata", Some(matches)) => { ("debugdata", Some(matches)) => {
commands::debugdata::DebugDataCommand::try_from(matches)?.run(&ui) commands::debugdata::DebugDataCommand::try_from(matches)?
.run(&ui, &config)
} }
("debugrequirements", _) => { ("debugrequirements", _) => {
commands::debugrequirements::DebugRequirementsCommand::new() commands::debugrequirements::DebugRequirementsCommand::new()
.run(&ui) .run(&ui, &config)
} }
_ => unreachable!(), // Because of AppSettings::SubcommandRequired, _ => unreachable!(), // Because of AppSettings::SubcommandRequired,
} }
} }
impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::files::FilesCommand<'a> { impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::files::FilesCommand<'a> {
type Error = CommandError; type Error = CommandError;