changeset 42328:94f3a73b6672

rust-filepatterns: add `rust-cpython` bindings for `filepatterns` 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. Differential Revision: https://phab.mercurial-scm.org/D6272
author Raphaël Gomès <rgomes@octobus.net>
date Fri, 17 May 2019 09:36:29 -0400
parents e8f3740cc067
children c7652f7440d9
files rust/hg-cpython/src/exceptions.rs rust/hg-cpython/src/filepatterns.rs rust/hg-cpython/src/lib.rs
diffstat 3 files changed, 158 insertions(+), 5 deletions(-) [+]
line wrap: on
line diff
--- a/rust/hg-cpython/src/exceptions.rs	Wed Apr 24 11:34:09 2019 +0200
+++ b/rust/hg-cpython/src/exceptions.rs	Fri May 17 09:36:29 2019 -0400
@@ -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))
                 }
             }
         }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rust/hg-cpython/src/filepatterns.rs	Fri May 17 09:36:29 2019 -0400
@@ -0,0 +1,115 @@
+// filepatterns.rs
+//
+// 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
+// GNU General Public License version 2 or any later version.
+
+//! 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.
+//!
+use cpython::{
+    exc, PyDict, PyErr, PyModule, PyResult, PyString, PyTuple, Python,
+    ToPyObject,
+};
+use hg::{build_single_regex, read_pattern_file, PatternTuple};
+use exceptions::{
+    PatternError,
+    PatternFileError,
+};
+
+/// 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))
+        }
+        Err(e) => Err(PatternFileError::pynew(py, e)),
+    }
+}
+
+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)),
+    }
+}
+
+pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
+    let dotted_name = &format!("{}.filepatterns", package);
+    let m = PyModule::new(py, dotted_name)?;
+
+    m.add(py, "__package__", package)?;
+    m.add(
+        py,
+        "__doc__",
+        "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
+            )
+        ),
+    )?;
+
+    let sys = PyModule::import(py, "sys")?;
+    let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
+    sys_modules.set_item(py, dotted_name, &m)?;
+
+    Ok(m)
+}
--- a/rust/hg-cpython/src/lib.rs	Wed Apr 24 11:34:09 2019 +0200
+++ b/rust/hg-cpython/src/lib.rs	Fri May 17 09:36:29 2019 -0400
@@ -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(())
 });