Nested .gitignores

[kpwelsh]

It would be great if this library had support for layering .gitignores to handle cases like the following:

package/
  .gitignore
  my_package/
    resources/
      .gitignore

I was working with a repo that has, a perhaps ill advised, gitignore like the following:

Root:

*.rst

Somewhere deep in the library:

!*

This was used to make a special folder of .rsts that would be included in the repo. I was naively ignoring on match any of the relevant .gitignores, but it seems like I would have to actually consider the exclusions / un-exclusions on the rule level and combine them there to handle something like this.

[notable-equivalent]

To add to this discussion, this is what I ended up with to match against nested .gitignores. It seems to work for my purposes, but I haven't exhaustively tested it.

def parents_up_to(path: Path, root_dir: Path):
    path = Path(os.path.abspath(path))
    root_dir = Path(os.path.abspath(root_dir))

    while True:
        yield path

        if path == root_dir:
            # We just finished processing the root directory we set, so break now
            break

        new_path = path.parent
        if new_path == path:
            # We have reached the root of the filesystem without hitting root_dir. Something is wrong
            raise RuntimeError(
                "Error: Reached the root of the filesystem when looking for "
                + "ignore files. Is root_dir not a base of path? "
                + "{path = }, {root_dir = }"
            )

        path = new_path


@functools.lru_cache(None)
def _ignore_file_to_rules_cached(ignore_file_abspath: Path) -> "list[gitignore_parser.IgnoreRule]":
    base_dir = ignore_file_abspath.parent

    rules = []
    for line_no, line in enumerate(ignore_file_abspath.read_text().splitlines(), start=1):
        rule = gitignore_parser.rule_from_pattern(
            line.rstrip("\n"), base_path=base_dir, source=(ignore_file_abspath, line_no)
        )
        if rule:
            rules.append(rule)

    return rules


def ignore_file_to_rules(ignore_file_path: Path) -> "list[gitignore_parser.IgnoreRule]":
    return _ignore_file_to_rules_cached(Path(os.path.abspath(ignore_file_path)))


def find_ignores_for(file_path: Path, root_dir: Path) -> "list[Path]":
    file_path = Path(os.path.abspath(file_path))
    root_dir = Path(os.path.abspath(root_dir))

    IGNORE_FILENAME = ".gitignore"

    ignore_files = [
        dir / IGNORE_FILENAME
        for dir in parents_up_to(file_path.parent, root_dir)
        if (dir / IGNORE_FILENAME).exists()
    ]
    ignore_files.reverse()
    return ignore_files


def match_rules_against(file_path: Path, rules: Reversible[gitignore_parser.IgnoreRule]):
    for rule in reversed(rules):
        is_relative_to = rule.base_path == file_path or rule.base_path in file_path.parents
        if is_relative_to and rule.match(file_path):
            return not rule.negation
    return False


def should_ignore_file(file_path: Path, root_dir: Path) -> bool:
    file_path = Path(os.path.abspath(file_path))
    root_dir = Path(os.path.abspath(root_dir))

    ignore_files = find_ignores_for(file_path, root_dir)
    rules = list(itertools.chain.from_iterable(ignore_file_to_rules(f) for f in ignore_files))

    return any(match_rules_against(p, rules) for p in parents_up_to(file_path, root_dir))