validate_codeowners.py

#!/usr/bin/env python3

if __name__ != "__main__":
    raise SystemExit(f'Utility script "{__file__}" should not be used as a module!')

import argparse
import re
import subprocess
import sys

sys.path.insert(0, "./")

try:
    from methods import print_error, print_info
except ImportError:
    raise SystemExit(f"Utility script {__file__} must be run from repository root!")


def glob_to_regex(glob: str) -> re.Pattern[str]:
    """Convert a CODEOWNERS glob to a RegEx pattern."""

    # Heavily inspired by: https://github.com/hmarr/codeowners/blob/main/match.go

    # Handle specific edgecases first.
    if "***" in glob:
        raise SyntaxError("Pattern cannot contain three consecutive asterisks")
    if glob == "/":
        raise SyntaxError('Standalone "/" will not match anything')
    if not glob:
        raise ValueError("Empty pattern")

    segments = glob.split("/")
    if not segments[0]:
        # Leading slash; relative to root.
        segments = segments[1:]
    else:
        # Check for single-segment pattern, which matches relative to any descendent path.
        #  This is equivalent to a leading `**/`.
        if len(segments) == 1 or (len(segments) == 2 and not segments[1]):
            if segments[0] != "**":
                segments.insert(0, "**")

    if len(segments) > 1 and not segments[-1]:
        # A trailing slash is equivalent to `/**`.
        segments[-1] = "**"

    last_index = len(segments) - 1
    need_slash = False
    pattern = r"\A"

    for index, segment in enumerate(segments):
        if segment == "**":
            if index == 0 and index == last_index:
                pattern += r".+"  # Pattern is just `**`; match everything.
            elif index == 0:
                pattern += r"(?:.+/)?"  # Pattern starts with `**`; match any leading path segment.
                need_slash = False
            elif index == last_index:
                pattern += r"/.*"  # Pattern ends with `**`; match any trailing path segment.
            else:
                pattern += r"(?:/.+)?"  # Pattern contains `**`; match zero or more path segments.
                need_slash = True

        elif segment == "*":
            if need_slash:
                pattern += "/"
            # Regular wildcard; match any non-separator characters.
            pattern += r"[^/]+"
            need_slash = True

        else:
            if need_slash:
                pattern += "/"

            escape = False
            for char in segment:
                if escape:
                    escape = False
                    pattern += re.escape(char)
                    continue
                elif char == "\\":
                    escape = True
                elif char == "*":
                    # Multi-character wildcard.
                    pattern += r"[^/]*"
                elif char == "?":
                    # Single-character wildcard.
                    pattern += r"[^/]"
                else:
                    # Regular character
                    pattern += re.escape(char)

            if index == last_index:
                pattern += r"(?:/.*)?"  # No trailing slash; match descendent paths.
            need_slash = True

    pattern += r"\Z"
    return re.compile(pattern)


RE_CODEOWNERS = re.compile(r"^(?P<code>[^#](?:\\ |[^\s])+) +(?P<owners>(?:[^#][^\s]+ ?)+)")


def parse_codeowners() -> list[tuple[re.Pattern[str], list[str]]]:
    codeowners = []
    with open(".github/CODEOWNERS", encoding="utf-8", newline="\n") as file:
        for line in reversed(file.readlines()):  # Lower items have higher precedence.
            if match := RE_CODEOWNERS.match(line):
                codeowners.append((glob_to_regex(match["code"]), match["owners"].split()))
    return codeowners


def main() -> int:
    parser = argparse.ArgumentParser(description="Utility script for validating CODEOWNERS assignment.")
    parser.add_argument("files", nargs="*", help="A list of files to validate. If excluded, checks all owned files.")
    parser.add_argument("-u", "--unowned", action="store_true", help="Only output files without an owner.")
    args = parser.parse_args()

    files: list[str] = args.files
    if not files:
        files = subprocess.run(["git", "ls-files"], text=True, capture_output=True).stdout.splitlines()

    ret = 0
    codeowners = parse_codeowners()

    for file in files:
        matched = False
        for code, owners in codeowners:
            if code.match(file):
                matched = True
                if not args.unowned:
                    print_info(f"{file}: {owners}")
                break
        if not matched:
            print_error(f"{file}: <UNOWNED>")
            ret += 1

    return ret


try:
    raise SystemExit(main())
except KeyboardInterrupt:
    import os
    import signal

    signal.signal(signal.SIGINT, signal.SIG_DFL)
    os.kill(os.getpid(), signal.SIGINT)