( )⚙ D5547 rust-cpython: consistency in use of hg-core constructs

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5547

rust-cpython: consistency in use of hg-core constructs
ClosedPublic

Authored by gracinet on Jan 10 2019, 4:55 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5ac61ca58c3f: rust-cpython: consistency in use of hg-core constructs
Summary

While not everybody likes the CoreLazy and CoreIterator
aliases, it's better not to mix them with direct references.
Note: it's quite possible in the future that these would stop
being exposed at the top of the hg crate

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

gracinet created this revision.Jan 10 2019, 4:55 AM
Closed by commit rHG5ac61ca58c3f: rust-cpython: consistency in use of hg-core constructs (authored by gracinet). · Explain WhyJan 11 2019, 9:15 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-cpython/src/ancestors.rs (7 lines)

Diff 13125

rust/hg-cpython/src/ancestors.rs

//! //!
//! [`LazyAncestors`]: struct.LazyAncestors.html //! [`LazyAncestors`]: struct.LazyAncestors.html
//! [`AncestorsIterator`]: struct.AncestorsIterator.html //! [`AncestorsIterator`]: struct.AncestorsIterator.html
use cindex::Index; use cindex::Index;
use cpython::{ use cpython::{
ObjectProtocol, PyClone, PyDict, PyModule, PyObject, PyResult, Python, ObjectProtocol, PyClone, PyDict, PyModule, PyObject, PyResult, Python,
}; };
use exceptions::GraphError; use exceptions::GraphError;
use hg;
use hg::Revision; use hg::Revision;
use hg::{AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy}; use hg::{AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy};
use std::cell::RefCell; use std::cell::RefCell;
/// Utility function to convert a Python iterable into a Vec<Revision> /// Utility function to convert a Python iterable into a Vec<Revision>
/// ///
/// We need this to feed to `AncestorIterators` constructors because /// We need this to feed to `AncestorIterators` constructors because
/// a `PyErr` can arise at each step of iteration, whereas our inner objects /// a `PyErr` can arise at each step of iteration, whereas our inner objects
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 = reviter_to_revvec(py, initrevs)?; let initvec = reviter_to_revvec(py, initrevs)?;
let ait = match hg::AncestorsIterator::new(Index::new(py, index)?, let ait = match CoreIterator::new(Index::new(py, index)?,
initvec, stoprev, initvec, stoprev,
inclusive) { inclusive) {
Ok(ait) => ait, Ok(ait) => ait,
Err(e) => { Err(e) => {
return Err(GraphError::pynew(py, e)); return Err(GraphError::pynew(py, e));
} }
}; };
AncestorsIterator::from_inner(py, ait) AncestorsIterator::from_inner(py, ait)
} }