cargdev/angular
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

ci: Migrate from CODEOWNERS to PullApprove for PR review management (#34814)

Browse Source 
We are migrating to PullApprove for our PR review management in an attempt
to allow for more granular and equitable code review assignments across the
team.  Currently this migration is equivalent in the review assignments
it will create. Once stable, our expectation is that we will be able to
take advantage of PullApproves additional features for things like staged
reviews.

PR Close #34814
This commit is contained in:
Joey Perrott
2020-01-16 08:39:09 -08:00
parent 7f44fa65a7
commit 296dc0622f
7 changed files with 1020 additions and 1185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
tools/verify-codeownership.js
View File

@ -1,199 +0,0 @@
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* **Usage:**
* ```
* node tools/verify-codeownership
* ```
*
* Verify whether there are directories in the codebase that don't have a codeowner (in
* `.github/CODEOWNERS`) and vice versa (that there are no patterns in `CODEOWNERS` that do not
* correspond to actual directories).
*
* The script does not aim to be exhaustive and highly accurate, checking all files and directories
* (since that would be too complicated). Instead, it does a coarse check on some important (or
* frequently changing) directories.
*
* Currently, it checks the following:
* - **Packages**: Top-level directories in `packages/`.
* - **API docs examples**: Top-level directories in `packages/examples/`.
* - **Guides**: Top-level files in `aio/content/guide/`.
* - **Guide images**: Top-level directories in `aio/content/images/guide/`.
* - **Guide examples**: Top-level directories in `aio/content/examples/`.
*/
'use strict';
// Imports
const chalk = require('chalk');
const fs = require('fs');
const path = require('path');
// Constants
const PROJECT_ROOT_DIR = path.resolve(__dirname, '..');
const CODEOWNERS_PATH = path.resolve(PROJECT_ROOT_DIR, '.github/CODEOWNERS');
const PKG_DIR = path.resolve(PROJECT_ROOT_DIR, 'packages');
const PKG_EXAMPLES_DIR = path.resolve(PKG_DIR, 'examples');
const AIO_CONTENT_DIR = path.resolve(PROJECT_ROOT_DIR, 'aio/content');
const AIO_GUIDES_DIR = path.resolve(AIO_CONTENT_DIR, 'guide');
const AIO_GUIDE_IMAGES_DIR = path.resolve(AIO_CONTENT_DIR, 'images/guide');
const AIO_GUIDE_EXAMPLES_DIR = path.resolve(AIO_CONTENT_DIR, 'examples');
const IGNORED_PKG_DIRS = new Set([
// Examples are checked separately.
'examples',
]);
// Run
_main();
// Functions - Definitions
function _main() {
const {packages: pkgPackagePaths, examples: pkgExamplePaths} = getPathsFromPkg();
const {
guides: aioGuidePaths,
images: aioGuideImagesPaths,
examples: aioExamplePaths,
} = getPathsFromAioContent();
const {
pkgPackages: coPkgPackagePaths,
pkgExamples: coPkgExamplePaths,
aioGuides: coAioGuidePaths,
aioImages: coAioGuideImagesPaths,
aioExamples: coAioExamplePaths,
} = getPathsFromCodeowners();
const pkgPackagesDiff = arrayDiff(pkgPackagePaths, coPkgPackagePaths);
const pkgExamplesDiff = arrayDiff(pkgExamplePaths, coPkgExamplePaths);
const aioGuidesDiff = arrayDiff(aioGuidePaths, coAioGuidePaths);
const aioImagesDiff = arrayDiff(aioGuideImagesPaths, coAioGuideImagesPaths);
const aioExamplesDiff = arrayDiff(aioExamplePaths, coAioExamplePaths);
const hasDiff = (pkgPackagesDiff.diffCount > 0) || (pkgExamplesDiff.diffCount > 0) ||
(aioGuidesDiff.diffCount > 0) || (aioImagesDiff.diffCount > 0) ||
(aioExamplesDiff.diffCount > 0);
if (hasDiff) {
const expectedPkgPackagesSrc = path.relative(PROJECT_ROOT_DIR, PKG_DIR);
const expectedPkgExamplesSrc = path.relative(PROJECT_ROOT_DIR, PKG_EXAMPLES_DIR);
const expectedAioGuidesSrc = path.relative(PROJECT_ROOT_DIR, AIO_GUIDES_DIR);
const expectedAioImagesSrc = path.relative(PROJECT_ROOT_DIR, AIO_GUIDE_IMAGES_DIR);
const expectedAioExamplesSrc = path.relative(PROJECT_ROOT_DIR, AIO_GUIDE_EXAMPLES_DIR);
const actualSrc = path.relative(PROJECT_ROOT_DIR, CODEOWNERS_PATH);
reportDiff(pkgPackagesDiff, expectedPkgPackagesSrc, actualSrc);
reportDiff(pkgExamplesDiff, expectedPkgExamplesSrc, actualSrc);
reportDiff(aioGuidesDiff, expectedAioGuidesSrc, actualSrc);
reportDiff(aioImagesDiff, expectedAioImagesSrc, actualSrc);
reportDiff(aioExamplesDiff, expectedAioExamplesSrc, actualSrc);
// tslint:disable-next-line: no-console
console.log(chalk.red(
'\nCode-ownership verification failed.\n' +
'Please update \'.github/CODEOWNERS\' to ensure that all necessary files/directories ' +
'have code-owners and all patterns that appear in the file correspond to actual ' +
'files/directories in the repo.'));
} else {
// tslint:disable-next-line: no-console
console.log(chalk.green('\nCode-ownership verification succeeded!'));
}
process.exit(hasDiff ? 1 : 0);
}
function arrayDiff(expected, actual) {
const missing = expected.filter(x => !actual.includes(x)).sort();
const extra = actual.filter(x => !expected.includes(x)).sort();
return {missing, extra, diffCount: missing.length + extra.length};
}
function findDirectories(parentDir) {
return fs.readdirSync(parentDir).filter(
name => fs.statSync(`${parentDir}/${name}`).isDirectory());
}
function getPathsFromAioContent() {
return {
guides: fs.readdirSync(AIO_GUIDES_DIR),
images: fs.readdirSync(AIO_GUIDE_IMAGES_DIR),
examples: fs.readdirSync(AIO_GUIDE_EXAMPLES_DIR)
.filter(name => fs.statSync(`${AIO_GUIDE_EXAMPLES_DIR}/${name}`).isDirectory()),
};
}
function getPathsFromCodeowners() {
const pkgPackagesPathRe = /^\/packages\/([^\s\*/]+)\/\*?\*\s/;
const pkgExamplesPathRe = /^\/packages\/examples\/([^\s\*/]+)/;
// Use capturing groups for `images/` and `examples` to be able to differentiate between the
// different kinds of matches (guide, image, example) later (see `isImage`/`isExample` below).
const aioGuidesImagesExamplesPathRe =
/^\/aio\/content\/(?:(images\/)?guide|(examples))\/([^\s\*/]+)/;
const manualGlobExpansions = {
// `CODEOWNERS` has a glob to match all `testing/` directories, so no specific glob for
// `packages/examples/testing/` is necessary.
'testing/**': ['/packages/examples/testing/**'],
};
const pkgPackages = [];
const pkgExamples = [];
const aioGuides = [];
const aioImages = [];
const aioExamples = [];
// Read `CODEOWNERS` and split into lines.
const lines = fs.readFileSync(CODEOWNERS_PATH, 'utf8').split('\n').map(l => l.trim());
// Manually expand globs to known matching patterns.
for (const [glob, expansions] of Object.entries(manualGlobExpansions)) {
const matchingLine = lines.find(l => l.startsWith(`${glob} `));
if (matchingLine !== undefined) {
lines.push(...expansions);
}
}
// Collect packages (`packages/`).
lines.map(l => l.match(pkgPackagesPathRe)).filter(m => m).forEach(([
, path
]) => pkgPackages.push(path));
// Collect API docs examples (`packages/examples/`).
lines.map(l => l.match(pkgExamplesPathRe)).filter(m => m).forEach(([
, path
]) => pkgExamples.push(path));
// Collect `aio/` guides/images/examples.
lines.map(l => l.match(aioGuidesImagesExamplesPathRe))
.filter(m => m)
.forEach(([, isImage, isExample, path]) => {
const list = isExample ? aioExamples : isImage ? aioImages : aioGuides;
list.push(path);
});
return {pkgPackages, pkgExamples, aioGuides, aioImages, aioExamples};
}
function getPathsFromPkg() {
return {
packages: findDirectories(PKG_DIR).filter(name => !IGNORED_PKG_DIRS.has(name)),
examples: findDirectories(PKG_EXAMPLES_DIR),
};
}
function reportDiff(diff, expectedSrc, actualSrc) {
if (diff.missing.length) {
console.error(
`\nEntries in '${expectedSrc}' but not in '${actualSrc}':\n` +
diff.missing.map(x => ` - ${x}`).join('\n'));
}
if (diff.extra.length) {
console.error(
`\nEntries in '${actualSrc}' but not in '${expectedSrc}':\n` +
diff.extra.map(x => ` - ${x}`).join('\n'));
}
}