rust-index: add a function to convert PyObject index for hg-core

Function in hg-core need something implementing the `Graph` trait. Right now,
the `hg-cpython` entry points directly turn the PyObject passed as argument
into a `cindex::Index`. However, if we start having the option to use an Index
in Rust, we need to dispatch between the different possible PyObject we could
receive.

So move the "duplicate" call into a unified function. When time come. It will be
easy to update the logic of all interface when the time come.

Differential Revision: https://phab.mercurial-scm.org/D7653

rust/hg-cpython/src/revlog.rs

@@ -0,0 +1,17 b''
+// revlog.rs
+//
+// Copyright 2019 Georges Racinet <[e-mail]>
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+
+use crate::cindex;
+use cpython::{PyObject, PyResult, Python};
+
+/// Return a Struct implementing the Graph trait
+pub(crate) fn pyindex_to_graph(
+    py: Python,
+    index: PyObject,
+) -> PyResult<cindex::Index> {
+    cindex::Index::new(py, index)
+}

rust/hg-cpython/src/ancestors.rs

@@ -1,220 +1,222 b''
 // ancestors.rs
 //
 // Copyright 2018 Georges Racinet <[e-mail]>
 //
 // 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`
 //! and can be used as replacement for the the pure `ancestor` Python module.
 //!
 //! # Classes visible from Python:
 //! - [`LazyAncestors`] is the Rust implementation of
 //!   `mercurial.ancestor.lazyancestors`. The only difference is that it is
 //!   instantiated with a C `parsers.index` instance instead of a parents
 //!   function.
 //!
 //! - [`MissingAncestors`] is the Rust implementation of
 //!   `mercurial.ancestor.incrementalmissingancestors`.
 //!
 //!   API differences:
 //!    + it is instantiated with a C `parsers.index`
 //!      instance instead of a parents function.
 //!    + `MissingAncestors.bases` is a method returning a tuple instead of
 //!      a set-valued attribute. We could return a Python set easily if our
 //!      [PySet PR](https://github.com/dgrunwald/rust-cpython/pull/165)
 //!      is accepted.
 //!
 //! - [`AncestorsIterator`] is the Rust counterpart of the
 //!   `ancestor._lazyancestorsiter` Python generator. From Python, instances of
 //!   this should be mainly obtained by calling `iter()` on a [`LazyAncestors`]
 //!   instance.
 //!
 //! [`LazyAncestors`]: struct.LazyAncestors.html
 //! [`MissingAncestors`]: struct.MissingAncestors.html
 //! [`AncestorsIterator`]: struct.AncestorsIterator.html
+use crate::revlog::pyindex_to_graph;
 use crate::{
     cindex::Index, conversion::rev_pyiter_collect, exceptions::GraphError,
 };
 use cpython::{
     ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject, PyResult,
     Python, PythonObject, ToPyObject,
 };
 use hg::Revision;
 use hg::{
     AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy,
     MissingAncestors as CoreMissing,
 };
 use std::cell::RefCell;
 use std::collections::HashSet;
 
 py_class!(pub class AncestorsIterator |py| {
     data inner: RefCell<Box<CoreIterator<Index>>>;
 
     def __next__(&self) -> PyResult<Option<Revision>> {
         match self.inner(py).borrow_mut().next() {
             Some(Err(e)) => Err(GraphError::pynew(py, e)),
             None => Ok(None),
             Some(Ok(r)) => Ok(Some(r)),
         }
     }
 
     def __contains__(&self, rev: Revision) -> PyResult<bool> {
         self.inner(py).borrow_mut().contains(rev)
             .map_err(|e| GraphError::pynew(py, e))
     }
 
     def __iter__(&self) -> PyResult<Self> {
         Ok(self.clone_ref(py))
     }
 
     def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision,
                 inclusive: bool) -> PyResult<AncestorsIterator> {
         let initvec: Vec<Revision> = rev_pyiter_collect(py, &initrevs)?;
         let ait = CoreIterator::new(
-            Index::new(py, index)?,
+            pyindex_to_graph(py, index)?,
             initvec,
             stoprev,
             inclusive,
         )
         .map_err(|e| GraphError::pynew(py, e))?;
         AncestorsIterator::from_inner(py, ait)
     }
 
 });
 
 impl AncestorsIterator {
     pub fn from_inner(py: Python, ait: CoreIterator<Index>) -> PyResult<Self> {
         Self::create_instance(py, RefCell::new(Box::new(ait)))
     }
 }
 
 py_class!(pub class LazyAncestors |py| {
     data inner: RefCell<Box<CoreLazy<Index>>>;
 
     def __contains__(&self, rev: Revision) -> PyResult<bool> {
         self.inner(py)
             .borrow_mut()
             .contains(rev)
             .map_err(|e| GraphError::pynew(py, e))
     }
 
     def __iter__(&self) -> PyResult<AncestorsIterator> {
         AncestorsIterator::from_inner(py, self.inner(py).borrow().iter())
     }
 
     def __bool__(&self) -> PyResult<bool> {
         Ok(!self.inner(py).borrow().is_empty())
     }
 
     def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision,
                 inclusive: bool) -> PyResult<Self> {
         let initvec: Vec<Revision> = rev_pyiter_collect(py, &initrevs)?;
 
         let lazy =
-            CoreLazy::new(Index::new(py, index)?, initvec, stoprev, inclusive)
+            CoreLazy::new(pyindex_to_graph(py, index)?,
+                          initvec, stoprev, inclusive)
                 .map_err(|e| GraphError::pynew(py, e))?;
 
         Self::create_instance(py, RefCell::new(Box::new(lazy)))
         }
 
 });
 
 py_class!(pub class MissingAncestors |py| {
     data inner: RefCell<Box<CoreMissing<Index>>>;
 
     def __new__(_cls, index: PyObject, bases: PyObject) -> PyResult<MissingAncestors> {
         let bases_vec: Vec<Revision> = rev_pyiter_collect(py, &bases)?;
-        let inner = CoreMissing::new(Index::new(py, index)?, bases_vec);
+        let inner = CoreMissing::new(pyindex_to_graph(py, index)?, bases_vec);
         MissingAncestors::create_instance(py, RefCell::new(Box::new(inner)))
     }
 
     def hasbases(&self) -> PyResult<bool> {
         Ok(self.inner(py).borrow().has_bases())
     }
 
     def addbases(&self, bases: PyObject) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let bases_vec: Vec<Revision> = rev_pyiter_collect(py, &bases)?;
         inner.add_bases(bases_vec);
         // cpython doc has examples with PyResult<()> but this gives me
         //   the trait `cpython::ToPyObject` is not implemented for `()`
         // so let's return an explicit None
         Ok(py.None())
     }
 
     def bases(&self) -> PyResult<HashSet<Revision>> {
         Ok(self.inner(py).borrow().get_bases().clone())
     }
 
     def basesheads(&self) -> PyResult<HashSet<Revision>> {
         let inner = self.inner(py).borrow();
         inner.bases_heads().map_err(|e| GraphError::pynew(py, e))
     }
 
     def removeancestorsfrom(&self, revs: PyObject) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         // this is very lame: we convert to a Rust set, update it in place
         // and then convert back to Python, only to have Python remove the
         // excess (thankfully, Python is happy with a list or even an iterator)
         // Leads to improve this:
         //  - have the CoreMissing instead do something emit revisions to
         //    discard
         //  - define a trait for sets of revisions in the core and implement
         //    it for a Python set rewrapped with the GIL marker
         let mut revs_pyset: HashSet<Revision> = rev_pyiter_collect(py, &revs)?;
         inner.remove_ancestors_from(&mut revs_pyset)
             .map_err(|e| GraphError::pynew(py, e))?;
 
         // convert as Python list
         let mut remaining_pyint_vec: Vec<PyObject> = Vec::with_capacity(
             revs_pyset.len());
         for rev in revs_pyset {
             remaining_pyint_vec.push(rev.to_py_object(py).into_object());
         }
         let remaining_pylist = PyList::new(py, remaining_pyint_vec.as_slice());
         revs.call_method(py, "intersection_update", (remaining_pylist, ), None)
     }
 
     def missingancestors(&self, revs: PyObject) -> PyResult<PyList> {
         let mut inner = self.inner(py).borrow_mut();
         let revs_vec: Vec<Revision> = rev_pyiter_collect(py, &revs)?;
         let missing_vec = match inner.missing_ancestors(revs_vec) {
             Ok(missing) => missing,
             Err(e) => {
                 return Err(GraphError::pynew(py, e));
             }
         };
         // convert as Python list
         let mut missing_pyint_vec: Vec<PyObject> = Vec::with_capacity(
             missing_vec.len());
         for rev in missing_vec {
             missing_pyint_vec.push(rev.to_py_object(py).into_object());
         }
         Ok(PyList::new(py, missing_pyint_vec.as_slice()))
     }
 });
 
 /// Create the module, with __package__ given from parent
 pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.ancestor", package);
     let m = PyModule::new(py, dotted_name)?;
     m.add(py, "__package__", package)?;
     m.add(
         py,
         "__doc__",
         "Generic DAG ancestor algorithms - Rust implementation",
     )?;
     m.add_class::<AncestorsIterator>(py)?;
     m.add_class::<LazyAncestors>(py)?;
     m.add_class::<MissingAncestors>(py)?;
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
     sys_modules.set_item(py, dotted_name, &m)?;
     // Example C code (see pyexpat.c and import.c) will "give away the
     // reference", but we won't because it will be consumed once the
     // Rust PyObject is dropped.
     Ok(m)
 }

rust/hg-cpython/src/dagops.rs

@@ -1,53 +1,53 b''
 // dagops.rs
 //
 // Copyright 2019 Georges Racinet <[e-mail]>
 //
 // 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::dagops` module provided by the
 //! `hg-core` package.
 //!
 //! From Python, this will be seen as `mercurial.rustext.dagop`
-use crate::{
-    cindex::Index, conversion::rev_pyiter_collect, exceptions::GraphError,
-};
+use crate::{conversion::rev_pyiter_collect, exceptions::GraphError};
 use cpython::{PyDict, PyModule, PyObject, PyResult, Python};
 use hg::dagops;
 use hg::Revision;
 use std::collections::HashSet;
 
+use crate::revlog::pyindex_to_graph;
+
 /// Using the the `index`, return heads out of any Python iterable of Revisions
 ///
 /// This is the Rust counterpart for `mercurial.dagop.headrevs`
 pub fn headrevs(
     py: Python,
     index: PyObject,
     revs: PyObject,
 ) -> PyResult<HashSet<Revision>> {
     let mut as_set: HashSet<Revision> = rev_pyiter_collect(py, &revs)?;
-    dagops::retain_heads(&Index::new(py, index)?, &mut as_set)
+    dagops::retain_heads(&pyindex_to_graph(py, index)?, &mut as_set)
         .map_err(|e| GraphError::pynew(py, e))?;
     Ok(as_set)
 }
 
 /// Create the module, with `__package__` given from parent
 pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.dagop", package);
     let m = PyModule::new(py, dotted_name)?;
     m.add(py, "__package__", package)?;
     m.add(py, "__doc__", "DAG operations - Rust implementation")?;
     m.add(
         py,
         "headrevs",
         py_fn!(py, headrevs(index: PyObject, revs: PyObject)),
     )?;
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
     sys_modules.set_item(py, dotted_name, &m)?;
     // Example C code (see pyexpat.c and import.c) will "give away the
     // reference", but we won't because it will be consumed once the
     // Rust PyObject is dropped.
     Ok(m)
 }

rust/hg-cpython/src/discovery.rs

@@ -1,159 +1,161 b''
 // discovery.rs
 //
 // Copyright 2018 Georges Racinet <[e-mail]>
 //
 // 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::discovery` module provided by the
 //! `hg-core` crate. From Python, this will be seen as `rustext.discovery`
 //!
 //! # Classes visible from Python:
 //! - [`PartialDiscover`] is the Rust implementation of
 //!   `mercurial.setdiscovery.partialdiscovery`.
 
 use crate::{
     cindex::Index, conversion::rev_pyiter_collect, exceptions::GraphError,
 };
 use cpython::{
     ObjectProtocol, PyDict, PyModule, PyObject, PyResult, PyTuple, Python,
     PythonObject, ToPyObject,
 };
 use hg::discovery::PartialDiscovery as CorePartialDiscovery;
 use hg::Revision;
 use std::collections::HashSet;
 
 use std::cell::RefCell;
 
+use crate::revlog::pyindex_to_graph;
+
 py_class!(pub class PartialDiscovery |py| {
     data inner: RefCell<Box<CorePartialDiscovery<Index>>>;
 
     // `_respectsize` is currently only here to replicate the Python API and
     // will be used in future patches inside methods that are yet to be
     // implemented.
     def __new__(
         _cls,
         repo: PyObject,
         targetheads: PyObject,
         respectsize: bool,
         randomize: bool = true
     ) -> PyResult<PartialDiscovery> {
         let index = repo.getattr(py, "changelog")?.getattr(py, "index")?;
         Self::create_instance(
             py,
             RefCell::new(Box::new(CorePartialDiscovery::new(
-                Index::new(py, index)?,
+                pyindex_to_graph(py, index)?,
                 rev_pyiter_collect(py, &targetheads)?,
                 respectsize,
                 randomize,
             )))
         )
     }
 
     def addcommons(&self, commons: PyObject) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let commons_vec: Vec<Revision> = rev_pyiter_collect(py, &commons)?;
         inner.add_common_revisions(commons_vec)
             .map_err(|e| GraphError::pynew(py, e))?;
         Ok(py.None())
     }
 
     def addmissings(&self, missings: PyObject) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let missings_vec: Vec<Revision> = rev_pyiter_collect(py, &missings)?;
         inner.add_missing_revisions(missings_vec)
             .map_err(|e| GraphError::pynew(py, e))?;
         Ok(py.None())
     }
 
     def addinfo(&self, sample: PyObject) -> PyResult<PyObject> {
         let mut missing: Vec<Revision> = Vec::new();
         let mut common: Vec<Revision> = Vec::new();
         for info in sample.iter(py)? { // info is a pair (Revision, bool)
             let mut revknown = info?.iter(py)?;
             let rev: Revision = revknown.next().unwrap()?.extract(py)?;
             let known: bool = revknown.next().unwrap()?.extract(py)?;
             if known {
                 common.push(rev);
             } else {
                 missing.push(rev);
             }
         }
         let mut inner = self.inner(py).borrow_mut();
         inner.add_common_revisions(common)
             .map_err(|e| GraphError::pynew(py, e))?;
         inner.add_missing_revisions(missing)
             .map_err(|e| GraphError::pynew(py, e))?;
         Ok(py.None())
     }
 
     def hasinfo(&self) -> PyResult<bool> {
         Ok(self.inner(py).borrow().has_info())
     }
 
     def iscomplete(&self) -> PyResult<bool> {
         Ok(self.inner(py).borrow().is_complete())
     }
 
     def stats(&self) -> PyResult<PyDict> {
         let stats = self.inner(py).borrow().stats();
         let as_dict: PyDict = PyDict::new(py);
         as_dict.set_item(py, "undecided",
                          stats.undecided.map(
                              |l| l.to_py_object(py).into_object())
                              .unwrap_or_else(|| py.None()))?;
         Ok(as_dict)
     }
 
     def commonheads(&self) -> PyResult<HashSet<Revision>> {
         self.inner(py).borrow().common_heads()
             .map_err(|e| GraphError::pynew(py, e))
     }
 
     def takefullsample(&self, _headrevs: PyObject,
                        size: usize) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let sample = inner.take_full_sample(size)
             .map_err(|e| GraphError::pynew(py, e))?;
         let as_vec: Vec<PyObject> = sample
             .iter()
             .map(|rev| rev.to_py_object(py).into_object())
             .collect();
         Ok(PyTuple::new(py, as_vec.as_slice()).into_object())
     }
 
     def takequicksample(&self, headrevs: PyObject,
                         size: usize) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let revsvec: Vec<Revision> = rev_pyiter_collect(py, &headrevs)?;
         let sample = inner.take_quick_sample(revsvec, size)
             .map_err(|e| GraphError::pynew(py, e))?;
         let as_vec: Vec<PyObject> = sample
             .iter()
             .map(|rev| rev.to_py_object(py).into_object())
             .collect();
         Ok(PyTuple::new(py, as_vec.as_slice()).into_object())
     }
 
 });
 
 /// Create the module, with __package__ given from parent
 pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.discovery", package);
     let m = PyModule::new(py, dotted_name)?;
     m.add(py, "__package__", package)?;
     m.add(
         py,
         "__doc__",
         "Discovery of common node sets - Rust implementation",
     )?;
     m.add_class::<PartialDiscovery>(py)?;
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
     sys_modules.set_item(py, dotted_name, &m)?;
     // Example C code (see pyexpat.c and import.c) will "give away the
     // reference", but we won't because it will be consumed once the
     // Rust PyObject is dropped.
     Ok(m)
 }

rust/hg-cpython/src/lib.rs

@@ -1,81 +1,82 b''
 // lib.rs
 //
 // Copyright 2018 Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Python bindings of `hg-core` objects using the `cpython` crate.
 //! Once compiled, the resulting single shared library object can be placed in
 //! the `mercurial` package directly as `rustext.so` or `rustext.dll`.
 //! It holds several modules, so that from the point of view of Python,
 //! it behaves as the `cext` package.
 //!
 //! Example:
 //!
 //! ```text
 //! >>> from mercurial.rustext import ancestor
 //! >>> ancestor.__doc__
 //! 'Generic DAG ancestor algorithms - Rust implementation'
 //! ```
 
 /// This crate uses nested private macros, `extern crate` is still needed in
 /// 2018 edition.
 #[macro_use]
 extern crate cpython;
 
 pub mod ancestors;
 mod cindex;
 mod conversion;
 #[macro_use]
 pub mod ref_sharing;
 pub mod dagops;
 pub mod dirstate;
 pub mod discovery;
 pub mod exceptions;
 pub mod filepatterns;
 pub mod parsers;
+pub mod revlog;
 pub mod utils;
 
 py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| {
     m.add(
         py,
         "__doc__",
         "Mercurial core concepts - Rust implementation",
     )?;
 
     let dotted_name: String = m.get(py, "__name__")?.extract(py)?;
     m.add(py, "ancestor", ancestors::init_module(py, &dotted_name)?)?;
     m.add(py, "dagop", dagops::init_module(py, &dotted_name)?)?;
     m.add(py, "discovery", discovery::init_module(py, &dotted_name)?)?;
     m.add(py, "dirstate", dirstate::init_module(py, &dotted_name)?)?;
     m.add(
         py,
         "filepatterns",
         filepatterns::init_module(py, &dotted_name)?,
     )?;
     m.add(
         py,
         "parsers",
         parsers::init_parsers_module(py, &dotted_name)?,
     )?;
     m.add(py, "GraphError", py.get_type::<exceptions::GraphError>())?;
     m.add(
         py,
         "PatternFileError",
         py.get_type::<exceptions::PatternFileError>(),
     )?;
     m.add(
         py,
         "PatternError",
         py.get_type::<exceptions::PatternError>(),
     )?;
     Ok(())
 });
 
 #[cfg(not(any(feature = "python27-bin", feature = "python3-bin")))]
 #[test]
 #[ignore]
 fn libpython_must_be_linked_to_run_tests() {
     // stub function to tell that some tests wouldn't run
 }