This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7653

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

Authored by marmoute on Dec 13 2019, 3:11 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGf98f0e3ddaa1: rust-index: add a function to convert PyObject index for hg-core
Summary

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.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

Diff 18887

rust/hg-cpython/src/ancestors.rs

//! - [`AncestorsIterator`] is the Rust counterpart of the //! - [`AncestorsIterator`] is the Rust counterpart of the
//! `ancestor._lazyancestorsiter` Python generator. From Python, instances of //! `ancestor._lazyancestorsiter` Python generator. From Python, instances of
//! this should be mainly obtained by calling `iter()` on a [`LazyAncestors`] //! this should be mainly obtained by calling `iter()` on a [`LazyAncestors`]
//! instance. //! 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::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::Revision; use hg::Revision;
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 = CoreIterator::new(
Index::new(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(py, e))?;
AncestorsIterator::from_inner(py, ait) AncestorsIterator::from_inner(py, ait)
} }
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(Index::new(py, index)?, initvec, stoprev, inclusive) CoreLazy::new(pyindex_to_graph(py, index)?,
initvec, stoprev, inclusive)
.map_err(|e| GraphError::pynew(py, e))?; .map_err(|e| GraphError::pynew(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>>>;
def __new__(_cls, index: PyObject, bases: PyObject) -> PyResult<MissingAncestors> { def __new__(_cls, index: PyObject, bases: PyObject) -> PyResult<MissingAncestors> {
let bases_vec: Vec<Revision> = rev_pyiter_collect(py, &bases)?; 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))) MissingAncestors::create_instance(py, RefCell::new(Box::new(inner)))
} }
def hasbases(&self) -> PyResult<bool> { def hasbases(&self) -> PyResult<bool> {
Ok(self.inner(py).borrow().has_bases()) Ok(self.inner(py).borrow().has_bases())
} }
def addbases(&self, bases: PyObject) -> PyResult<PyObject> { def addbases(&self, bases: PyObject) -> PyResult<PyObject> {

rust/hg-cpython/src/dagops.rs

// dagops.rs // dagops.rs
// //
// Copyright 2019 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019 Georges Racinet <georges.racinet@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dagops` module provided by the //! Bindings for the `hg::dagops` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dagop` //! From Python, this will be seen as `mercurial.rustext.dagop`
use crate::{ use crate::{conversion::rev_pyiter_collect, exceptions::GraphError};
cindex::Index, conversion::rev_pyiter_collect, exceptions::GraphError,
};
use cpython::{PyDict, PyModule, PyObject, PyResult, Python}; use cpython::{PyDict, PyModule, PyObject, PyResult, Python};
use hg::dagops; use hg::dagops;
use hg::Revision; use hg::Revision;
use std::collections::HashSet; use std::collections::HashSet;
use crate::revlog::pyindex_to_graph;
/// Using the the `index`, return heads out of any Python iterable of Revisions /// Using the the `index`, return heads out of any Python iterable of Revisions
/// ///
/// This is the Rust counterpart for `mercurial.dagop.headrevs` /// This is the Rust counterpart for `mercurial.dagop.headrevs`
pub fn headrevs( pub fn headrevs(
py: Python, py: Python,
index: PyObject, index: PyObject,
revs: PyObject, revs: PyObject,
) -> PyResult<HashSet<Revision>> { ) -> PyResult<HashSet<Revision>> {
let mut as_set: HashSet<Revision> = rev_pyiter_collect(py, &revs)?; 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))?; .map_err(|e| GraphError::pynew(py, e))?;
Ok(as_set) Ok(as_set)
} }
/// Create the module, with `__package__` given from parent /// Create the module, with `__package__` given from parent
pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> { pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.dagop", package); let dotted_name = &format!("{}.dagop", package);
let m = PyModule::new(py, dotted_name)?; let m = PyModule::new(py, dotted_name)?;

rust/hg-cpython/src/discovery.rs

PythonObject, ToPyObject, PythonObject, ToPyObject,
}; };
use hg::discovery::PartialDiscovery as CorePartialDiscovery; use hg::discovery::PartialDiscovery as CorePartialDiscovery;
use hg::Revision; use hg::Revision;
use std::collections::HashSet; use std::collections::HashSet;
use std::cell::RefCell; use std::cell::RefCell;
use crate::revlog::pyindex_to_graph;
py_class!(pub class PartialDiscovery |py| { py_class!(pub class PartialDiscovery |py| {
data inner: RefCell<Box<CorePartialDiscovery<Index>>>; data inner: RefCell<Box<CorePartialDiscovery<Index>>>;
// `_respectsize` is currently only here to replicate the Python API and // `_respectsize` is currently only here to replicate the Python API and
// will be used in future patches inside methods that are yet to be // will be used in future patches inside methods that are yet to be
// implemented. // implemented.
def __new__( def __new__(
_cls, _cls,
repo: PyObject, repo: PyObject,
targetheads: PyObject, targetheads: PyObject,
respectsize: bool, respectsize: bool,
randomize: bool = true randomize: bool = true
) -> PyResult<PartialDiscovery> { ) -> PyResult<PartialDiscovery> {
let index = repo.getattr(py, "changelog")?.getattr(py, "index")?; let index = repo.getattr(py, "changelog")?.getattr(py, "index")?;
Self::create_instance( Self::create_instance(
py, py,
RefCell::new(Box::new(CorePartialDiscovery::new( RefCell::new(Box::new(CorePartialDiscovery::new(
Index::new(py, index)?, pyindex_to_graph(py, index)?,
rev_pyiter_collect(py, &targetheads)?, rev_pyiter_collect(py, &targetheads)?,
respectsize, respectsize,
randomize, randomize,
))) )))
) )
} }
def addcommons(&self, commons: PyObject) -> PyResult<PyObject> { def addcommons(&self, commons: PyObject) -> PyResult<PyObject> {

rust/hg-cpython/src/lib.rs

#[macro_use] #[macro_use]
pub mod ref_sharing; pub mod ref_sharing;
pub mod dagops; pub mod dagops;
pub mod dirstate; pub mod dirstate;
pub mod discovery; pub mod discovery;
pub mod exceptions; pub mod exceptions;
pub mod filepatterns; pub mod filepatterns;
pub mod parsers; pub mod parsers;
pub mod revlog;
pub mod utils; pub mod utils;
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",
)?; )?;

rust/hg-cpython/src/revlog.rs

  • This file was added.
// revlog.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.
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)
}