split-by-codeowners 1.0.0 → 1.0.2

package/dist/index.js

@@ -27714,6 +27714,35 @@ exports.parseCodeowners = parseCodeowners;
 exports.ownersForFile = ownersForFile;
 const node_fs_1 = __importDefault(__nccwpck_require__(3024));
 const minimatch_1 = __nccwpck_require__(6507);
+function splitPatternOwners(line) {
+    // CODEOWNERS lines are: <pattern><whitespace><owner>...
+    // Patterns may contain spaces if escaped as `\ `.
+    // We parse by finding the first whitespace not escaped by a backslash.
+    let i = 0;
+    let escaped = false;
+    for (; i < line.length; i++) {
+        const ch = line[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (/\s/.test(ch))
+            break;
+    }
+    const rawPattern = line.slice(0, i).trim();
+    const rest = line.slice(i).trim();
+    if (!rawPattern || !rest)
+        return null;
+    const pattern = rawPattern.replaceAll("\\ ", " ");
+    const owners = rest.split(/\s+/).filter(Boolean);
+    if (!owners.length)
+        return null;
+    return { pattern, owners };
+}
 function parseCodeowners(path) {
     const text = node_fs_1.default.readFileSync(path, "utf8");
     const rules = [];
@@ -27721,18 +27750,60 @@ function parseCodeowners(path) {
         const line = raw.trim();
         if (!line || line.startsWith("#"))
             continue;
-        const parts = line.split(/\s+/).filter(Boolean);
-        if (parts.length < 2)
+        const parsed = splitPatternOwners(line);
+        if (!parsed)
             continue;
-        rules.push({ pattern: parts[0], owners: parts.slice(1) });
+        rules.push({ pattern: parsed.pattern, owners: parsed.owners });
     }
     return rules;
 }
+function hasGlobMagic(p) {
+    // Good-enough heuristic for gitignore-style globs.
+    return /[*?\[]/.test(p);
+}
 function matches(file, pattern) {
-    const f = file.replace(/\\/g, "/");
-    // crude but works for most repos:
-    const pat = pattern.startsWith("/") ? pattern.slice(1) : pattern;
-    return (0, minimatch_1.minimatch)(f, pat, { dot: true, matchBase: !pattern.startsWith("/") });
+    // GitHub CODEOWNERS patterns are gitignore-like:
+    // - Leading `/` anchors to repo root
+    // - Pattern without `/` matches a basename anywhere
+    // - A directory pattern matches everything under it (e.g. `/frontend/admin` should match `/frontend/admin/**`)
+    const f = file.replace(/\\/g, "/").replace(/^\.?\//, "");
+    let pat = pattern.replace(/\\/g, "/").trim();
+    if (!pat)
+        return false;
+    const anchored = pat.startsWith("/");
+    if (anchored)
+        pat = pat.slice(1);
+    // Directory patterns: trailing `/` means directory; also treat non-glob literal paths as directory-or-file match.
+    const trailingSlash = pat.endsWith("/");
+    if (trailingSlash)
+        pat = pat.slice(0, -1);
+    const isLiteral = !hasGlobMagic(pat);
+    const hasSlash = pat.includes("/");
+    // Literal path: match exact file OR directory subtree.
+    if (isLiteral && (anchored || hasSlash)) {
+        return f === pat || f.startsWith(pat + "/");
+    }
+    // Literal basename: match basename OR directory subtree anywhere.
+    if (isLiteral && !hasSlash) {
+        const base = f.split("/").pop() ?? f;
+        if (base === pat)
+            return true;
+        return f.includes("/" + pat + "/");
+    }
+    // Glob patterns: use minimatch.
+    // - If anchored: match from repo root.
+    // - If not anchored and no slash: match basename anywhere.
+    // - If not anchored but includes a slash: match relative to repo root (like a root CODEOWNERS / .gitignore).
+    const matchBase = !anchored && !hasSlash;
+    const mm = (0, minimatch_1.minimatch)(f, pat, { dot: true, matchBase });
+    if (mm)
+        return true;
+    // If the pattern explicitly denotes a directory (trailing slash), also match directory subtree.
+    if (trailingSlash) {
+        // Convert `dir/` to subtree match.
+        return (0, minimatch_1.minimatch)(f, pat + "/**", { dot: true, matchBase: false });
+    }
+    return false;
 }
 function ownersForFile(file, rules) {
     let hit;