Show More
@@ -153,6 +153,33 b' pub fn status_wrapper(' | |||
|
153 | 153 | ) |
|
154 | 154 | } |
|
155 | 155 | |
|
156 | fn collect_kindpats( | |
|
157 | py: Python, | |
|
158 | matcher: PyObject, | |
|
159 | ) -> PyResult<Vec<IgnorePattern>> { | |
|
160 | matcher | |
|
161 | .getattr(py, "_kindpats")? | |
|
162 | .iter(py)? | |
|
163 | .map(|k| { | |
|
164 | let k = k?; | |
|
165 | let syntax = parse_pattern_syntax( | |
|
166 | &[ | |
|
167 | k.get_item(py, 0)?.extract::<PyBytes>(py)?.data(py), | |
|
168 | &b":"[..], | |
|
169 | ] | |
|
170 | .concat(), | |
|
171 | ) | |
|
172 | .map_err(|e| handle_fallback(py, StatusError::Pattern(e)))?; | |
|
173 | let pattern = k.get_item(py, 1)?.extract::<PyBytes>(py)?; | |
|
174 | let pattern = pattern.data(py); | |
|
175 | let source = k.get_item(py, 2)?.extract::<PyBytes>(py)?; | |
|
176 | let source = get_path_from_bytes(source.data(py)); | |
|
177 | let new = IgnorePattern::new(syntax, pattern, source); | |
|
178 | Ok(new) | |
|
179 | }) | |
|
180 | .collect() | |
|
181 | } | |
|
182 | ||
|
156 | 183 | /// Transform a Python matcher into a Rust matcher. |
|
157 | 184 | fn extract_matcher( |
|
158 | 185 | py: Python, |
@@ -199,33 +226,7 b' fn extract_matcher(' | |||
|
199 | 226 | // Get the patterns from Python even though most of them are |
|
200 | 227 | // redundant with those we will parse later on, as they include |
|
201 | 228 | // those passed from the command line. |
|
202 |
let ignore_patterns |
|
|
203 | .getattr(py, "_kindpats")? | |
|
204 | .iter(py)? | |
|
205 | .map(|k| { | |
|
206 | let k = k?; | |
|
207 | let syntax = parse_pattern_syntax( | |
|
208 | &[ | |
|
209 | k.get_item(py, 0)? | |
|
210 | .extract::<PyBytes>(py)? | |
|
211 | .data(py), | |
|
212 | &b":"[..], | |
|
213 | ] | |
|
214 | .concat(), | |
|
215 | ) | |
|
216 | .map_err(|e| { | |
|
217 | handle_fallback(py, StatusError::Pattern(e)) | |
|
218 | })?; | |
|
219 | let pattern = k.get_item(py, 1)?.extract::<PyBytes>(py)?; | |
|
220 | let pattern = pattern.data(py); | |
|
221 | let source = k.get_item(py, 2)?.extract::<PyBytes>(py)?; | |
|
222 | let source = get_path_from_bytes(source.data(py)); | |
|
223 | let new = IgnorePattern::new(syntax, pattern, source); | |
|
224 | Ok(new) | |
|
225 | }) | |
|
226 | .collect(); | |
|
227 | ||
|
228 | let ignore_patterns = ignore_patterns?; | |
|
229 | let ignore_patterns = collect_kindpats(py, matcher)?; | |
|
229 | 230 | |
|
230 | 231 | let matcher = IncludeMatcher::new(ignore_patterns) |
|
231 | 232 | .map_err(|e| handle_fallback(py, e.into()))?; |
@@ -254,33 +255,9 b' fn extract_matcher(' | |||
|
254 | 255 | Ok(Box::new(DifferenceMatcher::new(m1, m2))) |
|
255 | 256 | } |
|
256 | 257 | "patternmatcher" => { |
|
257 |
let |
|
|
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<_>>>()?; | |
|
258 | let patterns = collect_kindpats(py, matcher)?; | |
|
282 | 259 | |
|
283 |
let matcher = PatternMatcher::new( |
|
|
260 | let matcher = PatternMatcher::new(patterns) | |
|
284 | 261 | .map_err(|e| handle_fallback(py, e.into()))?; |
|
285 | 262 | |
|
286 | 263 | Ok(Box::new(matcher)) |
General Comments 0
You need to be logged in to leave comments.
Login now