如何离线测试GitHub CODEOWNERS文件的规则匹配与优先级？

可以在不创建GitHub PR或部署变更的前提下，离线解析CODEOWNERS文件，确定指定文件对应的审批所有者。以下是两种可行方案：

一、使用现成工具 #

推荐使用codeowners CLI工具，它完全模拟GitHub的CODEOWNERS匹配规则，支持离线测试：

1. 安装工具（需Go环境）：

go install github.com/mszostok/codeowners@latest

2. 测试指定文件：

codeowners check file1 file2 file3

该工具会输出每个文件匹配到的所有者，同时支持验证CODEOWNERS文件的语法正确性，比自定义脚本更可靠。

二、修正后的自定义Python脚本 #

你提到的原Python脚本存在两个核心问题：一是fnmatch的匹配逻辑与GitHub规则不完全一致，二是未正确处理规则优先级（GitHub优先选择最具体的规则，而非仅按顺序取最后匹配的规则）。以下是修正后的版本：

import os
from pathlib import Path

def parse_codeowners(codeowners_path):
    rules = []
    with open(codeowners_path, 'r') as f:
        for line_num, line in enumerate(f, 1):
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            parts = line.split(maxsplit=1)
            if len(parts) < 2:
                print(f"警告：第{line_num}行格式无效，已跳过")
                continue
            pattern, owners_str = parts
            owners = owners_str.split()
            rules.append({
                'pattern': pattern,
                'owners': owners,
                'line': line_num
            })
    return rules

def calculate_specificity(pattern):
    # 计算规则的具体程度，值越高优先级越高
    specificity = 0
    # 不含通配符的精确路径优先级最高
    if '*' not in pattern and '**' not in pattern:
        specificity += 100
    # 路径分段数越多越具体
    segments = pattern.rstrip('/').split('/')
    specificity += len(segments) * 10
    # 根路径开头的规则加权重
    if pattern.startswith('/'):
        specificity += 5
    # 目录规则（以/结尾）权重略低
    if pattern.endswith('/'):
        specificity -= 2
    # 通配符越少越具体
    wildcard_count = pattern.count('*')
    specificity -= wildcard_count * 3
    return specificity

def matches_pattern(file_path, pattern):
    # 模拟GitHub的CODEOWNERS匹配逻辑
    file_path = Path(file_path).as_posix()
    pattern = pattern.rstrip('/')

    # 处理根路径开头的模式：仅匹配仓库根目录下的对应内容
    if pattern.startswith('/'):
        pattern = pattern[1:]
        return file_path == pattern or file_path.startswith(f"{pattern}/")
    # 处理**递归匹配
    if '**' in pattern:
        parts = pattern.split('**')
        prefix = parts[0]
        suffix = parts[1] if len(parts) > 1 else ''
        if prefix and not file_path.startswith(prefix):
            return False
        if suffix and not file_path.endswith(suffix):
            return False
        return True
    # 处理*单级匹配：仅匹配当前目录下的文件/目录
    if '*' in pattern:
        pattern_segments = pattern.split('/')
        file_segments = file_path.split('/')
        if len(pattern_segments) != len(file_segments):
            return False
        import fnmatch
        for p_seg, f_seg in zip(pattern_segments, file_segments):
            if not fnmatch.fnmatch(f_seg, p_seg):
                return False
        return True
    # 精确匹配文件或目录下的所有内容
    return file_path == pattern or file_path.startswith(f"{pattern}/")

def find_owners(rules, file_path):
    matching_rules = []
    for rule in rules:
        if matches_pattern(file_path, rule['pattern']):
            matching_rules.append(rule)
    if not matching_rules:
        return []
    # 按优先级排序：具体程度高的优先，相同则取文件中靠后的规则（行号大的）
    matching_rules.sort(key=lambda r: (-calculate_specificity(r['pattern']), r['line']))
    return matching_rules[0]['owners']

if __name__ == '__main__':
    # 加载CODEOWNERS文件
    codeowners_file = 'CODEOWNERS'
    if not os.path.exists(codeowners_file):
        print(f"错误：未找到文件 {codeowners_file}")
        exit(1)
    rules = parse_codeowners(codeowners_file)
    # 测试文件
    test_files = ['file1', 'file2', 'file3']
    for test_file in test_files:
        owners = find_owners(rules, test_file)
        print(f"文件: {test_file}, 所有者: {', '.join(owners) if owners else '无'}")

原脚本的问题说明： #

1. 匹配逻辑差异：fnmatch的*会匹配任意字符包括/，但GitHub的*仅匹配单级目录下的字符，**才会递归匹配子目录，原脚本未区分这一点。
2. 优先级错误：原脚本仅按规则顺序取最后一个匹配项，但GitHub会优先选择最具体的规则（比如src/file.go比src/**优先级高），若规则具体程度相同，才会取文件中靠后的规则。

内容的提问来源于stack exchange，提问作者sashoalm