rust/hg-cpython/src/dirstate/status.rs
changeset 51603 a2afa35641c9
parent 51602 68929cf3c0c6
child 51604 32ba01b5669d
equal deleted inserted replaced
51602:68929cf3c0c6 51603:a2afa35641c9
    15     PyResult, PyTuple, Python, PythonObject, ToPyObject,
    15     PyResult, PyTuple, Python, PythonObject, ToPyObject,
    16 };
    16 };
    17 use hg::dirstate::status::StatusPath;
    17 use hg::dirstate::status::StatusPath;
    18 use hg::matchers::{
    18 use hg::matchers::{
    19     DifferenceMatcher, IntersectionMatcher, Matcher, NeverMatcher,
    19     DifferenceMatcher, IntersectionMatcher, Matcher, NeverMatcher,
    20     UnionMatcher,
    20     PatternMatcher, UnionMatcher,
    21 };
    21 };
    22 use hg::{
    22 use hg::{
    23     matchers::{AlwaysMatcher, FileMatcher, IncludeMatcher},
    23     matchers::{AlwaysMatcher, FileMatcher, IncludeMatcher},
    24     parse_pattern_syntax,
    24     parse_pattern_syntax,
    25     utils::{
    25     utils::{
   250         "differencematcher" => {
   250         "differencematcher" => {
   251             let m1 = extract_matcher(py, matcher.getattr(py, "_m1")?)?;
   251             let m1 = extract_matcher(py, matcher.getattr(py, "_m1")?)?;
   252             let m2 = extract_matcher(py, matcher.getattr(py, "_m2")?)?;
   252             let m2 = extract_matcher(py, matcher.getattr(py, "_m2")?)?;
   253 
   253 
   254             Ok(Box::new(DifferenceMatcher::new(m1, m2)))
   254             Ok(Box::new(DifferenceMatcher::new(m1, m2)))
       
   255         }
       
   256         "patternmatcher" => {
       
   257             let ignore_patterns = matcher
       
   258                 .getattr(py, "_kindpats")?
       
   259                 .iter(py)?
       
   260                 .map(|k| {
       
   261                     let k = k?;
       
   262                     let syntax = parse_pattern_syntax(
       
   263                         &[
       
   264                             k.get_item(py, 0)?
       
   265                                 .extract::<PyBytes>(py)?
       
   266                                 .data(py),
       
   267                             &b":"[..],
       
   268                         ]
       
   269                         .concat(),
       
   270                     )
       
   271                     .map_err(|e| {
       
   272                         handle_fallback(py, StatusError::Pattern(e))
       
   273                     })?;
       
   274                     let pattern = k.get_item(py, 1)?.extract::<PyBytes>(py)?;
       
   275                     let pattern = pattern.data(py);
       
   276                     let source = k.get_item(py, 2)?.extract::<PyBytes>(py)?;
       
   277                     let source = get_path_from_bytes(source.data(py));
       
   278                     let new = IgnorePattern::new(syntax, pattern, source);
       
   279                     Ok(new)
       
   280                 })
       
   281                 .collect::<PyResult<Vec<_>>>()?;
       
   282 
       
   283             let matcher = PatternMatcher::new(ignore_patterns)
       
   284                 .map_err(|e| handle_fallback(py, e.into()))?;
       
   285 
       
   286             Ok(Box::new(matcher))
   255         }
   287         }
   256         e => Err(PyErr::new::<FallbackError, _>(
   288         e => Err(PyErr::new::<FallbackError, _>(
   257             py,
   289             py,
   258             format!("Unsupported matcher {}", e),
   290             format!("Unsupported matcher {}", e),
   259         )),
   291         )),