This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9876

rhg: replace `map_*_error` functions with `From` impls
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG252d1bdba33d: rhg: replace `map_*_error` functions with `From` impls

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, 8:00 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/rhg/src/error.rs
137

If it's possible to also fix the typo here, that'd be great.

186

and here...

231

... and here!

SimonSapin added a comment.Jan 29 2021, 12:31 PM

Unknow -> unknown? The variant names also have this typo, but they and the messages are gone in D9897 anyway.

SimonSapin added a commit: rHG252d1bdba33d: rhg: replace `map_*_error` functions with `From` impls.Feb 1 2021, 12:36 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG252d1bdba33d: rhg: replace `map_*_error` functions with `From` impls (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25430

rust/rhg/src/commands/cat.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{cat, CatRevError}; use hg::operations::cat;
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
"; ";
.or(Err(CommandError::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(CommandError::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| (e, rev))?;
.map_err(|e| map_rev_error(rev, e))?;
self.display(ui, &data) self.display(ui, &data)
} }
None => Err(CommandError::Unimplemented.into()), None => Err(CommandError::Unimplemented.into()),
} }
} }
} }
/// Convert `CatRevError` to `CommandError`
fn map_rev_error(rev: &str, err: CatRevError) -> 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(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
format
))
.into(),
))
}
}
}

rust/rhg/src/commands/debugdata.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{debug_data, DebugDataError, DebugDataKind}; use hg::operations::{debug_data, 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> {
rev: &'a str, rev: &'a str,
kind: DebugDataKind, kind: DebugDataKind,
} }
impl<'a> DebugDataCommand<'a> { impl<'a> DebugDataCommand<'a> {
pub fn new(rev: &'a str, kind: DebugDataKind) -> Self { pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
DebugDataCommand { rev, kind } DebugDataCommand { rev, kind }
} }
} }
impl<'a> Command for DebugDataCommand<'a> { impl<'a> Command for DebugDataCommand<'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()?;
let data = debug_data(&repo, self.rev, self.kind) let data = debug_data(&repo, self.rev, self.kind)
.map_err(|e| to_command_error(self.rev, e))?; .map_err(|e| (e, self.rev))?;
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
stdout.write_all(&data)?; stdout.write_all(&data)?;
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
/// Convert operation errors to command errors
fn to_command_error(rev: &str, err: DebugDataError) -> CommandError {
match err {
DebugDataError::IoError(err) => CommandError::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(),
)),
DebugDataError::InvalidRevision => CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: invalid revision identifier{}\n",
rev
))
.into(),
)),
DebugDataError::AmbiguousPrefix => CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: ambiguous revision identifier{}\n",
rev
))
.into(),
)),
DebugDataError::UnsuportedRevlogVersion(version) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unsupported revlog version {}\n",
version
))
.into(),
))
}
DebugDataError::CorruptedRevlog => {
CommandError::Abort(Some("abort: corrupted revlog\n".into()))
}
DebugDataError::UnknowRevlogDataFormat(format) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
format
))
.into(),
))
}
}
}

rust/rhg/src/commands/files.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{list_rev_tracked_files, ListRevTrackedFilesError}; use hg::operations::list_rev_tracked_files;
use hg::operations::{Dirstate, ListDirstateTrackedFilesError}; use hg::operations::Dirstate;
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.
} }
} }
impl<'a> Command for FilesCommand<'a> { impl<'a> Command for FilesCommand<'a> {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let repo = Repo::find()?; let repo = Repo::find()?;
repo.check_requirements()?; repo.check_requirements()?;
if let Some(rev) = self.rev { if let Some(rev) = self.rev {
let files = list_rev_tracked_files(&repo, rev) let files =
.map_err(|e| map_rev_error(rev, e))?; list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?;
self.display_files(ui, &repo, files.iter()) self.display_files(ui, &repo, files.iter())
} else { } else {
let distate = Dirstate::new(&repo).map_err(map_dirstate_error)?; let distate = Dirstate::new(&repo)?;
let files = distate.tracked_files().map_err(map_dirstate_error)?; let files = distate.tracked_files()?;
self.display_files(ui, &repo, files) self.display_files(ui, &repo, files)
} }
} }
} }
/// Convert `ListRevTrackedFilesError` to `CommandError`
fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> 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(),
))
}
}
}
/// Convert `ListDirstateTrackedFilesError` to `CommandError`
fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
match err {
ListDirstateTrackedFilesError::IoError(err) => CommandError::Abort(
Some(utf8_to_local(&format!("abort: {}\n", err)).into()),
),
ListDirstateTrackedFilesError::ParseError(_) => {
CommandError::Abort(Some(
// TODO find a better error message
b"abort: parse error\n".to_vec(),
))
}
}
}

rust/rhg/src/error.rs

use crate::exitcode; use crate::exitcode;
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::FindRootError; use hg::operations::{
CatRevError, DebugDataError, FindRootError, ListDirstateTrackedFilesError,
ListRevTrackedFilesError,
};
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_more::From)] #[derive(Debug, derive_more::From)]
pub enum CommandError { pub enum CommandError {
CommandError::RootNotFound(path) CommandError::RootNotFound(path)
} }
FindRootError::GetCurrentDirError(e) => { FindRootError::GetCurrentDirError(e) => {
CommandError::CurrentDirNotFound(e) CommandError::CurrentDirNotFound(e)
} }
} }
} }
} }
impl From<(DebugDataError, &str)> for CommandError {
fn from((err, rev): (DebugDataError, &str)) -> CommandError {
match err {
DebugDataError::IoError(err) => CommandError::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(),
)),
DebugDataError::InvalidRevision => CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: invalid revision identifier{}\n",
rev
))
.into(),
)),
DebugDataError::AmbiguousPrefix => CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: ambiguous revision identifier{}\n",
rev
))
.into(),
)),
DebugDataError::UnsuportedRevlogVersion(version) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unsupported revlog version {}\n",
version
))
.into(),
))
}
DebugDataError::CorruptedRevlog => {
CommandError::Abort(Some("abort: corrupted revlog\n".into()))
}
DebugDataError::UnknowRevlogDataFormat(format) => {
CommandError::Abort(Some(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
AlphareUnsubmitted
Not Done

If it's possible to also fix the typo here, that'd be great.

Alphare: If it's possible to also fix the typo here, that'd be great.
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",
AlphareUnsubmitted
Not Done

and here...

Alphare: and here...
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(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
AlphareUnsubmitted
Not Done

... and here!

Alphare: ... and here!
format
))
.into(),
))
}
}
}
}
impl From<ListDirstateTrackedFilesError> for CommandError {
fn from(err: ListDirstateTrackedFilesError) -> Self {
match err {
ListDirstateTrackedFilesError::IoError(err) => {
CommandError::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(),
))
}
ListDirstateTrackedFilesError::ParseError(_) => {
CommandError::Abort(Some(
// TODO find a better error message
b"abort: parse error\n".to_vec(),
))
}
}
}
}