( )⚙ 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
Lint Skipped
Unit
Unit Tests Skipped

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 15142

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(())
}); });