( )⚙ D11947 hg-cpython: use ancestor iterator impls from vcsgraph

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11947

hg-cpython: use ancestor iterator impls from vcsgraph
ClosedPublic

Authored by pacien on Dec 21 2021, 10:06 AM.

Details

Reviewers
SimonSapin
Alphare
Group Reviewers
hg-reviewers
Commits
rHG35ebe6f824be: hg-cpython: use ancestor iterator impls from vcsgraph

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

pacien created this revision.Dec 21 2021, 10:06 AM
SimonSapin accepted this revision.Dec 21 2021, 10:25 AM
Alphare accepted this revision.Dec 21 2021, 12:02 PM
This revision is now accepted and ready to land.Dec 21 2021, 12:02 PM
pacien added a commit: rHG35ebe6f824be: hg-cpython: use ancestor iterator impls from vcsgraph.Dec 21 2021, 12:05 PM
Closed by commit rHG35ebe6f824be: hg-cpython: use ancestor iterator impls from vcsgraph (authored by pacien). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31566

rust/hg-cpython/src/ancestors.rs

use crate::revlog::pyindex_to_graph; use crate::revlog::pyindex_to_graph;
use crate::{ use crate::{
cindex::Index, conversion::rev_pyiter_collect, exceptions::GraphError, cindex::Index, conversion::rev_pyiter_collect, exceptions::GraphError,
}; };
use cpython::{ use cpython::{
ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject, PyResult, ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject, PyResult,
Python, PythonObject, ToPyObject, Python, PythonObject, ToPyObject,
}; };
use hg::MissingAncestors as CoreMissing;
use hg::Revision; use hg::Revision;
use hg::{
AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy,
MissingAncestors as CoreMissing,
};
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::HashSet; use std::collections::HashSet;
use vcsgraph::lazy_ancestors::{
AncestorsIterator as VCGAncestorsIterator,
LazyAncestors as VCGLazyAncestors,
};
py_class!(pub class AncestorsIterator |py| { py_class!(pub class AncestorsIterator |py| {
data inner: RefCell<Box<CoreIterator<Index>>>; data inner: RefCell<Box<VCGAncestorsIterator<Index>>>;
def __next__(&self) -> PyResult<Option<Revision>> { def __next__(&self) -> PyResult<Option<Revision>> {
match self.inner(py).borrow_mut().next() { match self.inner(py).borrow_mut().next() {
Some(Err(e)) => Err(GraphError::pynew(py, e)), Some(Err(e)) => Err(GraphError::pynew_from_vcsgraph(py, e)),
None => Ok(None), None => Ok(None),
Some(Ok(r)) => Ok(Some(r)), Some(Ok(r)) => Ok(Some(r)),
} }
} }
def __contains__(&self, rev: Revision) -> PyResult<bool> { def __contains__(&self, rev: Revision) -> PyResult<bool> {
self.inner(py).borrow_mut().contains(rev) self.inner(py).borrow_mut().contains(rev)
.map_err(|e| GraphError::pynew(py, e)) .map_err(|e| GraphError::pynew_from_vcsgraph(py, e))
} }
def __iter__(&self) -> PyResult<Self> { def __iter__(&self) -> PyResult<Self> {
Ok(self.clone_ref(py)) Ok(self.clone_ref(py))
} }
def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision, def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision,
inclusive: bool) -> PyResult<AncestorsIterator> { inclusive: bool) -> PyResult<AncestorsIterator> {
let initvec: Vec<Revision> = rev_pyiter_collect(py, &initrevs)?; let initvec: Vec<Revision> = rev_pyiter_collect(py, &initrevs)?;
let ait = CoreIterator::new( let ait = VCGAncestorsIterator::new(
pyindex_to_graph(py, index)?, pyindex_to_graph(py, index)?,
initvec, initvec,
stoprev, stoprev,
inclusive, inclusive,
) )
.map_err(|e| GraphError::pynew(py, e))?; .map_err(|e| GraphError::pynew_from_vcsgraph(py, e))?;
AncestorsIterator::from_inner(py, ait) AncestorsIterator::from_inner(py, ait)
} }
}); });
impl AncestorsIterator { impl AncestorsIterator {
pub fn from_inner(py: Python, ait: CoreIterator<Index>) -> PyResult<Self> { pub fn from_inner(
py: Python,
ait: VCGAncestorsIterator<Index>,
) -> PyResult<Self> {
Self::create_instance(py, RefCell::new(Box::new(ait))) Self::create_instance(py, RefCell::new(Box::new(ait)))
} }
} }
py_class!(pub class LazyAncestors |py| { py_class!(pub class LazyAncestors |py| {
data inner: RefCell<Box<CoreLazy<Index>>>; data inner: RefCell<Box<VCGLazyAncestors<Index>>>;
def __contains__(&self, rev: Revision) -> PyResult<bool> { def __contains__(&self, rev: Revision) -> PyResult<bool> {
self.inner(py) self.inner(py)
.borrow_mut() .borrow_mut()
.contains(rev) .contains(rev)
.map_err(|e| GraphError::pynew(py, e)) .map_err(|e| GraphError::pynew_from_vcsgraph(py, e))
} }
def __iter__(&self) -> PyResult<AncestorsIterator> { def __iter__(&self) -> PyResult<AncestorsIterator> {
AncestorsIterator::from_inner(py, self.inner(py).borrow().iter()) AncestorsIterator::from_inner(py, self.inner(py).borrow().iter())
} }
def __bool__(&self) -> PyResult<bool> { def __bool__(&self) -> PyResult<bool> {
Ok(!self.inner(py).borrow().is_empty()) Ok(!self.inner(py).borrow().is_empty())
} }
def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision, def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision,
inclusive: bool) -> PyResult<Self> { inclusive: bool) -> PyResult<Self> {
let initvec: Vec<Revision> = rev_pyiter_collect(py, &initrevs)?; let initvec: Vec<Revision> = rev_pyiter_collect(py, &initrevs)?;
let lazy = let lazy =
CoreLazy::new(pyindex_to_graph(py, index)?, VCGLazyAncestors::new(pyindex_to_graph(py, index)?,
initvec, stoprev, inclusive) initvec, stoprev, inclusive)
.map_err(|e| GraphError::pynew(py, e))?; .map_err(|e| GraphError::pynew_from_vcsgraph(py, e))?;
Self::create_instance(py, RefCell::new(Box::new(lazy))) Self::create_instance(py, RefCell::new(Box::new(lazy)))
} }
}); });
py_class!(pub class MissingAncestors |py| { py_class!(pub class MissingAncestors |py| {
data inner: RefCell<Box<CoreMissing<Index>>>; data inner: RefCell<Box<CoreMissing<Index>>>;

rust/hg-cpython/src/exceptions.rs

.and_then(|m| m.get(py, "WdirUnsupported")) .and_then(|m| m.get(py, "WdirUnsupported"))
{ {
Err(e) => e, Err(e) => e,
Ok(cls) => PyErr::from_instance(py, cls), Ok(cls) => PyErr::from_instance(py, cls),
} }
} }
} }
} }
pub fn pynew_from_vcsgraph(
py: Python,
inner: vcsgraph::graph::GraphReadError,
) -> PyErr {
match inner {
vcsgraph::graph::GraphReadError::InconsistentGraphData => {
GraphError::new(py, "InconsistentGraphData")
}
vcsgraph::graph::GraphReadError::InvalidKey => {
GraphError::new(py, "ParentOutOfRange")
}
vcsgraph::graph::GraphReadError::KeyedInvalidKey(r) => {
GraphError::new(py, ("ParentOutOfRange", r))
}
vcsgraph::graph::GraphReadError::WorkingDirectoryUnsupported => {
match py
.import("mercurial.error")
.and_then(|m| m.get(py, "WdirUnsupported"))
{
Err(e) => e,
Ok(cls) => PyErr::from_instance(py, cls),
}
}
}
}
} }
py_exception!(rustext, HgPathPyError, RuntimeError); py_exception!(rustext, HgPathPyError, RuntimeError);
py_exception!(rustext, FallbackError, RuntimeError); py_exception!(rustext, FallbackError, RuntimeError);
py_exception!(shared_ref, AlreadyBorrowed, RuntimeError); py_exception!(shared_ref, AlreadyBorrowed, RuntimeError);