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

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 31562

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);