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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 25318

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