rust-filepatterns: remove bridge code for filepatterns-related functions
These functions will be used internally by `hg-core` without needed to be
exposed to Python.
Differential Revision: https://phab.mercurial-scm.org/D7868
--- a/mercurial/match.py Tue Jan 14 18:03:28 2020 +0100
+++ b/mercurial/match.py Tue Jan 14 16:58:07 2020 +0100
@@ -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:',
--- a/rust/hg-cpython/src/exceptions.rs Tue Jan 14 18:03:28 2020 +0100
+++ b/rust/hg-cpython/src/exceptions.rs Tue Jan 14 16:58:07 2020 +0100
@@ -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);
--- a/rust/hg-cpython/src/filepatterns.rs Tue Jan 14 18:03:28 2020 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,133 +0,0 @@
-// 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 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, ®ex)),
- 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)
-}
--- a/rust/hg-cpython/src/lib.rs Tue Jan 14 18:03:28 2020 +0100
+++ b/rust/hg-cpython/src/lib.rs Tue Jan 14 16:58:07 2020 +0100
@@ -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(())
});