This is an archive of the discontinued Mercurial Phabricator instance.

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 25354

rust/hg-core/src/dirstate/status.rs

	PatternError,			PatternError,
	};			};
	use lazy_static::lazy_static;			use lazy_static::lazy_static;
	use micro_timer::timed;			use micro_timer::timed;
	use rayon::prelude::*;			use rayon::prelude::*;
	use std::{			use std::{
	borrow::Cow,			borrow::Cow,
	collections::HashSet,			collections::HashSet,
				fmt,
	fs::{read_dir, DirEntry},			fs::{read_dir, DirEntry},
	io::ErrorKind,			io::ErrorKind,
	ops::Deref,			ops::Deref,
	path::{Path, PathBuf},			path::{Path, PathBuf},
	};			};

	/// Wrong type of file from a `BadMatch`			/// Wrong type of file from a `BadMatch`
	/// Note: a lot of those don't exist on all platforms.			/// Note: a lot of those don't exist on all platforms.
	#[derive(Debug, Copy, Clone)]			#[derive(Debug, Copy, Clone)]
	pub enum BadType {			pub enum BadType {
	CharacterDevice,			CharacterDevice,
	BlockDevice,			BlockDevice,
	FIFO,			FIFO,
	Socket,			Socket,
	Directory,			Directory,
	Unknown,			Unknown,
	}			}

	impl ToString for BadType {			impl fmt::Display for BadType {
	fn to_string(&self) -> String {			fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match self {			f.write_str(match self {
	BadType::CharacterDevice => "character device",			BadType::CharacterDevice => "character device",
	BadType::BlockDevice => "block device",			BadType::BlockDevice => "block device",
	BadType::FIFO => "fifo",			BadType::FIFO => "fifo",
	BadType::Socket => "socket",			BadType::Socket => "socket",
	BadType::Directory => "directory",			BadType::Directory => "directory",
	BadType::Unknown => "unknown",			BadType::Unknown => "unknown",
	}			})
	.to_string()
	}			}
	}			}

	/// Was explicitly matched but cannot be found/accessed			/// Was explicitly matched but cannot be found/accessed
	#[derive(Debug, Copy, Clone)]			#[derive(Debug, Copy, Clone)]
	pub enum BadMatch {			pub enum BadMatch {
	OsError(i32),			OsError(i32),
	BadType(BadType),			BadType(BadType),
	/// An invalid path that cannot be represented in Mercurial was found			/// An invalid path that cannot be represented in Mercurial was found
	Path(HgPathError),			Path(HgPathError),
	/// An invalid "ignore" pattern was found			/// An invalid "ignore" pattern was found
	Pattern(PatternError),			Pattern(PatternError),
	}			}

	pub type StatusResult<T> = Result<T, StatusError>;			pub type StatusResult<T> = Result<T, StatusError>;

	impl ToString for StatusError {			impl fmt::Display for StatusError {
	fn to_string(&self) -> String {			fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match self {			match self {
	StatusError::IO(e) => e.to_string(),			StatusError::IO(error) => error.fmt(f),
	StatusError::Path(e) => e.to_string(),			StatusError::Path(error) => error.fmt(f),
	StatusError::Pattern(e) => e.to_string(),			StatusError::Pattern(error) => error.fmt(f),
	}			}
	}			}
	}			}

	/// Gives information about which files are changed in the working directory			/// Gives information about which files are changed in the working directory
	/// and how, compared to the revision we're based on			/// and how, compared to the revision we're based on
	pub struct Status<'a, M: Matcher + Sync> {			pub struct Status<'a, M: Matcher + Sync> {
	dmap: &'a DirstateMap,			dmap: &'a DirstateMap,

rust/hg-core/src/lib.rs

	pub mod utils;			pub mod utils;

	use crate::utils::hg_path::{HgPathBuf, HgPathError};			use crate::utils::hg_path::{HgPathBuf, HgPathError};
	pub use filepatterns::{			pub use filepatterns::{
	parse_pattern_syntax, read_pattern_file, IgnorePattern,			parse_pattern_syntax, read_pattern_file, IgnorePattern,
	PatternFileWarning, PatternSyntax,			PatternFileWarning, PatternSyntax,
	};			};
	use std::collections::HashMap;			use std::collections::HashMap;
				use std::fmt;
	use twox_hash::RandomXxHashBuilder64;			use twox_hash::RandomXxHashBuilder64;

	/// This is a contract between the `micro-timer` crate and us, to expose			/// This is a contract between the `micro-timer` crate and us, to expose
	/// the `log` crate as `crate::log`.			/// the `log` crate as `crate::log`.
	use log;			use log;

	pub type LineNumber = usize;			pub type LineNumber = usize;

	/// Rust's default hasher is too slow because it tries to prevent collision			/// Rust's default hasher is too slow because it tries to prevent collision
	/// attacks. We are not concerned about those: if an ill-minded person has			/// attacks. We are not concerned about those: if an ill-minded person has
	/// write access to your repository, you have other issues.			/// write access to your repository, you have other issues.
	pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;			pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;

	#[derive(Debug, PartialEq)]			#[derive(Debug, PartialEq)]
	pub enum DirstateMapError {			pub enum DirstateMapError {
	PathNotFound(HgPathBuf),			PathNotFound(HgPathBuf),
	EmptyPath,			EmptyPath,
	InvalidPath(HgPathError),			InvalidPath(HgPathError),
	}			}

	impl ToString for DirstateMapError {			impl fmt::Display for DirstateMapError {
	fn to_string(&self) -> String {			fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match self {			match self {
	DirstateMapError::PathNotFound(_) => {			DirstateMapError::PathNotFound(_) => {
	"expected a value, found none".to_string()			f.write_str("expected a value, found none")
	}			}
	DirstateMapError::EmptyPath => "Overflow in dirstate.".to_string(),			DirstateMapError::EmptyPath => {
	DirstateMapError::InvalidPath(e) => e.to_string(),			f.write_str("Overflow in dirstate.")
				}
				DirstateMapError::InvalidPath(path_error) => path_error.fmt(f),
	}			}
	}			}
	}			}

	#[derive(Debug, derive_more::From)]			#[derive(Debug, derive_more::From)]
	pub enum DirstateError {			pub enum DirstateError {
	Map(DirstateMapError),			Map(DirstateMapError),
	Common(errors::HgError),			Common(errors::HgError),
	}			}

	#[derive(Debug, derive_more::From)]			#[derive(Debug, derive_more::From)]
	pub enum PatternError {			pub enum PatternError {
	#[from]			#[from]
	Path(HgPathError),			Path(HgPathError),
	UnsupportedSyntax(String),			UnsupportedSyntax(String),
	UnsupportedSyntaxInFile(String, String, usize),			UnsupportedSyntaxInFile(String, String, usize),
	TooLong(usize),			TooLong(usize),
	#[from]			#[from]
	IO(std::io::Error),			IO(std::io::Error),
	/// Needed a pattern that can be turned into a regex but got one that			/// Needed a pattern that can be turned into a regex but got one that
	/// can't. This should only happen through programmer error.			/// can't. This should only happen through programmer error.
	NonRegexPattern(IgnorePattern),			NonRegexPattern(IgnorePattern),
	}			}

	impl ToString for PatternError {			impl fmt::Display for PatternError {
	fn to_string(&self) -> String {			fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match self {			match self {
	PatternError::UnsupportedSyntax(syntax) => {			PatternError::UnsupportedSyntax(syntax) => {
	format!("Unsupported syntax {}", syntax)			write!(f, "Unsupported syntax {}", syntax)
	}			}
	PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => {			PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => {
	format!(			write!(
				f,
	"{}:{}: unsupported syntax {}",			"{}:{}: unsupported syntax {}",
	file_path, line, syntax			file_path, line, syntax
	)			)
	}			}
	PatternError::TooLong(size) => {			PatternError::TooLong(size) => {
	format!("matcher pattern is too long ({} bytes)", size)			write!(f, "matcher pattern is too long ({} bytes)", size)
	}			}
	PatternError::IO(e) => e.to_string(),			PatternError::IO(error) => error.fmt(f),
	PatternError::Path(e) => e.to_string(),			PatternError::Path(error) => error.fmt(f),
	PatternError::NonRegexPattern(pattern) => {			PatternError::NonRegexPattern(pattern) => {
	format!("'{:?}' cannot be turned into a regex", pattern)			write!(f, "'{:?}' cannot be turned into a regex", pattern)
	}			}
	}			}
	}			}
	}			}

rust/hg-core/src/utils/hg_path.rs

	NotFsCompliant(HgPathBuf),			NotFsCompliant(HgPathBuf),
	/// `path` is the smallest invalid path			/// `path` is the smallest invalid path
	NotUnderRoot {			NotUnderRoot {
	path: PathBuf,			path: PathBuf,
	root: PathBuf,			root: PathBuf,
	},			},
	}			}

	impl ToString for HgPathError {			impl fmt::Display for HgPathError {
	fn to_string(&self) -> String {			fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match self {			match self {
	HgPathError::LeadingSlash(bytes) => {			HgPathError::LeadingSlash(bytes) => {
	format!("Invalid HgPath '{:?}': has a leading slash.", bytes)			write!(f, "Invalid HgPath '{:?}': has a leading slash.", bytes)
	}			}
	HgPathError::ConsecutiveSlashes {			HgPathError::ConsecutiveSlashes {
	bytes,			bytes,
	second_slash_index: pos,			second_slash_index: pos,
	} => format!(			} => write!(
				f,
	"Invalid HgPath '{:?}': consecutive slashes at pos {}.",			"Invalid HgPath '{:?}': consecutive slashes at pos {}.",
	bytes, pos			bytes, pos
	),			),
	HgPathError::ContainsNullByte {			HgPathError::ContainsNullByte {
	bytes,			bytes,
	null_byte_index: pos,			null_byte_index: pos,
	} => format!(			} => write!(
				f,
	"Invalid HgPath '{:?}': contains null byte at pos {}.",			"Invalid HgPath '{:?}': contains null byte at pos {}.",
	bytes, pos			bytes, pos
	),			),
	HgPathError::DecodeError(bytes) => {			HgPathError::DecodeError(bytes) => write!(
	format!("Invalid HgPath '{:?}': could not be decoded.", bytes)			f,
	}			"Invalid HgPath '{:?}': could not be decoded.",
				bytes
				),
	HgPathError::EndsWithSlash(path) => {			HgPathError::EndsWithSlash(path) => {
	format!("Audit failed for '{}': ends with a slash.", path)			write!(f, "Audit failed for '{}': ends with a slash.", path)
	}			}
	HgPathError::ContainsIllegalComponent(path) => format!(			HgPathError::ContainsIllegalComponent(path) => write!(
				f,
	"Audit failed for '{}': contains an illegal component.",			"Audit failed for '{}': contains an illegal component.",
	path			path
	),			),
	HgPathError::InsideDotHg(path) => format!(			HgPathError::InsideDotHg(path) => write!(
				f,
	"Audit failed for '{}': is inside the '.hg' folder.",			"Audit failed for '{}': is inside the '.hg' folder.",
	path			path
	),			),
	HgPathError::IsInsideNestedRepo {			HgPathError::IsInsideNestedRepo {
	path,			path,
	nested_repo: nested,			nested_repo: nested,
	} => format!(			} => {
				write!(f,
	"Audit failed for '{}': is inside a nested repository '{}'.",			"Audit failed for '{}': is inside a nested repository '{}'.",
	path, nested			path, nested
	),			)
	HgPathError::TraversesSymbolicLink { path, symlink } => format!(			}
				HgPathError::TraversesSymbolicLink { path, symlink } => write!(
				f,
	"Audit failed for '{}': traverses symbolic link '{}'.",			"Audit failed for '{}': traverses symbolic link '{}'.",
	path, symlink			path, symlink
	),			),
	HgPathError::NotFsCompliant(path) => format!(			HgPathError::NotFsCompliant(path) => write!(
				f,
	"Audit failed for '{}': cannot be turned into a \			"Audit failed for '{}': cannot be turned into a \
	filesystem path.",			filesystem path.",
	path			path
	),			),
	HgPathError::NotUnderRoot { path, root } => format!(			HgPathError::NotUnderRoot { path, root } => write!(
				f,
	"Audit failed for '{}': not under root {}.",			"Audit failed for '{}': not under root {}.",
	path.display(),			path.display(),
	root.display()			root.display()
	),			),
	}			}
	}			}
	}			}

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	25354		Jan 28 2021, 2:39 PM	★	★
Diff 2	25438	rHG6c778d20c8c20620b3c6e4a9da99b5088f90fe58	Jan 28 2021, 1:21 PM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

rust: replace ToString impls with DisplayClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 25354

rust/hg-core/src/dirstate/status.rs

rust/hg-core/src/lib.rs

rust/hg-core/src/utils/hg_path.rs

rust: replace ToString impls with Display
ClosedPublic

Revision Contents
Changeset List