D6272: rust-filepatterns: add `rust-cpython` bindings for `filepatterns`
Alphare (Raphaël Gomès)
phabricator at mercurial-scm.org
Thu May 16 13:13:23 EDT 2019
This revision was automatically updated to reflect the committed changes.
Closed by commit rHG611b8953c93c: rust-filepatterns: add `rust-cpython` bindings for `filepatterns` (authored by Alphare, committed by ).
REPOSITORY
rHG Mercurial
CHANGES SINCE LAST UPDATE
https://phab.mercurial-scm.org/D6272?vs=15142&id=15148
REVISION DETAIL
https://phab.mercurial-scm.org/D6272
AFFECTED FILES
rust/hg-cpython/src/ancestors.rs
rust/hg-cpython/src/exceptions.rs
rust/hg-cpython/src/filepatterns.rs
rust/hg-cpython/src/lib.rs
CHANGE DETAILS
diff --git a/rust/hg-cpython/src/lib.rs b/rust/hg-cpython/src/lib.rs
--- a/rust/hg-cpython/src/lib.rs
+++ b/rust/hg-cpython/src/lib.rs
@@ -32,6 +32,7 @@
pub mod discovery;
pub mod exceptions;
pub mod dirstate;
+pub mod filepatterns;
py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| {
m.add(
@@ -45,6 +46,9 @@
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, "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(())
});
diff --git a/rust/hg-cpython/src/ancestors.rs b/rust/hg-cpython/src/filepatterns.rs
copy from rust/hg-cpython/src/ancestors.rs
copy to rust/hg-cpython/src/filepatterns.rs
--- a/rust/hg-cpython/src/ancestors.rs
+++ b/rust/hg-cpython/src/filepatterns.rs
@@ -1,220 +1,115 @@
-// ancestors.rs
+// filepatterns.rs
//
-// Copyright 2018 Georges Racinet <gracinet at anybox.fr>
+// Copyright 2019, Georges Racinet <gracinet at anybox.fr>,
+// Raphaël Gomès <rgomes at 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`
-//! 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`.
+//! Bindings for the `hg::filepatterns` module provided by the
+//! `hg-core` crate. From Python, this will be seen as `rustext.filepatterns`
+//! and can be used as replacement for the the pure `filepatterns` Python module.
//!
-//! 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::{
- ObjectProtocol, PyClone, PyDict, PyList, PyModule, PyObject, PyResult,
- Python, PythonObject, ToPyObject,
+ exc, PyDict, PyErr, PyModule, PyResult, PyString, PyTuple, Python,
+ ToPyObject,
};
-use exceptions::GraphError;
-use hg::Revision;
-use hg::{
- AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy,
- MissingAncestors as CoreMissing,
+use hg::{build_single_regex, read_pattern_file, PatternTuple};
+use exceptions::{
+ PatternError,
+ PatternFileError,
};
-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)),
+/// Rust does not like functions with different return signatures.
+/// The 3-tuple version is always returned by the hg-core function,
+/// the (potential) conversion is handled at this level since it is not likely
+/// to have any measurable impact on performance.
+///
+/// The Python implementation passes a function reference for `warn` instead
+/// of a boolean that is used to emit warnings while parsing. The Rust
+/// 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))
}
- }
-
- 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)))
+ Err(e) => Err(PatternFileError::pynew(py, e)),
}
}
-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())
+fn build_single_regex_wrapper(
+ py: Python,
+ kind: String,
+ pat: String,
+ globsuffix: String,
+) -> PyResult<PyString> {
+ match build_single_regex(
+ kind.as_ref(),
+ pat.as_bytes(),
+ globsuffix.as_bytes(),
+ ) {
+ Ok(regex) => match String::from_utf8(regex) {
+ Ok(regex) => Ok(regex.to_py_object(py)),
+ Err(e) => Err(PyErr::new::<exc::UnicodeDecodeError, _>(
+ py,
+ e.to_string(),
+ )),
+ },
+ Err(e) => Err(PatternError::pynew(py, e)),
}
-
- 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> {
- 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<PyObject> {
- py_set(py, self.inner(py).borrow().get_bases())
- }
-
- def basesheads(&self) -> PyResult<PyObject> {
- let inner = self.inner(py).borrow();
- py_set(py, &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))?;
+pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
+ let dotted_name = &format!("{}.filepatterns", package);
+ let m = PyModule::new(py, dotted_name)?;
- // 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",
+ "Patterns files parsing - Rust implementation",
)?;
- m.add_class::<AncestorsIterator>(py)?;
- m.add_class::<LazyAncestors>(py)?;
- m.add_class::<MissingAncestors>(py)?;
+ 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
+ )
+ ),
+ )?;
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)
}
diff --git a/rust/hg-cpython/src/exceptions.rs b/rust/hg-cpython/src/exceptions.rs
--- a/rust/hg-cpython/src/exceptions.rs
+++ b/rust/hg-cpython/src/exceptions.rs
@@ -12,8 +12,8 @@
//! existing Python exceptions if appropriate.
//!
//! [`GraphError`]: struct.GraphError.html
-use cpython::exc::ValueError;
-use cpython::{PyErr, Python};
+use cpython::exc::{ValueError, RuntimeError};
+use cpython::{PyErr, Python, exc};
use hg;
py_exception!(rustext, GraphError, ValueError);
@@ -28,9 +28,43 @@
match py
.import("mercurial.error")
.and_then(|m| m.get(py, "WdirUnsupported"))
- {
- Err(e) => e,
- Ok(cls) => PyErr::from_instance(py, cls),
+ {
+ Err(e) => e,
+ 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))
}
}
}
To: Alphare, #hg-reviewers, durin42
Cc: durin42, kevincox, mjpieters, mercurial-devel
More information about the Mercurial-devel
mailing list