mirror of
https://github.com/esphome/esphome.git
synced 2026-07-10 17:05:36 +00:00
J. Nick Koston
ed63f51fcb
Add a workflow that automatically manages a code-owner-approved label on PRs when component-specific codeowners submit approvals. This helps maintainers prioritize PRs that have domain-expert sign-off. The workflow triggers on pull_request_review events and recalculates the label based on all current reviews. Only individual component codeowners count - the catch-all @esphome/core team is excluded. Uses last-match-wins semantics for CODEOWNERS pattern matching. Also extracts shared CODEOWNERS parsing logic into a reusable module at .github/scripts/codeowners.js and updates codeowner-review-request and auto-label-pr workflows to use it.
125 lines
3.5 KiB
JavaScript
125 lines
3.5 KiB
JavaScript
// Shared CODEOWNERS parsing and matching utilities.
|
||
//
|
||
// Used by:
|
||
// - codeowner-review-request.yml
|
||
// - codeowner-approved-label.yml
|
||
// - auto-label-pr/detectors.js (detectCodeOwner)
|
||
|
||
/**
|
||
* Convert a CODEOWNERS glob pattern to a RegExp.
|
||
*
|
||
* Handles **, *, and ? wildcards after escaping regex-special characters.
|
||
*/
|
||
function globToRegex(pattern) {
|
||
let regexStr = pattern
|
||
.replace(/([.+^=!:${}()|[\]\\])/g, '\\$1')
|
||
.replace(/\*\*/g, '.*')
|
||
.replace(/\*/g, '[^/]*')
|
||
.replace(/\?/g, '.');
|
||
return new RegExp('^' + regexStr + '$');
|
||
}
|
||
|
||
/**
|
||
* Parse raw CODEOWNERS file content into an array of
|
||
* { pattern, regex, owners } objects.
|
||
*
|
||
* Each `owners` entry is the raw string from the file (e.g. "@user" or
|
||
* "@esphome/core").
|
||
*/
|
||
function parseCodeowners(content) {
|
||
const lines = content
|
||
.split('\n')
|
||
.map(line => line.trim())
|
||
.filter(line => line && !line.startsWith('#'));
|
||
|
||
const patterns = [];
|
||
for (const line of lines) {
|
||
const parts = line.split(/\s+/);
|
||
if (parts.length < 2) continue;
|
||
|
||
const pattern = parts[0];
|
||
const owners = parts.slice(1);
|
||
const regex = globToRegex(pattern);
|
||
patterns.push({ pattern, regex, owners });
|
||
}
|
||
return patterns;
|
||
}
|
||
|
||
/**
|
||
* Fetch and parse the CODEOWNERS file via the GitHub API.
|
||
*
|
||
* @param {object} github - octokit instance from actions/github-script
|
||
* @param {string} owner - repo owner
|
||
* @param {string} repo - repo name
|
||
* @param {string} [ref] - git ref (SHA / branch) to read from
|
||
* @returns {Array<{pattern: string, regex: RegExp, owners: string[]}>}
|
||
*/
|
||
async function fetchCodeowners(github, owner, repo, ref) {
|
||
const params = { owner, repo, path: 'CODEOWNERS' };
|
||
if (ref) params.ref = ref;
|
||
|
||
const { data: file } = await github.rest.repos.getContent(params);
|
||
const content = Buffer.from(file.content, 'base64').toString('utf8');
|
||
return parseCodeowners(content);
|
||
}
|
||
|
||
/**
|
||
* Classify raw owner strings into individual users and teams.
|
||
*
|
||
* @param {string[]} rawOwners - e.g. ["@user1", "@esphome/core"]
|
||
* @returns {{ users: string[], teams: string[] }}
|
||
* users – login names without "@"
|
||
* teams – team slugs without the "org/" prefix
|
||
*/
|
||
function classifyOwners(rawOwners) {
|
||
const users = [];
|
||
const teams = [];
|
||
for (const o of rawOwners) {
|
||
const clean = o.startsWith('@') ? o.slice(1) : o;
|
||
if (clean.includes('/')) {
|
||
teams.push(clean.split('/')[1]);
|
||
} else {
|
||
users.push(clean);
|
||
}
|
||
}
|
||
return { users, teams };
|
||
}
|
||
|
||
/**
|
||
* For each file, find its effective codeowners using GitHub's
|
||
* "last match wins" semantics, then union across all files.
|
||
*
|
||
* @param {string[]} files - list of file paths
|
||
* @param {Array} codeownersPatterns - from parseCodeowners / fetchCodeowners
|
||
* @returns {{ users: Set<string>, teams: Set<string> }}
|
||
*/
|
||
function getEffectiveOwners(files, codeownersPatterns) {
|
||
const users = new Set();
|
||
const teams = new Set();
|
||
|
||
for (const file of files) {
|
||
// Last matching pattern wins for each file
|
||
let effectiveOwners = null;
|
||
for (const { regex, owners } of codeownersPatterns) {
|
||
if (regex.test(file)) {
|
||
effectiveOwners = owners;
|
||
}
|
||
}
|
||
if (effectiveOwners) {
|
||
const classified = classifyOwners(effectiveOwners);
|
||
for (const u of classified.users) users.add(u);
|
||
for (const t of classified.teams) teams.add(t);
|
||
}
|
||
}
|
||
|
||
return { users, teams };
|
||
}
|
||
|
||
module.exports = {
|
||
globToRegex,
|
||
parseCodeowners,
|
||
fetchCodeowners,
|
||
classifyOwners,
|
||
getEffectiveOwners
|
||
};
|