This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9894

rust: Remove DirstateParseError and ListDirstateTrackedFilesError
ClosedPublic

Authored by SimonSapin on Jan 27 2021, 4:12 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG776b97179c06: rust: Remove DirstateParseError and ListDirstateTrackedFilesError
Summary

Use HgError 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 27 2021, 4:12 PM
Alphare accepted this revision.Jan 29 2021, 8:16 AM
SimonSapin added a commit: rHG776b97179c06: rust: Remove DirstateParseError and ListDirstateTrackedFilesError.Feb 1 2021, 12:37 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG776b97179c06: rust: Remove DirstateParseError and ListDirstateTrackedFilesError (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25434

rust/hg-core/src/dirstate.rs

// dirstate module // dirstate module
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@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::{utils::hg_path::HgPathBuf, DirstateParseError, FastHashMap}; use crate::errors::HgError;
use crate::{utils::hg_path::HgPathBuf, FastHashMap};
use std::collections::hash_map; use std::collections::hash_map;
use std::convert::TryFrom; use std::convert::TryFrom;
pub mod dirs_multiset; pub mod dirs_multiset;
pub mod dirstate_map; pub mod dirstate_map;
#[cfg(feature = "dirstate-tree")] #[cfg(feature = "dirstate-tree")]
pub mod dirstate_tree; pub mod dirstate_tree;
pub mod parsers; pub mod parsers;
Normal, Normal,
Added, Added,
Removed, Removed,
Merged, Merged,
Unknown, Unknown,
} }
impl TryFrom<u8> for EntryState { impl TryFrom<u8> for EntryState {
type Error = DirstateParseError; type Error = HgError;
fn try_from(value: u8) -> Result<Self, Self::Error> { fn try_from(value: u8) -> Result<Self, Self::Error> {
match value { match value {
b'n' => Ok(EntryState::Normal), b'n' => Ok(EntryState::Normal),
b'a' => Ok(EntryState::Added), b'a' => Ok(EntryState::Added),
b'r' => Ok(EntryState::Removed), b'r' => Ok(EntryState::Removed),
b'm' => Ok(EntryState::Merged), b'm' => Ok(EntryState::Merged),
b'?' => Ok(EntryState::Unknown), b'?' => Ok(EntryState::Unknown),
_ => Err(DirstateParseError::CorruptedEntry(format!( _ => Err(HgError::CorruptedRepository(format!(
"Incorrect entry state {}", "Incorrect dirstate entry state {}",
value value
))), ))),
} }
} }
} }
impl Into<u8> for EntryState { impl Into<u8> for EntryState {
fn into(self) -> u8 { fn into(self) -> u8 {

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@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::errors::HgError;
use crate::revlog::node::NULL_NODE_ID; use crate::revlog::node::NULL_NODE_ID;
use crate::{ use crate::{
dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT}, dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT},
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::{ utils::{
files::normalize_case, files::normalize_case,
hg_path::{HgPath, HgPathBuf}, hg_path::{HgPath, HgPathBuf},
}, },
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError,
DirstateParents, DirstateParseError, FastHashMap, StateMap, DirstateParents, FastHashMap, StateMap,
}; };
use micro_timer::timed; use micro_timer::timed;
use std::collections::HashSet; use std::collections::HashSet;
use std::convert::TryInto; use std::convert::TryInto;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
use std::time::Duration; use std::time::Duration;
.unwrap(), .unwrap(),
}; };
} else if file_contents.is_empty() { } else if file_contents.is_empty() {
parents = DirstateParents { parents = DirstateParents {
p1: NULL_NODE_ID, p1: NULL_NODE_ID,
p2: NULL_NODE_ID, p2: NULL_NODE_ID,
}; };
} else { } else {
return Err(DirstateError::Parse(DirstateParseError::Damaged)); return Err(
HgError::corrupted("Dirstate appears to be damaged").into()
);
} }
self.parents = Some(parents); self.parents = Some(parents);
Ok(self.parents.as_ref().unwrap()) Ok(self.parents.as_ref().unwrap())
} }
pub fn set_parents(&mut self, parents: &DirstateParents) { pub fn set_parents(&mut self, parents: &DirstateParents) {
self.parents = Some(parents.clone()); self.parents = Some(parents.clone());

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

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@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::errors::HgError; use crate::errors::HgError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{ use crate::{
dirstate::{CopyMap, EntryState, StateMap}, dirstate::{CopyMap, EntryState, StateMap},
DirstateEntry, DirstateParents, DirstateParseError, DirstateEntry, DirstateParents,
}; };
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use micro_timer::timed; use micro_timer::timed;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::io::Cursor; use std::io::Cursor;
use std::time::Duration; use std::time::Duration;
/// Parents are stored in the dirstate as byte hashes. /// Parents are stored in the dirstate as byte hashes.
pub const PARENT_SIZE: usize = 20; pub const PARENT_SIZE: usize = 20;
/// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits. /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits.
const MIN_ENTRY_SIZE: usize = 17; const MIN_ENTRY_SIZE: usize = 17;
type ParseResult<'a> = ( type ParseResult<'a> = (
DirstateParents, DirstateParents,
Vec<(&'a HgPath, DirstateEntry)>, Vec<(&'a HgPath, DirstateEntry)>,
Vec<(&'a HgPath, &'a HgPath)>, Vec<(&'a HgPath, &'a HgPath)>,
); );
#[timed] #[timed]
pub fn parse_dirstate( pub fn parse_dirstate(contents: &[u8]) -> Result<ParseResult, HgError> {
contents: &[u8],
) -> Result<ParseResult, DirstateParseError> {
if contents.len() < PARENT_SIZE * 2 { if contents.len() < PARENT_SIZE * 2 {
return Err(DirstateParseError::TooLittleData); return Err(HgError::corrupted("Too little data for dirstate."));
} }
let mut copies = vec![]; let mut copies = vec![];
let mut entries = vec![]; let mut entries = vec![];
let mut curr_pos = PARENT_SIZE * 2; let mut curr_pos = PARENT_SIZE * 2;
let parents = DirstateParents { let parents = DirstateParents {
p1: contents[..PARENT_SIZE].try_into().unwrap(), p1: contents[..PARENT_SIZE].try_into().unwrap(),
p2: contents[PARENT_SIZE..curr_pos].try_into().unwrap(), p2: contents[PARENT_SIZE..curr_pos].try_into().unwrap(),
}; };
while curr_pos < contents.len() { while curr_pos < contents.len() {
if curr_pos + MIN_ENTRY_SIZE > contents.len() { if curr_pos + MIN_ENTRY_SIZE > contents.len() {
return Err(DirstateParseError::Overflow); return Err(HgError::corrupted("Overflow in dirstate."));
} }
let entry_bytes = &contents[curr_pos..]; let entry_bytes = &contents[curr_pos..];
let mut cursor = Cursor::new(entry_bytes); let mut cursor = Cursor::new(entry_bytes);
let state = EntryState::try_from(cursor.read_u8()?)?; // Unwraping errors from `byteorder` as we’ve already checked
let mode = cursor.read_i32::<BigEndian>()?; // `MIN_ENTRY_SIZE` so the input should never be too short.
let size = cursor.read_i32::<BigEndian>()?; let state = EntryState::try_from(cursor.read_u8().unwrap())?;
let mtime = cursor.read_i32::<BigEndian>()?; let mode = cursor.read_i32::<BigEndian>().unwrap();
let path_len = cursor.read_i32::<BigEndian>()? as usize; let size = cursor.read_i32::<BigEndian>().unwrap();
let mtime = cursor.read_i32::<BigEndian>().unwrap();
let path_len = cursor.read_i32::<BigEndian>().unwrap() as usize;
if path_len > contents.len() - curr_pos { if path_len > contents.len() - curr_pos {
return Err(DirstateParseError::Overflow); return Err(HgError::corrupted("Overflow in dirstate."));
} }
// Slice instead of allocating a Vec needed for `read_exact` // Slice instead of allocating a Vec needed for `read_exact`
let path = &entry_bytes[MIN_ENTRY_SIZE..MIN_ENTRY_SIZE + (path_len)]; let path = &entry_bytes[MIN_ENTRY_SIZE..MIN_ENTRY_SIZE + (path_len)];
let (path, copy) = match memchr::memchr(0, path) { let (path, copy) = match memchr::memchr(0, path) {
None => (path, None), None => (path, None),
Some(i) => (&path[..i], Some(&path[(i + 1)..])), Some(i) => (&path[..i], Some(&path[(i + 1)..])),

rust/hg-core/src/lib.rs

pub type LineNumber = usize; pub type LineNumber = usize;
/// Rust's default hasher is too slow because it tries to prevent collision /// Rust's default hasher is too slow because it tries to prevent collision
/// attacks. We are not concerned about those: if an ill-minded person has /// attacks. We are not concerned about those: if an ill-minded person has
/// write access to your repository, you have other issues. /// write access to your repository, you have other issues.
pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>; pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;
#[derive(Clone, Debug, PartialEq)]
pub enum DirstateParseError {
TooLittleData,
Overflow,
// TODO refactor to use bytes instead of String
CorruptedEntry(String),
Damaged,
}
impl From<std::io::Error> for DirstateParseError {
fn from(e: std::io::Error) -> Self {
DirstateParseError::CorruptedEntry(e.to_string())
}
}
impl ToString for DirstateParseError {
fn to_string(&self) -> String {
use crate::DirstateParseError::*;
match self {
TooLittleData => "Too little data for dirstate.".to_string(),
Overflow => "Overflow in dirstate.".to_string(),
CorruptedEntry(e) => format!("Corrupted entry: {:?}.", e),
Damaged => "Dirstate appears to be damaged.".to_string(),
}
}
}
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum DirstateMapError { pub enum DirstateMapError {
PathNotFound(HgPathBuf), PathNotFound(HgPathBuf),
EmptyPath, EmptyPath,
InvalidPath(HgPathError), InvalidPath(HgPathError),
} }
impl ToString for DirstateMapError { impl ToString for DirstateMapError {
fn to_string(&self) -> String { fn to_string(&self) -> String {
match self { match self {
DirstateMapError::PathNotFound(_) => { DirstateMapError::PathNotFound(_) => {
"expected a value, found none".to_string() "expected a value, found none".to_string()
} }
DirstateMapError::EmptyPath => "Overflow in dirstate.".to_string(), DirstateMapError::EmptyPath => "Overflow in dirstate.".to_string(),
DirstateMapError::InvalidPath(e) => e.to_string(), DirstateMapError::InvalidPath(e) => e.to_string(),
} }
} }
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum DirstateError { pub enum DirstateError {
Parse(DirstateParseError),
Map(DirstateMapError), Map(DirstateMapError),
IO(std::io::Error),
Common(errors::HgError), Common(errors::HgError),
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum PatternError { pub enum PatternError {
#[from] #[from]
Path(HgPathError), Path(HgPathError),
UnsupportedSyntax(String), UnsupportedSyntax(String),

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::errors::{HgError, IoResultExt};
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::EntryState;
use rayon::prelude::*; use rayon::prelude::*;
/// Error type for `Dirstate` methods
#[derive(Debug, derive_more::From)]
pub enum ListDirstateTrackedFilesError {
/// Error when reading the `dirstate` file
IoError(std::io::Error),
/// Error when parsing the `dirstate` file
ParseError(DirstateParseError),
}
/// 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, HgError> {
let content = repo.hg_vfs().read("dirstate")?; let content = repo
.hg_vfs()
.read("dirstate")
// TODO: this will be more accurate when we use `HgError` in
// `Vfs::read`.
.for_file("dirstate".as_ref())?;
Ok(Self { content }) Ok(Self { content })
} }
pub fn tracked_files( pub fn tracked_files(&self) -> Result<Vec<&HgPath>, HgError> {
&self, let (_, entries, _) = parse_dirstate(&self.content)?;
) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
let (_, entries, _) = parse_dirstate(&self.content)
.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();

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; pub use cat::cat;
pub use debugdata::{debug_data, 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::Dirstate;
pub use list_tracked_files::{list_rev_tracked_files, FilesForRev}; pub use list_tracked_files::{list_rev_tracked_files, FilesForRev};
pub use list_tracked_files::{Dirstate, ListDirstateTrackedFilesError};

rust/hg-cpython/src/dirstate.rs

dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}, },
exceptions, exceptions,
}; };
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, exc, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult,
PySequence, Python, PySequence, Python,
}; };
use hg::{ use hg::{utils::hg_path::HgPathBuf, DirstateEntry, EntryState, StateMap};
utils::hg_path::HgPathBuf, DirstateEntry, DirstateParseError, EntryState,
StateMap,
};
use libc::{c_char, c_int}; use libc::{c_char, c_int};
use std::convert::TryFrom; use std::convert::TryFrom;
// C code uses a custom `dirstate_tuple` type, checks in multiple instances // C code uses a custom `dirstate_tuple` type, checks in multiple instances
// for this type, and raises a Python `Exception` if the check does not pass. // for this type, and raises a Python `Exception` if the check does not pass.
// Because this type differs only in name from the regular Python tuple, it // Because this type differs only in name from the regular Python tuple, it
// would be a good idea in the near future to remove it entirely to allow // would be a good idea in the near future to remove it entirely to allow
// for a pure Python tuple of the same effective structure to be used, // for a pure Python tuple of the same effective structure to be used,
} }
pub fn extract_dirstate(py: Python, dmap: &PyDict) -> Result<StateMap, PyErr> { pub fn extract_dirstate(py: Python, dmap: &PyDict) -> Result<StateMap, PyErr> {
dmap.items(py) dmap.items(py)
.iter() .iter()
.map(|(filename, stats)| { .map(|(filename, stats)| {
let stats = stats.extract::<PySequence>(py)?; let stats = stats.extract::<PySequence>(py)?;
let state = stats.get_item(py, 0)?.extract::<PyBytes>(py)?; let state = stats.get_item(py, 0)?.extract::<PyBytes>(py)?;
let state = EntryState::try_from(state.data(py)[0]).map_err( let state =
|e: DirstateParseError| { EntryState::try_from(state.data(py)[0]).map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
}, })?;
)?;
let mode = stats.get_item(py, 1)?.extract(py)?; let mode = stats.get_item(py, 1)?.extract(py)?;
let size = stats.get_item(py, 2)?.extract(py)?; let size = stats.get_item(py, 2)?.extract(py)?;
let mtime = stats.get_item(py, 3)?.extract(py)?; let mtime = stats.get_item(py, 3)?.extract(py)?;
let filename = filename.extract::<PyBytes>(py)?; let filename = filename.extract::<PyBytes>(py)?;
let filename = filename.data(py); let filename = filename.data(py);
Ok(( Ok((
HgPathBuf::from(filename.to_owned()), HgPathBuf::from(filename.to_owned()),
DirstateEntry { DirstateEntry {

rust/hg-cpython/src/dirstate/dirs_multiset.rs

use cpython::{ use cpython::{
exc, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyObject, PyResult, exc, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyObject, PyResult,
Python, UnsafePyLeaked, Python, UnsafePyLeaked,
}; };
use crate::dirstate::extract_dirstate; use crate::dirstate::extract_dirstate;
use hg::{ use hg::{
errors::HgError,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirsMultisetIter, DirstateMapError, DirstateParseError, DirsMultiset, DirsMultisetIter, DirstateMapError, EntryState,
EntryState,
}; };
py_class!(pub class Dirs |py| { py_class!(pub class Dirs |py| {
@shared data inner: DirsMultiset; @shared data inner: DirsMultiset;
// `map` is either a `dict` or a flat iterator (usually a `set`, sometimes // `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
// a `list`) // a `list`)
def __new__( def __new__(
_cls, _cls,
map: PyObject, map: PyObject,
skip: Option<PyObject> = None skip: Option<PyObject> = None
) -> PyResult<Self> { ) -> PyResult<Self> {
let mut skip_state: Option<EntryState> = None; let mut skip_state: Option<EntryState> = None;
if let Some(skip) = skip { if let Some(skip) = skip {
skip_state = Some( skip_state = Some(
skip.extract::<PyBytes>(py)?.data(py)[0] skip.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: DirstateParseError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
); );
} }
let inner = if let Ok(map) = map.cast_as::<PyDict>(py) { let inner = if let Ok(map) = map.cast_as::<PyDict>(py) {
let dirstate = extract_dirstate(py, &map)?; let dirstate = extract_dirstate(py, &map)?;
DirsMultiset::from_dirstate(&dirstate, skip_state) DirsMultiset::from_dirstate(&dirstate, skip_state)
.map_err(|e| { .map_err(|e: DirstateMapError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})? })?
} else { } else {
let map: Result<Vec<HgPathBuf>, PyErr> = map let map: Result<Vec<HgPathBuf>, PyErr> = map
.iter(py)? .iter(py)?
.map(|o| { .map(|o| {
Ok(HgPathBuf::from_bytes( Ok(HgPathBuf::from_bytes(
o?.extract::<PyBytes>(py)?.data(py), o?.extract::<PyBytes>(py)?.data(py),

rust/hg-cpython/src/dirstate/dirstate_map.rs

use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::{dirs_multiset::Dirs, make_dirstate_tuple}, dirstate::{dirs_multiset::Dirs, make_dirstate_tuple},
}; };
use hg::{ use hg::{
errors::HgError,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap, DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap,
DirstateMapError, DirstateParents, DirstateParseError, EntryState, DirstateMapError, DirstateParents, EntryState, StateMapIter, PARENT_SIZE,
StateMapIter, PARENT_SIZE,
}; };
// TODO // TODO
// This object needs to share references to multiple members of its Rust // This object needs to share references to multiple members of its Rust
// inner struct, namely `copy_map`, `dirs` and `all_dirs`. // inner struct, namely `copy_map`, `dirs` and `all_dirs`.
// Right now `CopyMap` is done, but it needs to have an explicit reference // Right now `CopyMap` is done, but it needs to have an explicit reference
// to `RustDirstateMap` which itself needs to have an encapsulation for // to `RustDirstateMap` which itself needs to have an encapsulation for
// every method in `CopyMap` (copymapcopy, etc.). // every method in `CopyMap` (copymapcopy, etc.).
mode: PyObject, mode: PyObject,
size: PyObject, size: PyObject,
mtime: PyObject mtime: PyObject
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
self.inner(py).borrow_mut().add_file( self.inner(py).borrow_mut().add_file(
HgPath::new(f.extract::<PyBytes>(py)?.data(py)), HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
oldstate.extract::<PyBytes>(py)?.data(py)[0] oldstate.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: DirstateParseError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
DirstateEntry { DirstateEntry {
state: state.extract::<PyBytes>(py)?.data(py)[0] state: state.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: DirstateParseError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
mode: mode.extract(py)?, mode: mode.extract(py)?,
size: size.extract(py)?, size: size.extract(py)?,
mtime: mtime.extract(py)?, mtime: mtime.extract(py)?,
}, },
).and(Ok(py.None())).or_else(|e: DirstateMapError| { ).and(Ok(py.None())).or_else(|e: DirstateMapError| {
Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())) Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))
}) })
} }
def removefile( def removefile(
&self, &self,
f: PyObject, f: PyObject,
oldstate: PyObject, oldstate: PyObject,
size: PyObject size: PyObject
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
.remove_file( .remove_file(
HgPath::new(f.extract::<PyBytes>(py)?.data(py)), HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
oldstate.extract::<PyBytes>(py)?.data(py)[0] oldstate.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: DirstateParseError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
size.extract(py)?, size.extract(py)?,
) )
.or_else(|_| { .or_else(|_| {
Err(PyErr::new::<exc::OSError, _>( Err(PyErr::new::<exc::OSError, _>(
py, py,
"Dirstate error".to_string(), "Dirstate error".to_string(),
)) ))
})?; })?;
Ok(py.None()) Ok(py.None())
} }
def dropfile( def dropfile(
&self, &self,
f: PyObject, f: PyObject,
oldstate: PyObject oldstate: PyObject
) -> PyResult<PyBool> { ) -> PyResult<PyBool> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
.drop_file( .drop_file(
HgPath::new(f.extract::<PyBytes>(py)?.data(py)), HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
oldstate.extract::<PyBytes>(py)?.data(py)[0] oldstate.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: DirstateParseError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
) )
.and_then(|b| Ok(b.to_py_object(py))) .and_then(|b| Ok(b.to_py_object(py)))
.or_else(|e| { .or_else(|e| {
Err(PyErr::new::<exc::OSError, _>( Err(PyErr::new::<exc::OSError, _>(
py, py,
format!("Dirstate error: {}", e.to_string()), format!("Dirstate error: {}", e.to_string()),

rust/hg-cpython/src/parsers.rs

//! //!
//! From Python, this will be seen as `mercurial.rustext.parsers` //! From Python, this will be seen as `mercurial.rustext.parsers`
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python, exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python,
PythonObject, ToPyObject, PythonObject, ToPyObject,
}; };
use hg::{ use hg::{
pack_dirstate, parse_dirstate, utils::hg_path::HgPathBuf, DirstateEntry, pack_dirstate, parse_dirstate, utils::hg_path::HgPathBuf, DirstateEntry,
DirstateParents, DirstateParseError, FastHashMap, PARENT_SIZE, DirstateParents, FastHashMap, PARENT_SIZE,
}; };
use std::convert::TryInto; use std::convert::TryInto;
use crate::dirstate::{extract_dirstate, make_dirstate_tuple}; use crate::dirstate::{extract_dirstate, make_dirstate_tuple};
use std::time::Duration; use std::time::Duration;
fn parse_dirstate_wrapper( fn parse_dirstate_wrapper(
py: Python, py: Python,
PyBytes::new(py, copy_path.as_bytes()), PyBytes::new(py, copy_path.as_bytes()),
)?; )?;
} }
Ok( Ok(
(PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2)) (PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2))
.to_py_object(py), .to_py_object(py),
) )
} }
Err(e) => Err(PyErr::new::<exc::ValueError, _>( Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())),
py,
match e {
DirstateParseError::TooLittleData => {
"too little data for parents".to_string()
}
DirstateParseError::Overflow => {
"overflow in dirstate".to_string()
}
DirstateParseError::CorruptedEntry(e) => e,
DirstateParseError::Damaged => {
"dirstate appears to be damaged".to_string()
}
},
)),
} }
} }
fn pack_dirstate_wrapper( fn pack_dirstate_wrapper(
py: Python, py: Python,
dmap: PyDict, dmap: PyDict,
copymap: PyDict, copymap: PyDict,
pl: PyTuple, pl: PyTuple,

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::{FindRootError, ListDirstateTrackedFilesError}; use hg::errors::HgError;
use hg::operations::FindRootError;
use hg::requirements::RequirementsError; use hg::requirements::RequirementsError;
use hg::revlog::revlog::RevlogError; 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
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`
#[from] #[from]
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,
/// Common cases
#[from]
Other(HgError),
} }
impl CommandError { impl CommandError {
pub fn get_exit_code(&self) -> exitcode::ExitCode { pub fn get_exit_code(&self) -> exitcode::ExitCode {
match self { match self {
CommandError::RootNotFound(_) => exitcode::ABORT, CommandError::RootNotFound(_) => exitcode::ABORT,
CommandError::CurrentDirNotFound(_) => exitcode::ABORT, CommandError::CurrentDirNotFound(_) => exitcode::ABORT,
CommandError::RequirementsError( CommandError::RequirementsError(
RequirementsError::Unsupported { .. }, RequirementsError::Unsupported { .. },
) => exitcode::UNIMPLEMENTED_COMMAND, ) => exitcode::UNIMPLEMENTED_COMMAND,
CommandError::RequirementsError(_) => exitcode::ABORT, CommandError::RequirementsError(_) => exitcode::ABORT,
CommandError::StdoutError => exitcode::ABORT, CommandError::StdoutError => exitcode::ABORT,
CommandError::StderrError => exitcode::ABORT, CommandError::StderrError => exitcode::ABORT,
CommandError::Abort(_) => exitcode::ABORT, CommandError::Abort(_) => exitcode::ABORT,
CommandError::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND, CommandError::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND,
CommandError::Other(HgError::UnsupportedFeature(_)) => {
exitcode::UNIMPLEMENTED_COMMAND
}
CommandError::Other(_) => exitcode::ABORT,
} }
} }
/// Return the message corresponding to the error 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 {
CommandError::RootNotFound(path) => { CommandError::RootNotFound(path) => {
let bytes = get_bytes_from_path(path); let bytes = get_bytes_from_path(path);
format format
)) ))
.into(), .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(),
))
}
}
}
}