gitignore_parser: Collect logic matching many rules into match_rules()

This replace the last half of parse_gitignore_lines() with a dedicated
function for applying a list of matching rules to a single path. Also,
take over the call from DirectoryTraversal._do_ignore() which had
duplicated this logic.

fawltydeps/dir_traversal.py

@@ -17,7 +17,7 @@
     TypeVar,
 )
 
-from fawltydeps.gitignore_parser import IgnoreRule
+from fawltydeps.gitignore_parser import IgnoreRule, match_rules
 from fawltydeps.utils import dirs_between
 
 T = TypeVar("T")
@@ -149,15 +149,7 @@ def ignore(self, pattern: str, base_dir: Optional[Path] = None) -> None:
 
     def _do_ignore(self, path: Path, is_dir: bool) -> bool:
         """Check if given path is ignored by any of our ignore rules."""
-        abs_path = path.resolve()
-        for rule in reversed(self.ignore_rules):
-            try:
-                if rule.match(abs_path, is_dir):
-                    logger.debug(f"    ignore rule {rule!r} matches {abs_path}")
-                    return not rule.negated
-            except ValueError:  # abs_path not relative to rule.base_path
-                pass
-        return False
+        return match_rules(self.ignore_rules, path.resolve(), is_dir)
 
     def traverse(self) -> Iterator[TraversalStep[T]]:
         """Perform the traversal of the added directories.

fawltydeps/gitignore_parser.py

@@ -1,11 +1,21 @@
 """A spec-compliant gitignore parser for Python."""
 
+import functools
 import logging
 import os
 import re
 import sys
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, Dict, Iterable, NamedTuple, Optional, Tuple
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+)
 
 from fawltydeps.types import Location
 
@@ -76,22 +86,15 @@ def parse_gitignore_lines(
             # Blank lines and comments are ok when parsing multiple lines
             logger.debug(str(exc))
 
-    if not any(r.negated for r in rules):
+    return functools.partial(match_rules, rules)
 
-        def handle_straightforward(file_path: Path, is_dir: bool) -> bool:
-            return any(r.match(file_path, is_dir) for r in rules)
 
-        return handle_straightforward
-
-    # We have negation rules. We can't use a simple "any" to evaluate them.
-    # Later rules override earlier rules.
-    def handle_negation(file_path: Path, is_dir: bool) -> bool:
-        for rule in reversed(rules):
-            if rule.match(file_path, is_dir):
-                return not rule.negated
-        return False
-
-    return handle_negation
+def match_rules(rules: List["IgnoreRule"], path: Path, is_dir: bool) -> bool:
+    """Match the given path against the given list of rules."""
+    for rule in reversed(rules):
+        if rule.match(path, is_dir):
+            return not rule.negated
+    return False
 
 
 class IgnoreRule(NamedTuple):