This is an archive of the discontinued Mercurial Phabricator instance.

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

SimonSapin updated this revision to Diff 25371.Jan 29 2021, 12:49 PM

Alphare accepted this revision.Jan 29 2021, 6:07 PM

SimonSapin added a child revision: D9938: rust: use HgError in ConfigError.Feb 1 2021, 6:59 AM

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

		Path
M		rust/hg-core/src/config/config.rs (7 lines)
D	M	rust/hg-core/src/operations/find_root.rs (79 lines)
M		rust/hg-core/src/operations/mod.rs (2 lines)
M		rust/hg-core/src/repo.rs (48 lines)
M		rust/rhg/src/commands/cat.rs (1 line)
M		rust/rhg/src/commands/files.rs (1 line)
M		rust/rhg/src/error.rs (24 lines)
M		tests/test-rhg.t (10 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	25356		Jan 28 2021, 2:40 PM	★	★
Diff 2	25371		Jan 29 2021, 12:48 PM	★	★
Diff 3	25440	rHG1dcd9c9975eda56a0339c44e3c87f3a02213f7db	Jan 28 2021, 2:31 PM	★	★

Commit	Parents	Author	Summary	Date
9e1c8b134d09	81f0a6c642ce	Simon Sapin		Jan 28 2021, 2:31 PM

Status	Author	Revision
Closed	SimonSapin	D9938 rust: use HgError in ConfigError
Closed	SimonSapin	D9906 rust: Fold find_root and check_requirements into Repo::find
Closed	SimonSapin	D9905 rhg: Simplify CommandError based on its use
Closed	SimonSapin	D9904 rust: replace ToString impls with Display
Closed	SimonSapin	D9897 rust: use HgError in RevlogError and Vfs
Closed	SimonSapin	D9896 rust: replace RequirementsError with HgError
Closed	SimonSapin	D9895 rhg: Print an error message in more cases
Closed	SimonSapin	D9894 rust: Remove DirstateParseError and ListDirstateTrackedFilesError
Closed	SimonSapin	D9893 rust: Replace DirstatePackError with HgError
Closed	SimonSapin	D9892 rust: Introduce an `HgError` enum for common error cases
Closed	SimonSapin	D9877 rust: remove three enums that were identical to `RevlogError`
Closed	SimonSapin	D9876 rhg: replace `map_*_error` functions with `From` impls
Closed	SimonSapin	D9875 rust: replace trivial `impl From …` with `#[derive(derive_more::From)]`
Closed	SimonSapin	D9874 rust: remove `FooError` structs with only `kind: FooErrorKind` enum field
Closed	SimonSapin	D9873 rhg: centralize parsing of `--rev` CLI arguments
Closed	SimonSapin	D9864 rust: Remove hex parsing from the nodemap
Closed	SimonSapin	D9863 rust: Make NodePrefix allocation-free and Copy, remove NodePrefixRef
Closed	SimonSapin	D9862 rust: Exclude empty node prefixes
Closed	SimonSapin	D9861 rust: Simplify error type for reading hex node IDs
Closed	SimonSapin	D9860 rust: replace Node::encode_hex with std::fmt::LowerHex

Diff 25356

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 {
				NotFoundInCurrentDirectoryAncestors,
				#[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();			// ancestors() is inclusive: it first yields the current directory
	let dot_hg = working_directory.join(".hg");			// as-is.
	Self {			for ancestor in crate::utils::current_dir()?.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::NotFoundInCurrentDirectoryAncestors)
	pub fn find() -> Result<Self, FindRootError> {
	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 hg::errors::HgError;
	use hg::operations::FindRootError;			use hg::repo::RepoFindError;
	use hg::revlog::revlog::RevlogError;			use hg::revlog::revlog::RevlogError;
	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::NotFoundInCurrentDirectoryAncestors => {
	"no repository found in '{}' (.hg not found)!",			CommandError::abort(
	path.display()			"no repository found in the current directory or ancestors! \
	)),			(.hg not found)"
	FindRootError::GetCurrentDirError(error) => HgError::IoError {			)
	error,
	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 the current directory or ancestors! (.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

This is an archive of the discontinued Mercurial Phabricator instance.

rust: Fold find_root and check_requirements into Repo::findClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List