This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9877

rust: remove three enums that were identical to `RevlogError`
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGb274aa2f20fd: rust: remove three enums that were identical to `RevlogError`

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, 8:00 AM
SimonSapin added a commit: rHGb274aa2f20fd: rust: remove three enums that were identical to `RevlogError`.Feb 1 2021, 12:37 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGb274aa2f20fd: rust: remove three enums that were identical to `RevlogError` (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25274

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

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use std::convert::From;
use std::path::PathBuf; use std::path::PathBuf;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::Manifest; use crate::revlog::manifest::Manifest;
use crate::revlog::path_encode::path_encode; use crate::revlog::path_encode::path_encode;
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'];
/// Error type for `cat`
#[derive(Debug)]
pub enum CatRevError {
/// Error when reading a `revlog` file.
IoError(std::io::Error),
/// The revision has not been found.
InvalidRevision,
/// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix,
/// A `revlog` file is corrupted.
CorruptedRevlog,
/// The `revlog` format version is not supported.
UnsuportedRevlogVersion(u16),
/// The `revlog` data format is not supported.
UnknowRevlogDataFormat(u8),
}
impl From<RevlogError> for CatRevError {
fn from(err: RevlogError) -> Self {
match err {
RevlogError::IoError(err) => CatRevError::IoError(err),
RevlogError::UnsuportedVersion(version) => {
CatRevError::UnsuportedRevlogVersion(version)
}
RevlogError::InvalidRevision => CatRevError::InvalidRevision,
RevlogError::AmbiguousPrefix => CatRevError::AmbiguousPrefix,
RevlogError::Corrupted => CatRevError::CorruptedRevlog,
RevlogError::UnknowDataFormat(format) => {
CatRevError::UnknowRevlogDataFormat(format)
}
}
}
}
/// 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>, RevlogError> {
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(|_| CatRevError::CorruptedRevlog)?; .map_err(|_| RevlogError::Corrupted)?;
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(|_| CatRevError::CorruptedRevlog)?; .map_err(|_| RevlogError::Corrupted)?;
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,
} }
/// Error type for `debug_data`
#[derive(Debug, derive_more::From)]
pub enum DebugDataError {
/// Error when reading a `revlog` file.
#[from]
IoError(std::io::Error),
/// The revision has not been found.
InvalidRevision,
/// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix,
/// A `revlog` file is corrupted.
CorruptedRevlog,
/// The `revlog` format version is not supported.
UnsuportedRevlogVersion(u16),
/// The `revlog` data format is not supported.
UnknowRevlogDataFormat(u8),
}
impl From<RevlogError> for DebugDataError {
fn from(err: RevlogError) -> Self {
match err {
RevlogError::IoError(err) => DebugDataError::IoError(err),
RevlogError::UnsuportedVersion(version) => {
DebugDataError::UnsuportedRevlogVersion(version)
}
RevlogError::InvalidRevision => DebugDataError::InvalidRevision,
RevlogError::AmbiguousPrefix => DebugDataError::AmbiguousPrefix,
RevlogError::Corrupted => DebugDataError::CorruptedRevlog,
RevlogError::UnknowDataFormat(format) => {
DebugDataError::UnknowRevlogDataFormat(format)
}
}
}
}
/// 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,
) -> Result<Vec<u8>, DebugDataError> { ) -> Result<Vec<u8>, RevlogError> {
let index_file = match kind { let index_file = match kind {
DebugDataKind::Changelog => "00changelog.i", DebugDataKind::Changelog => "00changelog.i",
DebugDataKind::Manifest => "00manifest.i", DebugDataKind::Manifest => "00manifest.i",
}; };
let revlog = Revlog::open(repo, index_file, None)?; let revlog = Revlog::open(repo, index_file, None)?;
let rev = let rev =
crate::revset::resolve_rev_number_or_hex_prefix(revset, &revlog)?; crate::revset::resolve_rev_number_or_hex_prefix(revset, &revlog)?;
let data = revlog.get_rev_data(rev)?; let data = revlog.get_rev_data(rev)?;
Ok(data) Ok(data)
} }

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

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate::parsers::parse_dirstate; use crate::dirstate::parsers::parse_dirstate;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
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;
/// Error type for `Dirstate` methods /// Error type for `Dirstate` methods
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum ListDirstateTrackedFilesError { 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),
_ => Some(path), _ => Some(path),
}) })
.collect(); .collect();
files.par_sort_unstable(); files.par_sort_unstable();
Ok(files) Ok(files)
} }
} }
/// Error type `list_rev_tracked_files`
#[derive(Debug)]
pub enum ListRevTrackedFilesError {
/// Error when reading a `revlog` file.
IoError(std::io::Error),
/// The revision has not been found.
InvalidRevision,
/// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix,
/// A `revlog` file is corrupted.
CorruptedRevlog,
/// The `revlog` format version is not supported.
UnsuportedRevlogVersion(u16),
/// The `revlog` data format is not supported.
UnknowRevlogDataFormat(u8),
}
impl From<RevlogError> for ListRevTrackedFilesError {
fn from(err: RevlogError) -> Self {
match err {
RevlogError::IoError(err) => {
ListRevTrackedFilesError::IoError(err)
}
RevlogError::UnsuportedVersion(version) => {
ListRevTrackedFilesError::UnsuportedRevlogVersion(version)
}
RevlogError::InvalidRevision => {
ListRevTrackedFilesError::InvalidRevision
}
RevlogError::AmbiguousPrefix => {
ListRevTrackedFilesError::AmbiguousPrefix
}
RevlogError::Corrupted => {
ListRevTrackedFilesError::CorruptedRevlog
}
RevlogError::UnknowDataFormat(format) => {
ListRevTrackedFilesError::UnknowRevlogDataFormat(format)
}
}
}
}
/// 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, RevlogError> {
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(ListRevTrackedFilesError::CorruptedRevlog))?; .map_err(|_| RevlogError::Corrupted)?;
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}; pub use cat::cat;
pub use debugdata::{debug_data, DebugDataError, DebugDataKind}; pub use debugdata::{debug_data, DebugDataKind};
pub use find_root::{find_root, find_root_from_path, FindRootError}; pub use find_root::{find_root, find_root_from_path, FindRootError};
pub use list_tracked_files::{ pub use list_tracked_files::{list_rev_tracked_files, FilesForRev};
list_rev_tracked_files, FilesForRev, ListRevTrackedFilesError,
};
pub use list_tracked_files::{Dirstate, ListDirstateTrackedFilesError}; pub use list_tracked_files::{Dirstate, ListDirstateTrackedFilesError};

rust/rhg/src/error.rs

use crate::exitcode; use crate::exitcode;
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::UiError; use crate::ui::UiError;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::operations::{ use hg::operations::{FindRootError, ListDirstateTrackedFilesError};
CatRevError, DebugDataError, FindRootError, ListDirstateTrackedFilesError,
ListRevTrackedFilesError,
};
use hg::requirements::RequirementsError; use hg::requirements::RequirementsError;
use hg::revlog::revlog::RevlogError;
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_more::From)] #[derive(Debug, derive_more::From)]
pub enum CommandError { pub enum CommandError {
/// The root of the repository cannot be found /// The root of the repository cannot be found
} }
FindRootError::GetCurrentDirError(e) => { FindRootError::GetCurrentDirError(e) => {
CommandError::CurrentDirNotFound(e) CommandError::CurrentDirNotFound(e)
} }
} }
} }
} }
impl From<(DebugDataError, &str)> for CommandError { impl From<(RevlogError, &str)> for CommandError {
fn from((err, rev): (DebugDataError, &str)) -> CommandError { fn from((err, rev): (RevlogError, &str)) -> CommandError {
match err { match err {
DebugDataError::IoError(err) => CommandError::Abort(Some( RevlogError::IoError(err) => CommandError::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(), utf8_to_local(&format!("abort: {}\n", err)).into(),
)), )),
DebugDataError::InvalidRevision => CommandError::Abort(Some( RevlogError::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(),
)), )),
DebugDataError::AmbiguousPrefix => CommandError::Abort(Some( RevlogError::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(),
)), )),
DebugDataError::UnsuportedRevlogVersion(version) => { RevlogError::UnsuportedVersion(version) => {
CommandError::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(),
)) ))
} }
DebugDataError::CorruptedRevlog => { RevlogError::Corrupted => {
CommandError::Abort(Some("abort: corrupted revlog\n".into())) CommandError::Abort(Some("abort: corrupted revlog\n".into()))
} }
DebugDataError::UnknowRevlogDataFormat(format) => { RevlogError::UnknowDataFormat(format) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
format
))
.into(),
))
}
}
}
}
impl From<(ListRevTrackedFilesError, &str)> for CommandError {
fn from((err, rev): (ListRevTrackedFilesError, &str)) -> CommandError {
match err {
ListRevTrackedFilesError::IoError(err) => CommandError::Abort(
Some(utf8_to_local(&format!("abort: {}\n", err)).into()),
),
ListRevTrackedFilesError::InvalidRevision => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: invalid revision identifier {}\n",
rev
))
.into(),
))
}
ListRevTrackedFilesError::AmbiguousPrefix => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: ambiguous revision identifier {}\n",
rev
))
.into(),
))
}
ListRevTrackedFilesError::UnsuportedRevlogVersion(version) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unsupported revlog version {}\n",
version
))
.into(),
))
}
ListRevTrackedFilesError::CorruptedRevlog => {
CommandError::Abort(Some("abort: corrupted revlog\n".into()))
}
ListRevTrackedFilesError::UnknowRevlogDataFormat(format) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
format
))
.into(),
))
}
}
}
}
impl From<(CatRevError, &str)> for CommandError {
fn from((err, rev): (CatRevError, &str)) -> CommandError {
match err {
CatRevError::IoError(err) => CommandError::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(),
)),
CatRevError::InvalidRevision => CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: invalid revision identifier {}\n",
rev
))
.into(),
)),
CatRevError::AmbiguousPrefix => CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: ambiguous revision identifier {}\n",
rev
))
.into(),
)),
CatRevError::UnsuportedRevlogVersion(version) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unsupported revlog version {}\n",
version
))
.into(),
))
}
CatRevError::CorruptedRevlog => {
CommandError::Abort(Some("abort: corrupted revlog\n".into()))
}
CatRevError::UnknowRevlogDataFormat(format) => {
CommandError::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(),
)) ))
} }