This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9906

rust: Fold find_root and check_requirements into Repo::find
ClosedPublic

Authored by SimonSapin on Jan 28 2021, 2:40 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1dcd9c9975ed: rust: Fold find_root and check_requirements into 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.Jan 28 2021, 2:40 PM
Alphare added a subscriber: Alphare.Jan 29 2021, 9:26 AM
Alphare added inline comments.
tests/test-rhg.t
25

This is wrong: we're supposed to conform to the Mercurial UI as much as possible. Possibly we should update the message to also say or its ancestors, but that's for a separate patch.

Alphare requested changes to this revision.Jan 29 2021, 9:26 AM
This revision now requires changes to proceed.Jan 29 2021, 9:26 AM
Alphare accepted this revision.Jan 29 2021, 6:07 PM
SimonSapin added a commit: rHG1dcd9c9975ed: rust: Fold find_root and check_requirements into Repo::find.Feb 1 2021, 12:38 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG1dcd9c9975ed: rust: Fold find_root and check_requirements into Repo::find (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25440

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

// config.rs // config.rs
// //
// Copyright 2020 // Copyright 2020
// Valentin Gatien-Baron, // Valentin Gatien-Baron,
// Raphaël Gomès <rgomes@octobus.net> // Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use super::layer; use super::layer;
use crate::config::layer::{ConfigError, ConfigLayer, ConfigValue}; use crate::config::layer::{ConfigError, ConfigLayer, ConfigValue};
use std::path::PathBuf; use std::path::PathBuf;
use crate::operations::find_root; use crate::repo::Repo;
use crate::utils::files::read_whole_file; use crate::utils::files::read_whole_file;
/// Holds the config values for the current repository /// Holds the config values for the current repository
/// TODO update this docstring once we support more sources /// TODO update this docstring once we support more sources
pub struct Config { pub struct Config {
layers: Vec<layer::ConfigLayer>, layers: Vec<layer::ConfigLayer>,
} }
} }
} }
Ok(Config { layers }) Ok(Config { layers })
} }
/// Loads the local config. In a future version, this will also load the /// Loads the local config. In a future version, this will also load the
/// `$HOME/.hgrc` and more to mirror the Python implementation. /// `$HOME/.hgrc` and more to mirror the Python implementation.
pub fn load() -> Result<Self, ConfigError> { pub fn load_for_repo(repo: &Repo) -> Result<Self, ConfigError> {
let root = find_root().unwrap();
Ok(Self::load_from_explicit_sources(vec![ Ok(Self::load_from_explicit_sources(vec![
ConfigSource::AbsPath(root.join(".hg/hgrc")), ConfigSource::AbsPath(repo.hg_vfs().join("hgrc")),
])?) ])?)
} }
/// Returns an `Err` if the first value found is not a valid boolean. /// Returns an `Err` if the first value found is not a valid boolean.
/// Otherwise, returns an `Ok(option)`, where `option` is the boolean if /// Otherwise, returns an `Ok(option)`, where `option` is the boolean if
/// found, or `None`. /// found, or `None`.
pub fn get_option( pub fn get_option(
&self, &self,

rust/hg-core/src/operations/find_root.rs

  • This file was deleted.
use std::path::{Path, PathBuf};
/// Error type for `find_root`
#[derive(Debug)]
pub enum FindRootError {
/// Root of the repository has not been found
/// Contains the current directory used by FindRoot
RootNotFound(PathBuf),
/// The current directory does not exists or permissions are insufficient
/// to get access to it
GetCurrentDirError(std::io::Error),
}
/// Find the root of the repository
/// by searching for a .hg directory in the process’ current directory and its
/// ancestors
pub fn find_root() -> Result<PathBuf, FindRootError> {
let current_dir = std::env::current_dir()
.map_err(|e| FindRootError::GetCurrentDirError(e))?;
Ok(find_root_from_path(&current_dir)?.into())
}
/// Find the root of the repository
/// by searching for a .hg directory in the given directory and its ancestors
pub fn find_root_from_path(start: &Path) -> Result<&Path, FindRootError> {
if start.join(".hg").exists() {
return Ok(start);
}
for ancestor in start.ancestors() {
if ancestor.join(".hg").exists() {
return Ok(ancestor);
}
}
Err(FindRootError::RootNotFound(start.into()))
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile;
#[test]
fn dot_hg_not_found() {
let tmp_dir = tempfile::tempdir().unwrap();
let path = tmp_dir.path();
let err = find_root_from_path(&path).unwrap_err();
// TODO do something better
assert!(match err {
FindRootError::RootNotFound(p) => p == path.to_path_buf(),
_ => false,
})
}
#[test]
fn dot_hg_in_current_path() {
let tmp_dir = tempfile::tempdir().unwrap();
let root = tmp_dir.path();
fs::create_dir_all(root.join(".hg")).unwrap();
let result = find_root_from_path(&root).unwrap();
assert_eq!(result, root)
}
#[test]
fn dot_hg_in_parent() {
let tmp_dir = tempfile::tempdir().unwrap();
let root = tmp_dir.path();
fs::create_dir_all(root.join(".hg")).unwrap();
let directory = root.join("some/nested/directory");
let result = find_root_from_path(&directory).unwrap();
assert_eq!(result, root)
}
} /* tests */

rust/hg-core/src/operations/mod.rs

//! A distinction is made between operations and commands. //! A distinction is made between operations and commands.
//! An operation is what can be done whereas a command is what is exposed by //! An operation is what can be done whereas a command is what is exposed by
//! the cli. A single command can use several operations to achieve its goal. //! the cli. A single command can use several operations to achieve its goal.
mod cat; mod cat;
mod debugdata; mod debugdata;
mod dirstate_status; mod dirstate_status;
mod find_root;
mod list_tracked_files; mod list_tracked_files;
pub use cat::cat; pub use cat::cat;
pub use debugdata::{debug_data, DebugDataKind}; pub use debugdata::{debug_data, DebugDataKind};
pub use find_root::{find_root, find_root_from_path, FindRootError};
pub use list_tracked_files::Dirstate; pub use list_tracked_files::Dirstate;
pub use list_tracked_files::{list_rev_tracked_files, FilesForRev}; pub use list_tracked_files::{list_rev_tracked_files, FilesForRev};

rust/hg-core/src/repo.rs

use crate::errors::{HgError, IoResultExt}; use crate::errors::{HgError, IoResultExt};
use crate::operations::{find_root, FindRootError};
use crate::requirements; use crate::requirements;
use memmap::{Mmap, MmapOptions}; use memmap::{Mmap, MmapOptions};
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// A repository on disk /// A repository on disk
pub struct Repo { pub struct Repo {
working_directory: PathBuf, working_directory: PathBuf,
dot_hg: PathBuf, dot_hg: PathBuf,
store: PathBuf, store: PathBuf,
} }
#[derive(Debug, derive_more::From)]
pub enum RepoFindError {
NotFoundInCurrentDirectoryOrAncestors {
current_directory: PathBuf,
},
#[from]
Other(HgError),
}
/// Filesystem access abstraction for the contents of a given "base" diretory /// Filesystem access abstraction for the contents of a given "base" diretory
#[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 {
/// Returns `None` if the given path doesn’t look like a repository /// Search the current directory and its ancestores for a repository:
/// (doesn’t contain a `.hg` sub-directory). /// a working directory that contains a `.hg` sub-directory.
pub fn for_path(root: impl Into<PathBuf>) -> Self { pub fn find() -> Result<Self, RepoFindError> {
let working_directory = root.into(); let current_directory = crate::utils::current_dir()?;
let dot_hg = working_directory.join(".hg"); // ancestors() is inclusive: it first yields `current_directory` as-is.
Self { for ancestor in current_directory.ancestors() {
let dot_hg = ancestor.join(".hg");
if dot_hg.is_dir() {
let repo = Self {
store: dot_hg.join("store"), store: dot_hg.join("store"),
dot_hg, dot_hg,
working_directory, working_directory: ancestor.to_owned(),
};
requirements::check(&repo)?;
return Ok(repo);
} }
} }
Err(RepoFindError::NotFoundInCurrentDirectoryOrAncestors {
pub fn find() -> Result<Self, FindRootError> { current_directory,
find_root().map(Self::for_path) })
}
pub fn check_requirements(&self) -> Result<(), HgError> {
requirements::check(self)
} }
pub fn working_directory_path(&self) -> &Path { pub fn working_directory_path(&self) -> &Path {
&self.working_directory &self.working_directory
} }
/// For accessing repository files (in `.hg`), except for the store /// For accessing repository files (in `.hg`), except for the store
/// (`.hg/store`). /// (`.hg/store`).
pub(crate) fn _working_directory_vfs(&self) -> Vfs<'_> { pub(crate) fn _working_directory_vfs(&self) -> Vfs<'_> {
Vfs { Vfs {
base: &self.working_directory, base: &self.working_directory,
} }
} }
} }
impl Vfs<'_> { impl Vfs<'_> {
pub(crate) fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
self.base.join(relative_path)
}
pub(crate) fn read( pub(crate) fn read(
&self, &self,
relative_path: impl AsRef<Path>, relative_path: impl AsRef<Path>,
) -> Result<Vec<u8>, HgError> { ) -> Result<Vec<u8>, HgError> {
let path = self.base.join(relative_path); let path = self.join(relative_path);
std::fs::read(&path).for_file(&path) std::fs::read(&path).for_file(&path)
} }
pub(crate) fn mmap_open( pub(crate) fn mmap_open(
&self, &self,
relative_path: impl AsRef<Path>, relative_path: impl AsRef<Path>,
) -> Result<Mmap, HgError> { ) -> Result<Mmap, HgError> {
let path = self.base.join(relative_path); let path = self.base.join(relative_path);
let file = std::fs::File::open(&path).for_file(&path)?; let file = std::fs::File::open(&path).for_file(&path)?;
// TODO: what are the safety requirements here? // TODO: what are the safety requirements here?
let mmap = unsafe { MmapOptions::new().map(&file) }.for_file(&path)?; let mmap = unsafe { MmapOptions::new().map(&file) }.for_file(&path)?;
Ok(mmap) Ok(mmap)
} }
} }

rust/rhg/src/commands/cat.rs

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) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find()?;
repo.check_requirements()?;
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/files.rs

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) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find()?;
repo.check_requirements()?;
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/error.rs

use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::UiError; use crate::ui::UiError;
use hg::errors::{HgError, IoErrorContext}; use format_bytes::format_bytes;
use hg::operations::FindRootError; use hg::errors::HgError;
use hg::repo::RepoFindError;
use hg::revlog::revlog::RevlogError; use hg::revlog::revlog::RevlogError;
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)]
pub enum CommandError { pub enum CommandError {
/// Exit with an error message and "standard" failure exit code. /// Exit with an error message and "standard" failure exit code.
Abort { message: Vec<u8> }, Abort { message: Vec<u8> },
fn from(_error: UiError) -> Self { fn from(_error: UiError) -> Self {
// If we already failed writing to stdout or stderr, // If we already failed writing to stdout or stderr,
// writing an error message to stderr about it would be likely to fail // writing an error message to stderr about it would be likely to fail
// too. // too.
CommandError::abort("") CommandError::abort("")
} }
} }
impl From<FindRootError> for CommandError { impl From<RepoFindError> for CommandError {
fn from(err: FindRootError) -> Self { fn from(error: RepoFindError) -> Self {
match err { match error {
FindRootError::RootNotFound(path) => CommandError::abort(format!( RepoFindError::NotFoundInCurrentDirectoryOrAncestors {
"no repository found in '{}' (.hg not found)!", current_directory,
path.display() } => CommandError::Abort {
)), message: format_bytes!(
FindRootError::GetCurrentDirError(error) => HgError::IoError { b"no repository found in '{}' (.hg not found)!",
error, get_bytes_from_path(current_directory)
context: IoErrorContext::CurrentDir, ),
} },
.into(), RepoFindError::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!(

tests/test-rhg.t

USAGE: USAGE:
rhg <SUBCOMMAND> rhg <SUBCOMMAND>
For more information try --help For more information try --help
[252] [252]
Finding root Finding root
$ rhg root $ rhg root
abort: no repository found in '$TESTTMP' (.hg not found)! abort: no repository found in '$TESTTMP' (.hg not found)!
AlphareUnsubmitted
Not Done

This is wrong: we're supposed to conform to the Mercurial UI as much as possible. Possibly we should update the message to also say or its ancestors, but that's for a separate patch.

Alphare: This is wrong: we're supposed to conform to the Mercurial UI as much as possible. Possibly we…
[255] [255]
$ hg init repository $ hg init repository
$ cd repository $ cd repository
$ rhg root $ rhg root
$TESTTMP/repository $TESTTMP/repository
Unwritable file descriptor Unwritable file descriptor
$ echo indoor-pool >> .hg/requires $ echo indoor-pool >> .hg/requires
$ rhg files $ rhg files
[252] [252]
$ rhg cat -r 1 copy_of_original $ rhg cat -r 1 copy_of_original
[252] [252]
$ rhg debugrequirements $ rhg debugrequirements
dotencode [252]
fncache
generaldelta
revlogv1
sparserevlog
store
indoor-pool
$ echo -e '\xFF' >> .hg/requires $ echo -e '\xFF' >> .hg/requires
$ rhg debugrequirements $ rhg debugrequirements
abort: corrupted repository: parse error in 'requires' file abort: corrupted repository: parse error in 'requires' file
[255] [255]
Persistent nodemap Persistent nodemap
$ cd $TESTTMP $ cd $TESTTMP
rust/hg-core/src/config/config.rs