D7868: rust-filepatterns: remove bridge code for filepatterns-related functions

Alphare (Raphaël Gomès) phabricator at mercurial-scm.org
Tue Jan 14 12:35:20 EST 2020


Alphare created this revision.
Herald added subscribers: mercurial-devel, mjpieters, kevincox, durin42.
Herald added a reviewer: hg-reviewers.

REVISION SUMMARY
  These functions will be used internally by `hg-core` without needed to be
  exposed to Python.

REPOSITORY
  rHG Mercurial

BRANCH
  default

REVISION DETAIL
  https://phab.mercurial-scm.org/D7868

AFFECTED FILES
  mercurial/match.py
  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
@@ -33,7 +33,6 @@
 pub mod dirstate;
 pub mod discovery;
 pub mod exceptions;
-pub mod filepatterns;
 pub mod parsers;
 pub mod revlog;
 pub mod utils;
@@ -53,25 +52,10 @@
     m.add(py, "revlog", revlog::init_module(py, &dotted_name)?)?;
     m.add(
         py,
-        "filepatterns",
-        filepatterns::init_module(py, &dotted_name)?,
-    )?;
-    m.add(
-        py,
         "parsers",
         parsers::init_parsers_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/filepatterns.rs b/rust/hg-cpython/src/filepatterns.rs
deleted file mode 100644
--- a/rust/hg-cpython/src/filepatterns.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-// filepatterns.rs
-//
-// 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::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 crate::exceptions::{PatternError, PatternFileError};
-use cpython::{
-    PyBytes, PyDict, PyModule, PyObject, PyResult, PyTuple, Python, ToPyObject,
-};
-use hg::utils::files;
-use hg::{build_single_regex, read_pattern_file, LineNumber, PatternTuple};
-use std::path::PathBuf;
-
-/// 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: PyObject,
-    warn: bool,
-    source_info: bool,
-) -> PyResult<PyTuple> {
-    let bytes = file_path.extract::<PyBytes>(py)?;
-    let path = files::get_path_from_bytes(bytes.data(py));
-    match read_pattern_file(path, warn) {
-        Ok((patterns, warnings)) => {
-            if source_info {
-                let itemgetter = |x: &PatternTuple| {
-                    (PyBytes::new(py, &x.0), x.1, PyBytes::new(py, &x.2))
-                };
-                let results: Vec<(PyBytes, LineNumber, PyBytes)> =
-                    patterns.iter().map(itemgetter).collect();
-                return Ok((results, warnings_to_py_bytes(py, &warnings))
-                    .to_py_object(py));
-            }
-            let itemgetter = |x: &PatternTuple| PyBytes::new(py, &x.0);
-            let results: Vec<PyBytes> =
-                patterns.iter().map(itemgetter).collect();
-            Ok(
-                (results, warnings_to_py_bytes(py, &warnings))
-                    .to_py_object(py),
-            )
-        }
-        Err(e) => Err(PatternFileError::pynew(py, e)),
-    }
-}
-
-fn warnings_to_py_bytes(
-    py: Python,
-    warnings: &[(PathBuf, Vec<u8>)],
-) -> Vec<(PyBytes, PyBytes)> {
-    warnings
-        .iter()
-        .map(|(path, syn)| {
-            (
-                PyBytes::new(py, &files::get_bytes_from_path(path)),
-                PyBytes::new(py, syn),
-            )
-        })
-        .collect()
-}
-
-fn build_single_regex_wrapper(
-    py: Python,
-    kind: PyObject,
-    pat: PyObject,
-    globsuffix: PyObject,
-) -> PyResult<PyBytes> {
-    match build_single_regex(
-        kind.extract::<PyBytes>(py)?.data(py),
-        pat.extract::<PyBytes>(py)?.data(py),
-        globsuffix.extract::<PyBytes>(py)?.data(py),
-    ) {
-        Ok(regex) => Ok(PyBytes::new(py, &regex)),
-        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: PyObject,
-                pat: PyObject,
-                globsuffix: PyObject
-            )
-        ),
-    )?;
-    m.add(
-        py,
-        "read_pattern_file",
-        py_fn!(
-            py,
-            read_pattern_file_wrapper(
-                file_path: PyObject,
-                warn: bool,
-                source_info: bool
-            )
-        ),
-    )?;
-    m.add(py, "PatternError", py.get_type::<PatternError>())?;
-    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)
-}
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
@@ -13,7 +13,7 @@
 //!
 //! [`GraphError`]: struct.GraphError.html
 use cpython::{
-    exc::{IOError, RuntimeError, ValueError},
+    exc::{RuntimeError, ValueError},
     py_exception, PyErr, Python,
 };
 use hg;
@@ -39,34 +39,6 @@
     }
 }
 
-py_exception!(rustext, PatternError, RuntimeError);
-py_exception!(rustext, PatternFileError, RuntimeError);
 py_exception!(rustext, HgPathPyError, 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::<IOError, _>(py, value)
-            }
-            hg::PatternFileError::Pattern(e, l) => match e {
-                hg::PatternError::UnsupportedSyntax(m) => {
-                    PatternFileError::new(py, ("PatternFileError", m, l))
-                }
-            },
-        }
-    }
-}
-
 py_exception!(shared_ref, AlreadyBorrowed, RuntimeError);
diff --git a/mercurial/match.py b/mercurial/match.py
--- a/mercurial/match.py
+++ b/mercurial/match.py
@@ -24,7 +24,7 @@
 )
 from .utils import stringutil
 
-rustmod = policy.importrust('filepatterns')
+rustmod = policy.importrust('dirstate')
 
 allpatternkinds = (
     b're',
@@ -1273,15 +1273,6 @@
     '''Convert a (normalized) pattern of any kind into a
     regular expression.
     globsuffix is appended to the regexp of globs.'''
-
-    if rustmod is not None:
-        try:
-            return rustmod.build_single_regex(kind, pat, globsuffix)
-        except rustmod.PatternError:
-            raise error.ProgrammingError(
-                b'not a regex pattern: %s:%s' % (kind, pat)
-            )
-
     if not pat and kind in (b'glob', b'relpath'):
         return b''
     if kind == b're':
@@ -1554,18 +1545,6 @@
     This is useful to debug ignore patterns.
     '''
 
-    if rustmod is not None:
-        result, warnings = rustmod.read_pattern_file(
-            filepath, bool(warn), sourceinfo,
-        )
-
-        for warning_params in warnings:
-            # Can't be easily emitted from Rust, because it would require
-            # a mechanism for both gettext and calling the `warn` function.
-            warn(_(b"%s: ignoring invalid syntax '%s'\n") % warning_params)
-
-        return result
-
     syntaxes = {
         b're': b'relre:',
         b'regexp': b'relre:',



To: Alphare, #hg-reviewers
Cc: durin42, kevincox, mjpieters, mercurial-devel


More information about the Mercurial-devel mailing list