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))

[YarikTH]

My compact implementation using functools.cache. Done today and not fully tested, but can also be used as a base. (caution - input must be normalized path to directory. Otherwise it fails with infinite recursion)

@cache
def parse_gitignore_recursive(dir_path: str):
    current_gitignore_path = os.path.join(dir_path, '.gitignore')
    parent_dir = os.path.normpath(os.path.join(dir_path, os.pardir))

    current_matches = None
    if os.path.exists(current_gitignore_path):
        current_matches = parse_gitignore(current_gitignore_path)

    if (parent_dir == dir_path):
        if current_matches is not None:
            return current_matches
        else:
            return lambda file_path: False
    else:
        parent_matches = parse_gitignore_recursive(parent_dir)
        if current_matches is not None:
            return lambda file_path: parent_matches(file_path) or current_matches(file_path)
        else:
            return parent_matches

This feature is highly wanted, because a single .gitignore is rarely enough and as a result all users have to invent own versions.

[mherrmann]

Thanks, feel free to create a PR that adds this functionality (along with some tests) 👍