This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9874

rust: remove `FooError` structs with only `kind: FooErrorKind` enum field
ClosedPublic

Authored by SimonSapin on Jan 26 2021, 2:59 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG3e2d539d0d1a: rust: remove `FooError` structs with only `kind: FooErrorKind` enum field
Summary

Use the enum directly as FooError instead.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Jan 26 2021, 2:59 PM
Alphare accepted this revision.Jan 29 2021, 7:57 AM
Alphare added a subscriber: Alphare.

...yeah I have no idea why we did it that way in the first place, thanks.

pulkit accepted this revision.Jan 31 2021, 2:41 PM
This revision is now accepted and ready to land.Jan 31 2021, 2:41 PM

Revision Contents
Changeset List

Diff 25271

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

use crate::revlog::revlog::Revlog; use crate::revlog::revlog::Revlog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n']; const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
/// Kind of error encountered by `CatRev` /// Error type for `cat`
#[derive(Debug)] #[derive(Debug)]
pub enum CatRevErrorKind { pub enum CatRevError {
/// Error when reading a `revlog` file. /// Error when reading a `revlog` file.
IoError(std::io::Error), IoError(std::io::Error),
/// The revision has not been found. /// The revision has not been found.
InvalidRevision, InvalidRevision,
/// Found more than one revision whose ID match the requested prefix /// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix, AmbiguousPrefix,
/// A `revlog` file is corrupted. /// A `revlog` file is corrupted.
CorruptedRevlog, CorruptedRevlog,
/// The `revlog` format version is not supported. /// The `revlog` format version is not supported.
UnsuportedRevlogVersion(u16), UnsuportedRevlogVersion(u16),
/// The `revlog` data format is not supported. /// The `revlog` data format is not supported.
UnknowRevlogDataFormat(u8), UnknowRevlogDataFormat(u8),
} }
/// A `CatRev` error
#[derive(Debug)]
pub struct CatRevError {
/// Kind of error encountered by `CatRev`
pub kind: CatRevErrorKind,
}
impl From<CatRevErrorKind> for CatRevError {
fn from(kind: CatRevErrorKind) -> Self {
CatRevError { kind }
}
}
impl From<RevlogError> for CatRevError { impl From<RevlogError> for CatRevError {
fn from(err: RevlogError) -> Self { fn from(err: RevlogError) -> Self {
match err { match err {
RevlogError::IoError(err) => CatRevErrorKind::IoError(err), RevlogError::IoError(err) => CatRevError::IoError(err),
RevlogError::UnsuportedVersion(version) => { RevlogError::UnsuportedVersion(version) => {
CatRevErrorKind::UnsuportedRevlogVersion(version) CatRevError::UnsuportedRevlogVersion(version)
} }
RevlogError::InvalidRevision => CatRevErrorKind::InvalidRevision, RevlogError::InvalidRevision => CatRevError::InvalidRevision,
RevlogError::AmbiguousPrefix => CatRevErrorKind::AmbiguousPrefix, RevlogError::AmbiguousPrefix => CatRevError::AmbiguousPrefix,
RevlogError::Corrupted => CatRevErrorKind::CorruptedRevlog, RevlogError::Corrupted => CatRevError::CorruptedRevlog,
RevlogError::UnknowDataFormat(format) => { RevlogError::UnknowDataFormat(format) => {
CatRevErrorKind::UnknowRevlogDataFormat(format) CatRevError::UnknowRevlogDataFormat(format)
} }
} }
.into()
} }
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
/// ///
/// * `root`: Repository root /// * `root`: Repository root
/// * `rev`: The revision to cat the files from. /// * `rev`: The revision to cat the files from.
/// * `files`: The files to output. /// * `files`: The files to output.
pub fn cat( pub fn cat(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
files: &[HgPathBuf], files: &[HgPathBuf],
) -> Result<Vec<u8>, CatRevError> { ) -> Result<Vec<u8>, CatRevError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
let changelog = Changelog::open(repo)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(repo)?; let manifest = Manifest::open(repo)?;
let changelog_entry = changelog.get_rev(rev)?; let changelog_entry = changelog.get_rev(rev)?;
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevError::CorruptedRevlog)?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
let mut bytes = vec![]; let mut bytes = vec![];
for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() { for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
for cat_file in files.iter() { for cat_file in files.iter() {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
let index_path = store_path(manifest_file, b".i"); let index_path = store_path(manifest_file, b".i");
let data_path = store_path(manifest_file, b".d"); let data_path = store_path(manifest_file, b".d");
let file_log = let file_log =
Revlog::open(repo, &index_path, Some(&data_path))?; Revlog::open(repo, &index_path, Some(&data_path))?;
let file_node = Node::from_hex(node_bytes) let file_node = Node::from_hex(node_bytes)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevError::CorruptedRevlog)?;
let file_rev = file_log.get_node_rev(file_node.into())?; let file_rev = file_log.get_node_rev(file_node.into())?;
let data = file_log.get_rev_data(file_rev)?; let data = file_log.get_rev_data(file_rev)?;
if data.starts_with(&METADATA_DELIMITER) { if data.starts_with(&METADATA_DELIMITER) {
let end_delimiter_position = data let end_delimiter_position = data
[METADATA_DELIMITER.len()..] [METADATA_DELIMITER.len()..]
.windows(METADATA_DELIMITER.len()) .windows(METADATA_DELIMITER.len())
.position(|bytes| bytes == METADATA_DELIMITER); .position(|bytes| bytes == METADATA_DELIMITER);
if let Some(position) = end_delimiter_position { if let Some(position) = end_delimiter_position {

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

/// Kind of data to debug /// Kind of data to debug
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum DebugDataKind { pub enum DebugDataKind {
Changelog, Changelog,
Manifest, Manifest,
} }
/// Kind of error encountered by DebugData /// Error type for `debug_data`
#[derive(Debug)] #[derive(Debug)]
pub enum DebugDataErrorKind { pub enum DebugDataError {
/// Error when reading a `revlog` file. /// Error when reading a `revlog` file.
IoError(std::io::Error), IoError(std::io::Error),
/// The revision has not been found. /// The revision has not been found.
InvalidRevision, InvalidRevision,
/// Found more than one revision whose ID match the requested prefix /// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix, AmbiguousPrefix,
/// A `revlog` file is corrupted. /// A `revlog` file is corrupted.
CorruptedRevlog, CorruptedRevlog,
/// The `revlog` format version is not supported. /// The `revlog` format version is not supported.
UnsuportedRevlogVersion(u16), UnsuportedRevlogVersion(u16),
/// The `revlog` data format is not supported. /// The `revlog` data format is not supported.
UnknowRevlogDataFormat(u8), UnknowRevlogDataFormat(u8),
} }
/// A DebugData error
#[derive(Debug)]
pub struct DebugDataError {
/// Kind of error encountered by DebugData
pub kind: DebugDataErrorKind,
}
impl From<DebugDataErrorKind> for DebugDataError {
fn from(kind: DebugDataErrorKind) -> Self {
DebugDataError { kind }
}
}
impl From<std::io::Error> for DebugDataError { impl From<std::io::Error> for DebugDataError {
fn from(err: std::io::Error) -> Self { fn from(err: std::io::Error) -> Self {
let kind = DebugDataErrorKind::IoError(err); DebugDataError::IoError(err)
DebugDataError { kind }
} }
} }
impl From<RevlogError> for DebugDataError { impl From<RevlogError> for DebugDataError {
fn from(err: RevlogError) -> Self { fn from(err: RevlogError) -> Self {
match err { match err {
RevlogError::IoError(err) => DebugDataErrorKind::IoError(err), RevlogError::IoError(err) => DebugDataError::IoError(err),
RevlogError::UnsuportedVersion(version) => { RevlogError::UnsuportedVersion(version) => {
DebugDataErrorKind::UnsuportedRevlogVersion(version) DebugDataError::UnsuportedRevlogVersion(version)
}
RevlogError::InvalidRevision => {
DebugDataErrorKind::InvalidRevision
}
RevlogError::AmbiguousPrefix => {
DebugDataErrorKind::AmbiguousPrefix
} }
RevlogError::Corrupted => DebugDataErrorKind::CorruptedRevlog, RevlogError::InvalidRevision => DebugDataError::InvalidRevision,
RevlogError::AmbiguousPrefix => DebugDataError::AmbiguousPrefix,
RevlogError::Corrupted => DebugDataError::CorruptedRevlog,
RevlogError::UnknowDataFormat(format) => { RevlogError::UnknowDataFormat(format) => {
DebugDataErrorKind::UnknowRevlogDataFormat(format) DebugDataError::UnknowRevlogDataFormat(format)
} }
} }
.into()
} }
} }
/// Dump the contents data of a revision. /// Dump the contents data of a revision.
pub fn debug_data( pub fn debug_data(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
kind: DebugDataKind, kind: DebugDataKind,

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

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

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

use crate::revlog::manifest::{Manifest, ManifestEntry}; use crate::revlog::manifest::{Manifest, ManifestEntry};
use crate::revlog::node::Node; use crate::revlog::node::Node;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{DirstateParseError, EntryState}; use crate::{DirstateParseError, EntryState};
use rayon::prelude::*; use rayon::prelude::*;
use std::convert::From; use std::convert::From;
/// Kind of error encountered by `ListDirstateTrackedFiles` /// Error type for `Dirstate` methods
#[derive(Debug)] #[derive(Debug)]
pub enum ListDirstateTrackedFilesErrorKind { pub enum ListDirstateTrackedFilesError {
/// Error when reading the `dirstate` file /// Error when reading the `dirstate` file
IoError(std::io::Error), IoError(std::io::Error),
/// Error when parsing the `dirstate` file /// Error when parsing the `dirstate` file
ParseError(DirstateParseError), ParseError(DirstateParseError),
} }
/// A `ListDirstateTrackedFiles` error
#[derive(Debug)]
pub struct ListDirstateTrackedFilesError {
/// Kind of error encountered by `ListDirstateTrackedFiles`
pub kind: ListDirstateTrackedFilesErrorKind,
}
impl From<ListDirstateTrackedFilesErrorKind>
for ListDirstateTrackedFilesError
{
fn from(kind: ListDirstateTrackedFilesErrorKind) -> Self {
ListDirstateTrackedFilesError { kind }
}
}
impl From<std::io::Error> for ListDirstateTrackedFilesError { impl From<std::io::Error> for ListDirstateTrackedFilesError {
fn from(err: std::io::Error) -> Self { fn from(err: std::io::Error) -> Self {
let kind = ListDirstateTrackedFilesErrorKind::IoError(err); ListDirstateTrackedFilesError::IoError(err)
ListDirstateTrackedFilesError { kind }
} }
} }
/// List files under Mercurial control in the working directory /// List files under Mercurial control in the working directory
/// by reading the dirstate /// by reading the dirstate
pub struct Dirstate { pub struct Dirstate {
/// The `dirstate` content. /// The `dirstate` content.
content: Vec<u8>, content: Vec<u8>,
} }
impl Dirstate { impl Dirstate {
pub fn new(repo: &Repo) -> Result<Self, ListDirstateTrackedFilesError> { pub fn new(repo: &Repo) -> Result<Self, ListDirstateTrackedFilesError> {
let content = repo.hg_vfs().read("dirstate")?; let content = repo.hg_vfs().read("dirstate")?;
Ok(Self { content }) Ok(Self { content })
} }
pub fn tracked_files( pub fn tracked_files(
&self, &self,
) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> { ) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
let (_, entries, _) = parse_dirstate(&self.content) let (_, entries, _) = parse_dirstate(&self.content)
.map_err(ListDirstateTrackedFilesErrorKind::ParseError)?; .map_err(ListDirstateTrackedFilesError::ParseError)?;
let mut files: Vec<&HgPath> = entries let mut files: Vec<&HgPath> = entries
.into_iter() .into_iter()
.filter_map(|(path, entry)| match entry.state { .filter_map(|(path, entry)| match entry.state {
EntryState::Removed => None, EntryState::Removed => None,
_ => Some(path), _ => Some(path),
}) })
.collect(); .collect();
files.par_sort_unstable(); files.par_sort_unstable();
Ok(files) Ok(files)
} }
} }
/// Kind of error encountered by `ListRevTrackedFiles` /// Error type `list_rev_tracked_files`
#[derive(Debug)] #[derive(Debug)]
pub enum ListRevTrackedFilesErrorKind { pub enum ListRevTrackedFilesError {
/// Error when reading a `revlog` file. /// Error when reading a `revlog` file.
IoError(std::io::Error), IoError(std::io::Error),
/// The revision has not been found. /// The revision has not been found.
InvalidRevision, InvalidRevision,
/// Found more than one revision whose ID match the requested prefix /// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix, AmbiguousPrefix,
/// A `revlog` file is corrupted. /// A `revlog` file is corrupted.
CorruptedRevlog, CorruptedRevlog,
/// The `revlog` format version is not supported. /// The `revlog` format version is not supported.
UnsuportedRevlogVersion(u16), UnsuportedRevlogVersion(u16),
/// The `revlog` data format is not supported. /// The `revlog` data format is not supported.
UnknowRevlogDataFormat(u8), UnknowRevlogDataFormat(u8),
} }
/// A `ListRevTrackedFiles` error
#[derive(Debug)]
pub struct ListRevTrackedFilesError {
/// Kind of error encountered by `ListRevTrackedFiles`
pub kind: ListRevTrackedFilesErrorKind,
}
impl From<ListRevTrackedFilesErrorKind> for ListRevTrackedFilesError {
fn from(kind: ListRevTrackedFilesErrorKind) -> Self {
ListRevTrackedFilesError { kind }
}
}
impl From<RevlogError> for ListRevTrackedFilesError { impl From<RevlogError> for ListRevTrackedFilesError {
fn from(err: RevlogError) -> Self { fn from(err: RevlogError) -> Self {
match err { match err {
RevlogError::IoError(err) => { RevlogError::IoError(err) => {
ListRevTrackedFilesErrorKind::IoError(err) ListRevTrackedFilesError::IoError(err)
} }
RevlogError::UnsuportedVersion(version) => { RevlogError::UnsuportedVersion(version) => {
ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) ListRevTrackedFilesError::UnsuportedRevlogVersion(version)
} }
RevlogError::InvalidRevision => { RevlogError::InvalidRevision => {
ListRevTrackedFilesErrorKind::InvalidRevision ListRevTrackedFilesError::InvalidRevision
} }
RevlogError::AmbiguousPrefix => { RevlogError::AmbiguousPrefix => {
ListRevTrackedFilesErrorKind::AmbiguousPrefix ListRevTrackedFilesError::AmbiguousPrefix
} }
RevlogError::Corrupted => { RevlogError::Corrupted => {
ListRevTrackedFilesErrorKind::CorruptedRevlog ListRevTrackedFilesError::CorruptedRevlog
} }
RevlogError::UnknowDataFormat(format) => { RevlogError::UnknowDataFormat(format) => {
ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) ListRevTrackedFilesError::UnknowRevlogDataFormat(format)
} }
} }
.into()
} }
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub fn list_rev_tracked_files( pub fn list_rev_tracked_files(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
) -> Result<FilesForRev, ListRevTrackedFilesError> { ) -> Result<FilesForRev, ListRevTrackedFilesError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
let changelog = Changelog::open(repo)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(repo)?; let manifest = Manifest::open(repo)?;
let changelog_entry = changelog.get_rev(rev)?; let changelog_entry = changelog.get_rev(rev)?;
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?; .or(Err(ListRevTrackedFilesError::CorruptedRevlog))?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
Ok(FilesForRev(manifest_entry)) Ok(FilesForRev(manifest_entry))
} }
pub struct FilesForRev(ManifestEntry); pub struct FilesForRev(ManifestEntry);
impl FilesForRev { impl FilesForRev {
pub fn iter(&self) -> impl Iterator<Item = &HgPath> { pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
self.0.files() self.0.files()
} }
} }

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 find_root;
mod list_tracked_files; mod list_tracked_files;
pub use cat::{cat, CatRevError, CatRevErrorKind}; pub use cat::{cat, CatRevError};
pub use debugdata::{ pub use debugdata::{debug_data, DebugDataError, DebugDataKind};
debug_data, DebugDataError, DebugDataErrorKind, DebugDataKind, pub use find_root::{find_root, find_root_from_path, FindRootError};
};
pub use find_root::{
find_root, find_root_from_path, FindRootError, FindRootErrorKind,
};
pub use list_tracked_files::{ pub use list_tracked_files::{
list_rev_tracked_files, FilesForRev, ListRevTrackedFilesError, list_rev_tracked_files, FilesForRev, ListRevTrackedFilesError,
ListRevTrackedFilesErrorKind,
};
pub use list_tracked_files::{
Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
}; };
pub use list_tracked_files::{Dirstate, ListDirstateTrackedFilesError};

rust/rhg/src/commands/cat.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::CommandError;
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{cat, CatRevError, CatRevErrorKind}; use hg::operations::{cat, CatRevError};
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
"; ";
} }
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()?; repo.check_requirements()?;
let cwd = std::env::current_dir() let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?; .or_else(|e| Err(CommandError::CurrentDirNotFound(e)))?;
let mut files = vec![]; let mut files = vec![];
for file in self.files.iter() { for file in self.files.iter() {
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())
.or(Err(CommandErrorKind::Abort(None)))?; .or(Err(CommandError::Abort(None)))?;
let hg_file = HgPathBuf::try_from(stripped.to_path_buf()) let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
.or(Err(CommandErrorKind::Abort(None)))?; .or(Err(CommandError::Abort(None)))?;
files.push(hg_file); files.push(hg_file);
} }
match self.rev { match self.rev {
Some(rev) => { Some(rev) => {
let data = cat(&repo, rev, &files) let data = cat(&repo, rev, &files)
.map_err(|e| map_rev_error(rev, e))?; .map_err(|e| map_rev_error(rev, e))?;
self.display(ui, &data) self.display(ui, &data)
} }
None => Err(CommandErrorKind::Unimplemented.into()), None => Err(CommandError::Unimplemented.into()),
} }
} }
} }
/// Convert `CatRevErrorKind` to `CommandError` /// Convert `CatRevError` to `CommandError`
fn map_rev_error(rev: &str, err: CatRevError) -> CommandError { fn map_rev_error(rev: &str, err: CatRevError) -> CommandError {
CommandError { match err {
kind: match err.kind { CatRevError::IoError(err) => CommandError::Abort(Some(
CatRevErrorKind::IoError(err) => CommandErrorKind::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(), utf8_to_local(&format!("abort: {}\n", err)).into(),
)), )),
CatRevErrorKind::InvalidRevision => CommandErrorKind::Abort(Some( CatRevError::InvalidRevision => CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: invalid revision identifier {}\n", "abort: invalid revision identifier {}\n",
rev rev
)) ))
.into(), .into(),
)), )),
CatRevErrorKind::AmbiguousPrefix => CommandErrorKind::Abort(Some( CatRevError::AmbiguousPrefix => CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: ambiguous revision identifier {}\n", "abort: ambiguous revision identifier {}\n",
rev rev
)) ))
.into(), .into(),
)), )),
CatRevErrorKind::UnsuportedRevlogVersion(version) => { CatRevError::UnsuportedRevlogVersion(version) => {
CommandErrorKind::Abort(Some( CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: unsupported revlog version {}\n", "abort: unsupported revlog version {}\n",
version version
)) ))
.into(), .into(),
)) ))
} }
CatRevErrorKind::CorruptedRevlog => CommandErrorKind::Abort(Some( CatRevError::CorruptedRevlog => {
"abort: corrupted revlog\n".into(), CommandError::Abort(Some("abort: corrupted revlog\n".into()))
)), }
CatRevErrorKind::UnknowRevlogDataFormat(format) => { CatRevError::UnknowRevlogDataFormat(format) => {
CommandErrorKind::Abort(Some( CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n", "abort: unknow revlog dataformat {:?}\n",
format format
)) ))
.into(), .into(),
)) ))
} }
},
} }
} }

rust/rhg/src/commands/debugdata.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::CommandError;
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{ use hg::operations::{debug_data, DebugDataError, DebugDataKind};
debug_data, DebugDataError, DebugDataErrorKind, 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> {
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
/// Convert operation errors to command errors /// Convert operation errors to command errors
fn to_command_error(rev: &str, err: DebugDataError) -> CommandError { fn to_command_error(rev: &str, err: DebugDataError) -> CommandError {
match err.kind { match err {
DebugDataErrorKind::IoError(err) => CommandError { DebugDataError::IoError(err) => CommandError::Abort(Some(
kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(), utf8_to_local(&format!("abort: {}\n", err)).into(),
)), )),
}, DebugDataError::InvalidRevision => CommandError::Abort(Some(
DebugDataErrorKind::InvalidRevision => CommandError {
kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: invalid revision identifier{}\n", "abort: invalid revision identifier{}\n",
rev rev
)) ))
.into(), .into(),
)), )),
}, DebugDataError::AmbiguousPrefix => CommandError::Abort(Some(
DebugDataErrorKind::AmbiguousPrefix => CommandError {
kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: ambiguous revision identifier{}\n", "abort: ambiguous revision identifier{}\n",
rev rev
)) ))
.into(), .into(),
)), )),
}, DebugDataError::UnsuportedRevlogVersion(version) => {
DebugDataErrorKind::UnsuportedRevlogVersion(version) => CommandError { CommandError::Abort(Some(
kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: unsupported revlog version {}\n", "abort: unsupported revlog version {}\n",
version version
)) ))
.into(), .into(),
)), ))
}, }
DebugDataErrorKind::CorruptedRevlog => CommandError { DebugDataError::CorruptedRevlog => {
kind: CommandErrorKind::Abort(Some( CommandError::Abort(Some("abort: corrupted revlog\n".into()))
"abort: corrupted revlog\n".into(), }
)), DebugDataError::UnknowRevlogDataFormat(format) => {
}, CommandError::Abort(Some(
DebugDataErrorKind::UnknowRevlogDataFormat(format) => CommandError {
kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n", "abort: unknow revlog dataformat {:?}\n",
format format
)) ))
.into(), .into(),
)), ))
}, }
} }
} }

rust/rhg/src/commands/files.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::CommandError;
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{ use hg::operations::{list_rev_tracked_files, ListRevTrackedFilesError};
list_rev_tracked_files, ListRevTrackedFilesError, use hg::operations::{Dirstate, ListDirstateTrackedFilesError};
ListRevTrackedFilesErrorKind,
};
use hg::operations::{
Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
};
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.
Returns 0 on success. Returns 0 on success.
fn display_files( fn display_files(
&self, &self,
ui: &Ui, ui: &Ui,
repo: &Repo, repo: &Repo,
files: impl IntoIterator<Item = &'a HgPath>, files: impl IntoIterator<Item = &'a HgPath>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let cwd = std::env::current_dir() let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?; .or_else(|e| Err(CommandError::CurrentDirNotFound(e)))?;
let rooted_cwd = cwd let rooted_cwd = cwd
.strip_prefix(repo.working_directory_path()) .strip_prefix(repo.working_directory_path())
.expect("cwd was already checked within the repository"); .expect("cwd was already checked within the repository");
let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd)); let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
for file in files { for file in files {
} else { } else {
let distate = Dirstate::new(&repo).map_err(map_dirstate_error)?; let distate = Dirstate::new(&repo).map_err(map_dirstate_error)?;
let files = distate.tracked_files().map_err(map_dirstate_error)?; let files = distate.tracked_files().map_err(map_dirstate_error)?;
self.display_files(ui, &repo, files) self.display_files(ui, &repo, files)
} }
} }
} }
/// Convert `ListRevTrackedFilesErrorKind` to `CommandError` /// Convert `ListRevTrackedFilesError` to `CommandError`
fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError { fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
CommandError { match err {
kind: match err.kind { ListRevTrackedFilesError::IoError(err) => CommandError::Abort(Some(
ListRevTrackedFilesErrorKind::IoError(err) => {
CommandErrorKind::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(), utf8_to_local(&format!("abort: {}\n", err)).into(),
)) )),
} ListRevTrackedFilesError::InvalidRevision => {
ListRevTrackedFilesErrorKind::InvalidRevision => { CommandError::Abort(Some(
CommandErrorKind::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: invalid revision identifier {}\n", "abort: invalid revision identifier {}\n",
rev rev
)) ))
.into(), .into(),
)) ))
} }
ListRevTrackedFilesErrorKind::AmbiguousPrefix => { ListRevTrackedFilesError::AmbiguousPrefix => {
CommandErrorKind::Abort(Some( CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: ambiguous revision identifier {}\n", "abort: ambiguous revision identifier {}\n",
rev rev
)) ))
.into(), .into(),
)) ))
} }
ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) => { ListRevTrackedFilesError::UnsuportedRevlogVersion(version) => {
CommandErrorKind::Abort(Some( CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: unsupported revlog version {}\n", "abort: unsupported revlog version {}\n",
version version
)) ))
.into(), .into(),
)) ))
} }
ListRevTrackedFilesErrorKind::CorruptedRevlog => { ListRevTrackedFilesError::CorruptedRevlog => {
CommandErrorKind::Abort(Some( CommandError::Abort(Some("abort: corrupted revlog\n".into()))
"abort: corrupted revlog\n".into(),
))
} }
ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) => { ListRevTrackedFilesError::UnknowRevlogDataFormat(format) => {
CommandErrorKind::Abort(Some( CommandError::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n", "abort: unknow revlog dataformat {:?}\n",
format format
)) ))
.into(), .into(),
)) ))
} }
},
} }
} }
/// Convert `ListDirstateTrackedFilesError` to `CommandError` /// Convert `ListDirstateTrackedFilesError` to `CommandError`
fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError { fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
CommandError { match err {
kind: match err.kind { ListDirstateTrackedFilesError::IoError(err) => CommandError::Abort(
ListDirstateTrackedFilesErrorKind::IoError(err) => { Some(utf8_to_local(&format!("abort: {}\n", err)).into()),
CommandErrorKind::Abort(Some( ),
utf8_to_local(&format!("abort: {}\n", err)).into(), ListDirstateTrackedFilesError::ParseError(_) => {
)) CommandError::Abort(Some(
}
ListDirstateTrackedFilesErrorKind::ParseError(_) => {
CommandErrorKind::Abort(Some(
// TODO find a better error message // TODO find a better error message
b"abort: parse error\n".to_vec(), b"abort: parse error\n".to_vec(),
)) ))
} }
},
} }
} }

rust/rhg/src/error.rs

use crate::exitcode; use crate::exitcode;
use crate::ui::UiError; use crate::ui::UiError;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::operations::{FindRootError, FindRootErrorKind}; use hg::operations::FindRootError;
use hg::requirements::RequirementsError; use hg::requirements::RequirementsError;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
use std::convert::From; use std::convert::From;
use std::path::PathBuf; use std::path::PathBuf;
/// The kind of command error /// The kind of command error
#[derive(Debug)] #[derive(Debug)]
pub enum CommandErrorKind { pub enum CommandError {
/// The root of the repository cannot be found /// The root of the repository cannot be found
RootNotFound(PathBuf), RootNotFound(PathBuf),
/// The current directory cannot be found /// The current directory cannot be found
CurrentDirNotFound(std::io::Error), CurrentDirNotFound(std::io::Error),
/// `.hg/requires` /// `.hg/requires`
RequirementsError(RequirementsError), RequirementsError(RequirementsError),
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError, StdoutError,
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError, StderrError,
/// The command aborted /// The command aborted
Abort(Option<Vec<u8>>), Abort(Option<Vec<u8>>),
/// A mercurial capability as not been implemented. /// A mercurial capability as not been implemented.
Unimplemented, Unimplemented,
} }
impl CommandErrorKind { impl CommandError {
pub fn get_exit_code(&self) -> exitcode::ExitCode { pub fn get_exit_code(&self) -> exitcode::ExitCode {
match self { match self {
CommandErrorKind::RootNotFound(_) => exitcode::ABORT, CommandError::RootNotFound(_) => exitcode::ABORT,
CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT, CommandError::CurrentDirNotFound(_) => exitcode::ABORT,
CommandErrorKind::RequirementsError( CommandError::RequirementsError(
RequirementsError::Unsupported { .. }, RequirementsError::Unsupported { .. },
) => exitcode::UNIMPLEMENTED_COMMAND, ) => exitcode::UNIMPLEMENTED_COMMAND,
CommandErrorKind::RequirementsError(_) => exitcode::ABORT, CommandError::RequirementsError(_) => exitcode::ABORT,
CommandErrorKind::StdoutError => exitcode::ABORT, CommandError::StdoutError => exitcode::ABORT,
CommandErrorKind::StderrError => exitcode::ABORT, CommandError::StderrError => exitcode::ABORT,
CommandErrorKind::Abort(_) => exitcode::ABORT, CommandError::Abort(_) => exitcode::ABORT,
CommandErrorKind::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND, CommandError::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND,
} }
} }
/// Return the message corresponding to the error kind if any /// Return the message corresponding to the error if any
pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> { pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
match self { match self {
CommandErrorKind::RootNotFound(path) => { CommandError::RootNotFound(path) => {
let bytes = get_bytes_from_path(path); let bytes = get_bytes_from_path(path);
Some(format_bytes!( Some(format_bytes!(
b"abort: no repository found in '{}' (.hg not found)!\n", b"abort: no repository found in '{}' (.hg not found)!\n",
bytes.as_slice() bytes.as_slice()
)) ))
} }
CommandErrorKind::CurrentDirNotFound(e) => Some(format_bytes!( CommandError::CurrentDirNotFound(e) => Some(format_bytes!(
b"abort: error getting current working directory: {}\n", b"abort: error getting current working directory: {}\n",
e.to_string().as_bytes(), e.to_string().as_bytes(),
)), )),
CommandErrorKind::RequirementsError( CommandError::RequirementsError(RequirementsError::Corrupted) => {
RequirementsError::Corrupted, Some(
) => Some(
"abort: .hg/requires is corrupted\n".as_bytes().to_owned(), "abort: .hg/requires is corrupted\n".as_bytes().to_owned(),
), )
CommandErrorKind::Abort(message) => message.to_owned(),
_ => None,
}
} }
CommandError::Abort(message) => message.to_owned(),
_ => None,
} }
/// The error type for the Command trait
#[derive(Debug)]
pub struct CommandError {
pub kind: CommandErrorKind,
} }
impl CommandError {
/// Exist the process with the corresponding exit code. /// Exist the process with the corresponding exit code.
pub fn exit(&self) { pub fn exit(&self) {
std::process::exit(self.kind.get_exit_code()) std::process::exit(self.get_exit_code())
}
/// Return the message corresponding to the command error if any
pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
self.kind.get_error_message_bytes()
}
}
impl From<CommandErrorKind> for CommandError {
fn from(kind: CommandErrorKind) -> Self {
CommandError { kind }
} }
} }
impl From<UiError> for CommandError { impl From<UiError> for CommandError {
fn from(error: UiError) -> Self { fn from(error: UiError) -> Self {
CommandError { match error {
kind: match error { UiError::StdoutError(_) => CommandError::StdoutError,
UiError::StdoutError(_) => CommandErrorKind::StdoutError, UiError::StderrError(_) => CommandError::StderrError,
UiError::StderrError(_) => CommandErrorKind::StderrError,
},
} }
} }
} }
impl From<FindRootError> for CommandError { impl From<FindRootError> for CommandError {
fn from(err: FindRootError) -> Self { fn from(err: FindRootError) -> Self {
match err.kind { match err {
FindRootErrorKind::RootNotFound(path) => CommandError { FindRootError::RootNotFound(path) => {
kind: CommandErrorKind::RootNotFound(path), CommandError::RootNotFound(path)
}, }
FindRootErrorKind::GetCurrentDirError(e) => CommandError { FindRootError::GetCurrentDirError(e) => {
kind: CommandErrorKind::CurrentDirNotFound(e), CommandError::CurrentDirNotFound(e)
}, }
} }
} }
} }
impl From<RequirementsError> for CommandError { impl From<RequirementsError> for CommandError {
fn from(err: RequirementsError) -> Self { fn from(err: RequirementsError) -> Self {
CommandError { CommandError::RequirementsError(err)
kind: CommandErrorKind::RequirementsError(err),
}
} }
} }