( )⚙ D6272 rust-filepatterns: add `rust-cpython` bindings for `filepatterns`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6272

rust-filepatterns: add `rust-cpython` bindings for `filepatterns`
ClosedPublic

Authored by Alphare on Apr 18 2019, 8:10 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG94f3a73b6672: rust-filepatterns: add `rust-cpython` bindings for `filepatterns`
rHG3c3e5dda8d3d: rust-filepatterns: add `rust-cpython` bindings for `filepatterns`
rHG611b8953c93c: rust-filepatterns: add `rust-cpython` bindings for `filepatterns`
Summary

This change adds the rust-cpython interface for top-level functions and
exceptions in the filepatterns module.

Contrary to the Python implementation, this tries to have finer-grained
exceptions to allow for better readability and flow control down the line.

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

Alphare created this revision.Apr 18 2019, 8:10 AM
Alphare added a comment.May 3 2019, 4:25 AM

Hi, I'm bumping this stack so that it does not die. It seems to me that not a lot of work is left to close this.

durin42 accepted this revision.May 15 2019, 2:12 PM
This revision is now accepted and ready to land.May 15 2019, 2:12 PM
Alphare updated this revision to Diff 15142.May 16 2019, 11:21 AM
Closed by commit rHG611b8953c93c: rust-filepatterns: add `rust-cpython` bindings for `filepatterns` (authored by Alphare). · Explain WhyMay 16 2019, 1:13 PM
This revision was automatically updated to reflect the committed changes.
Alphare updated this revision to Diff 15170.May 17 2019, 10:17 AM

Revision Contents
Changeset List

PathPackages
Prust/hg-cpython/src/ancestors.rs
Copied to rust/hg-cpython/src/filepatterns.rs
Mrust/hg-cpython/src/exceptions.rs (44 lines)
Prust/hg-cpython/src/filepatterns.rs (279 lines)
Copied from rust/hg-cpython/src/ancestors.rs
Mrust/hg-cpython/src/lib.rs (4 lines)

Diff 15148

rust/hg-cpython/src/ancestors.rs

  • This file was copied to rust/hg-cpython/src/filepatterns.rs.

rust/hg-cpython/src/exceptions.rs

// ancestors.rs // ancestors.rs
// //
// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// 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 Rust errors //! Bindings for Rust errors
//! //!
//! [`GraphError`] exposes `hg::GraphError` as a subclass of `ValueError` //! [`GraphError`] exposes `hg::GraphError` as a subclass of `ValueError`
//! but some variants of `hg::GraphError` can be converted directly to other //! but some variants of `hg::GraphError` can be converted directly to other
//! existing Python exceptions if appropriate. //! existing Python exceptions if appropriate.
//! //!
//! [`GraphError`]: struct.GraphError.html //! [`GraphError`]: struct.GraphError.html
use cpython::exc::ValueError; use cpython::exc::{ValueError, RuntimeError};
use cpython::{PyErr, Python}; use cpython::{PyErr, Python, exc};
use hg; use hg;
py_exception!(rustext, GraphError, ValueError); py_exception!(rustext, GraphError, ValueError);
impl GraphError { impl GraphError {
pub fn pynew(py: Python, inner: hg::GraphError) -> PyErr { pub fn pynew(py: Python, inner: hg::GraphError) -> PyErr {
match inner { match inner {
hg::GraphError::ParentOutOfRange(r) => { hg::GraphError::ParentOutOfRange(r) => {
GraphError::new(py, ("ParentOutOfRange", r)) GraphError::new(py, ("ParentOutOfRange", r))
} }
hg::GraphError::WorkingDirectoryUnsupported => { hg::GraphError::WorkingDirectoryUnsupported => {
match py match py
.import("mercurial.error") .import("mercurial.error")
.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),
} }
} }
} }
} }
} }
py_exception!(rustext, PatternError, RuntimeError);
py_exception!(rustext, PatternFileError, RuntimeError);
impl PatternError {
pub fn pynew(py: Python, inner: hg::PatternError) -> PyErr {
match inner {
hg::PatternError::UnsupportedSyntax(m) => {
PatternError::new(py, ("PatternError", m))
}
}
}
}
impl PatternFileError {
pub fn pynew(py: Python, inner: hg::PatternFileError) -> PyErr {
match inner {
hg::PatternFileError::IO(e) => {
let value = (
e.raw_os_error().unwrap_or(2),
e.to_string()
);
PyErr::new::<exc::IOError, _>(py, value)
}
hg::PatternFileError::Pattern(e, l) => {
match e {
hg::PatternError::UnsupportedSyntax(m) =>
PatternFileError::new(py, ("PatternFileError", m, l))
}
}
}
}
}

rust/hg-cpython/src/filepatterns.rs

  • This file was copied from rust/hg-cpython/src/ancestors.rs.
// ancestors.rs // filepatterns.rs
// //
// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2019, Georges Racinet <gracinet@anybox.fr>,
// Raphaël Gomès <rgomes@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::ancestors` module provided by the //! Bindings for the `hg::filepatterns` module provided by the
//! `hg-core` crate. From Python, this will be seen as `rustext.ancestor` //! `hg-core` crate. From Python, this will be seen as `rustext.filepatterns`
//! and can be used as replacement for the the pure `ancestor` Python module. //! and can be used as replacement for the the pure `filepatterns` 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::conversion::{py_set, rev_pyiter_collect};
use cindex::Index;
use cpython::{ use cpython::{
ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject, PyResult, exc, PyDict, PyErr, PyModule, PyResult, PyString, PyTuple, Python,
Python, PythonObject, ToPyObject, ToPyObject,
}; };
use exceptions::GraphError; use hg::{build_single_regex, read_pattern_file, PatternTuple};
use hg::Revision; use exceptions::{
use hg::{ PatternError,
AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy, PatternFileError,
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)?,
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)
.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);
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> { /// Rust does not like functions with different return signatures.
let mut inner = self.inner(py).borrow_mut(); /// The 3-tuple version is always returned by the hg-core function,
let bases_vec: Vec<Revision> = rev_pyiter_collect(py, &bases)?; /// the (potential) conversion is handled at this level since it is not likely
inner.add_bases(bases_vec); /// to have any measurable impact on performance.
// cpython doc has examples with PyResult<()> but this gives me ///
// the trait `cpython::ToPyObject` is not implemented for `()` /// The Python implementation passes a function reference for `warn` instead
// so let's return an explicit None /// of a boolean that is used to emit warnings while parsing. The Rust
Ok(py.None()) /// implementation chooses to accumulate the warnings and propagate them to
/// Python upon completion. See the `readpatternfile` function in `match.py`
/// for more details.
fn read_pattern_file_wrapper(
py: Python,
file_path: String,
warn: bool,
source_info: bool,
) -> PyResult<PyTuple> {
match read_pattern_file(file_path, warn) {
Ok((patterns, warnings)) => {
if source_info {
return Ok((patterns, warnings).to_py_object(py));
}
let itemgetter = |x: &PatternTuple| x.0.to_py_object(py);
let results: Vec<PyString> =
patterns.iter().map(itemgetter).collect();
Ok((results, warnings).to_py_object(py))
}
Err(e) => Err(PatternFileError::pynew(py, e)),
} }
def bases(&self) -> PyResult<PyObject> {
py_set(py, self.inner(py).borrow().get_bases())
} }
def basesheads(&self) -> PyResult<PyObject> { fn build_single_regex_wrapper(
let inner = self.inner(py).borrow(); py: Python,
py_set(py, &inner.bases_heads().map_err(|e| GraphError::pynew(py, e))?) kind: String,
} pat: String,
globsuffix: String,
def removeancestorsfrom(&self, revs: PyObject) -> PyResult<PyObject> { ) -> PyResult<PyString> {
let mut inner = self.inner(py).borrow_mut(); match build_single_regex(
// this is very lame: we convert to a Rust set, update it in place kind.as_ref(),
// and then convert back to Python, only to have Python remove the pat.as_bytes(),
// excess (thankfully, Python is happy with a list or even an iterator) globsuffix.as_bytes(),
// Leads to improve this: ) {
// - have the CoreMissing instead do something emit revisions to Ok(regex) => match String::from_utf8(regex) {
// discard Ok(regex) => Ok(regex.to_py_object(py)),
// - define a trait for sets of revisions in the core and implement Err(e) => Err(PyErr::new::<exc::UnicodeDecodeError, _>(
// it for a Python set rewrapped with the GIL marker py,
let mut revs_pyset: HashSet<Revision> = rev_pyiter_collect(py, &revs)?; e.to_string(),
inner.remove_ancestors_from(&mut revs_pyset) )),
.map_err(|e| GraphError::pynew(py, e))?; },
Err(e) => Err(PatternError::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> { pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.ancestor", package); let dotted_name = &format!("{}.filepatterns", package);
let m = PyModule::new(py, dotted_name)?; let m = PyModule::new(py, dotted_name)?;
m.add(py, "__package__", package)?; m.add(py, "__package__", package)?;
m.add( m.add(
py, py,
"__doc__", "__doc__",
"Generic DAG ancestor algorithms - Rust implementation", "Patterns files parsing - Rust implementation",
)?;
m.add(
py,
"build_single_regex",
py_fn!(
py,
build_single_regex_wrapper(
kind: String,
pat: String,
globsuffix: String
)
),
)?;
m.add(
py,
"read_pattern_file",
py_fn!(
py,
read_pattern_file_wrapper(
file_path: String,
warn: bool,
source_info: bool
)
),
)?; )?;
m.add_class::<AncestorsIterator>(py)?;
m.add_class::<LazyAncestors>(py)?;
m.add_class::<MissingAncestors>(py)?;
let sys = PyModule::import(py, "sys")?; let sys = PyModule::import(py, "sys")?;
let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?; let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
sys_modules.set_item(py, dotted_name, &m)?; 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) Ok(m)
} }

rust/hg-cpython/src/lib.rs

pub mod ancestors; pub mod ancestors;
mod cindex; mod cindex;
mod conversion; mod conversion;
pub mod dagops; pub mod dagops;
pub mod discovery; pub mod discovery;
pub mod exceptions; pub mod exceptions;
pub mod dirstate; pub mod dirstate;
pub mod filepatterns;
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, "dagop", dagops::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, "discovery", discovery::init_module(py, &dotted_name)?)?;
m.add(py, "dirstate", dirstate::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, "GraphError", py.get_type::<exceptions::GraphError>())?; 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(()) Ok(())
}); });