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
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 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 25428

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),
}
} }
} }