This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5578

rust-cpython: moved generic conversion fn out of ancestors module
ClosedPublic

Authored by gracinet on Jan 14 2019, 9:13 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGff333620a4cc: rust-cpython: moved generic conversion fn out of ancestors module
Summary

This will allow to use it easily from other submodules

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

gracinet created this revision.Jan 14 2019, 9:13 PM
Closed by commit rHGff333620a4cc: rust-cpython: moved generic conversion fn out of ancestors module (authored by gracinet). · Explain WhyJan 16 2019, 7:43 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 13249

rust/hg-cpython/src/ancestors.rs

//! - [`AncestorsIterator`] is the Rust counterpart of the //! - [`AncestorsIterator`] is the Rust counterpart of the
//! `ancestor._lazyancestorsiter` Python generator. //! `ancestor._lazyancestorsiter` Python generator.
//! From Python, instances of this should be mainly obtained by calling //! From Python, instances of this should be mainly obtained by calling
//! `iter()` on a [`LazyAncestors`] instance. //! `iter()` on a [`LazyAncestors`] instance.
//! //!
//! [`LazyAncestors`]: struct.LazyAncestors.html //! [`LazyAncestors`]: struct.LazyAncestors.html
//! [`MissingAncestors`]: struct.MissingAncestors.html //! [`MissingAncestors`]: struct.MissingAncestors.html
//! [`AncestorsIterator`]: struct.AncestorsIterator.html //! [`AncestorsIterator`]: struct.AncestorsIterator.html
use crate::conversion::rev_pyiter_collect;
use cindex::Index; use cindex::Index;
use cpython::{ use cpython::{
ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject, ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject,
PyResult, PyTuple, Python, PythonObject, ToPyObject, PyResult, PyTuple, Python, PythonObject, ToPyObject,
}; };
use exceptions::GraphError; use exceptions::GraphError;
use hg::Revision; use hg::Revision;
use hg::{ use hg::{
AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy, AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy,
MissingAncestors as CoreMissing, MissingAncestors as CoreMissing,
}; };
use std::cell::RefCell; use std::cell::RefCell;
use std::iter::FromIterator;
use std::collections::HashSet; use std::collections::HashSet;
/// Utility function to convert a Python iterable into various collections
///
/// We need this in particular to feed to various methods of inner objects
/// with `impl IntoIterator<Item=Revision>` arguments, because
/// a `PyErr` can arise at each step of iteration, whereas these methods
/// expect iterables over `Revision`, not over some `Result<Revision, PyErr>`
fn rev_pyiter_collect<C>(py: Python, revs: &PyObject) -> PyResult<C>
where
C: FromIterator<Revision>,
{
revs.iter(py)?
.map(|r| r.and_then(|o| o.extract::<Revision>(py)))
.collect()
}
py_class!(pub class AncestorsIterator |py| { py_class!(pub class AncestorsIterator |py| {
data inner: RefCell<Box<CoreIterator<Index>>>; data inner: RefCell<Box<CoreIterator<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(py, e)),
None => Ok(None), None => Ok(None),
Some(Ok(r)) => Ok(Some(r)), Some(Ok(r)) => Ok(Some(r)),

rust/hg-cpython/src/conversion.rs

  • This file was added.
// conversion.rs
//
// Copyright 2019 Georges Racinet <georges.racinet@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
//! Bindings for the hg::ancestors module provided by the
//! `hg-core` crate. From Python, this will be seen as `rustext.ancestor`
use cpython::{ObjectProtocol, PyObject, PyResult, Python};
use hg::Revision;
use std::iter::FromIterator;
/// Utility function to convert a Python iterable into various collections
///
/// We need this in particular to feed to various methods of inner objects
/// with `impl IntoIterator<Item=Revision>` arguments, because
/// a `PyErr` can arise at each step of iteration, whereas these methods
/// expect iterables over `Revision`, not over some `Result<Revision, PyErr>`
pub fn rev_pyiter_collect<C>(py: Python, revs: &PyObject) -> PyResult<C>
where
C: FromIterator<Revision>,
{
revs.iter(py)?
.map(|r| r.and_then(|o| o.extract::<Revision>(py)))
.collect()
}

rust/hg-cpython/src/lib.rs

#[macro_use] #[macro_use]
extern crate cpython; extern crate cpython;
extern crate hg; extern crate hg;
extern crate libc; extern crate libc;
pub mod ancestors; pub mod ancestors;
mod cindex; mod cindex;
mod conversion;
pub mod exceptions; pub mod exceptions;
py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| { py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| {
m.add( m.add(
py, py,
"__doc__", "__doc__",
"Mercurial core concepts - Rust implementation", "Mercurial core concepts - Rust implementation",
)?; )?;
let dotted_name: String = m.get(py, "__name__")?.extract(py)?; let dotted_name: String = m.get(py, "__name__")?.extract(py)?;
m.add(py, "ancestor", ancestors::init_module(py, &dotted_name)?)?; m.add(py, "ancestor", ancestors::init_module(py, &dotted_name)?)?;
m.add(py, "GraphError", py.get_type::<exceptions::GraphError>())?; m.add(py, "GraphError", py.get_type::<exceptions::GraphError>())?;
Ok(()) Ok(())
}); });