comparison rust/hg-cpython/src/dirstate/status.rs @ 49346:75119bbee3d1

hg-cpython: refactor matcher transformation logic

This reduces duplication and will allow for recursive transformation in
UnionMatcher.

49345:137d6bb71937

use cpython::{
    exc::ValueError, ObjectProtocol, PyBytes, PyErr, PyList, PyObject,
    PyResult, PyTuple, Python, PythonObject, ToPyObject,
};
use hg::dirstate::status::StatusPath;
use hg::{
    matchers::{AlwaysMatcher, FileMatcher, IncludeMatcher},
    parse_pattern_syntax,
    utils::{
        files::{get_bytes_from_path, get_path_from_bytes},

        let (status_res, warnings) =
            res.map_err(|e| handle_fallback(py, e))?;
        build_response(py, status_res, warnings)
    };

    match matcher.get_type(py).name(py).borrow() {
        "alwaysmatcher" => {
            let matcher = AlwaysMatcher;
            dmap.with_status(
                &matcher,
                root_dir.to_path_buf(),
                ignore_files,
                StatusOptions {
                    check_exec,
                    list_clean,
                    list_ignored,
                    list_unknown,
                    list_copies,
                    collect_traversed_dirs,
                },
                after_status,
            )
        }
        "exactmatcher" => {
            let files = matcher.call_method(
                py,
                "files",
                PyTuple::new(py, &[]),

                    ))
                })
                .collect();

            let files = files?;
            let matcher = FileMatcher::new(files)
                .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
            dmap.with_status(
                &matcher,
                root_dir.to_path_buf(),
                ignore_files,
                StatusOptions {
                    check_exec,
                    list_clean,
                    list_ignored,
                    list_unknown,
                    list_copies,
                    collect_traversed_dirs,
                },
                after_status,
            )
        }
        "includematcher" => {
            // Get the patterns from Python even though most of them are
            // redundant with those we will parse later on, as they include
            // those passed from the command line.

            let ignore_patterns = ignore_patterns?;

            let matcher = IncludeMatcher::new(ignore_patterns)
                .map_err(|e| handle_fallback(py, e.into()))?;

            dmap.with_status(
                &matcher,
                root_dir.to_path_buf(),
                ignore_files,
                StatusOptions {
                    check_exec,
                    list_clean,
                    list_ignored,
                    list_unknown,
                    list_copies,
                    collect_traversed_dirs,
                },
                after_status,
            )
        }
        e => Err(PyErr::new::<FallbackError, _>(
            py,
            format!("Unsupported matcher {}", e),
        )),

49346:75119bbee3d1

use cpython::{
    exc::ValueError, ObjectProtocol, PyBytes, PyErr, PyList, PyObject,
    PyResult, PyTuple, Python, PythonObject, ToPyObject,
};
use hg::dirstate::status::StatusPath;
use hg::matchers::Matcher;
use hg::{
    matchers::{AlwaysMatcher, FileMatcher, IncludeMatcher},
    parse_pattern_syntax,
    utils::{
        files::{get_bytes_from_path, get_path_from_bytes},

        let (status_res, warnings) =
            res.map_err(|e| handle_fallback(py, e))?;
        build_response(py, status_res, warnings)
    };

    let matcher = extract_matcher(py, matcher)?;
    dmap.with_status(
        &*matcher,
        root_dir.to_path_buf(),
        ignore_files,
        StatusOptions {
            check_exec,
            list_clean,
            list_ignored,
            list_unknown,
            list_copies,
            collect_traversed_dirs,
        },
        after_status,
    )
}

/// Transform a Python matcher into a Rust matcher.
fn extract_matcher(
    py: Python,
    matcher: PyObject,
) -> PyResult<Box<dyn Matcher + Sync>> {
    match matcher.get_type(py).name(py).borrow() {
        "alwaysmatcher" => Ok(Box::new(AlwaysMatcher)),
        "exactmatcher" => {
            let files = matcher.call_method(
                py,
                "files",
                PyTuple::new(py, &[]),

                    ))
                })
                .collect();

            let files = files?;
            let file_matcher = FileMatcher::new(files)
                .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
            Ok(Box::new(file_matcher))
        }
        "includematcher" => {
            // Get the patterns from Python even though most of them are
            // redundant with those we will parse later on, as they include
            // those passed from the command line.

            let ignore_patterns = ignore_patterns?;

            let matcher = IncludeMatcher::new(ignore_patterns)
                .map_err(|e| handle_fallback(py, e.into()))?;

            Ok(Box::new(matcher))
        }
        e => Err(PyErr::new::<FallbackError, _>(
            py,
            format!("Unsupported matcher {}", e),
        )),