133 lines
4.4 KiB
TypeScript
133 lines
4.4 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google LLC 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
|
|
*/
|
|
|
|
import {error} from '../utils/console';
|
|
import {convertConditionToFunction} from './condition_evaluator';
|
|
import {PullApproveGroupConfig} from './parse-yaml';
|
|
import {PullApproveGroupStateDependencyError} from './pullapprove_arrays';
|
|
|
|
/** A condition for a group. */
|
|
interface GroupCondition {
|
|
expression: string;
|
|
checkFn: (files: string[], groups: PullApproveGroup[]) => boolean;
|
|
matchedFiles: Set<string>;
|
|
unverifiable: boolean;
|
|
}
|
|
|
|
interface GroupReviewers {
|
|
users?: string[];
|
|
teams?: string[];
|
|
}
|
|
|
|
/** Result of testing files against the group. */
|
|
export interface PullApproveGroupResult {
|
|
groupName: string;
|
|
matchedConditions: GroupCondition[];
|
|
matchedCount: number;
|
|
unmatchedConditions: GroupCondition[];
|
|
unmatchedCount: number;
|
|
unverifiableConditions: GroupCondition[];
|
|
}
|
|
|
|
// Regular expression that matches conditions for the global approval.
|
|
const GLOBAL_APPROVAL_CONDITION_REGEX = /^"global-(docs-)?approvers" not in groups.approved$/;
|
|
|
|
/** A PullApprove group to be able to test files against. */
|
|
export class PullApproveGroup {
|
|
/** List of conditions for the group. */
|
|
readonly conditions: GroupCondition[] = [];
|
|
/** List of reviewers for the group. */
|
|
readonly reviewers: GroupReviewers;
|
|
|
|
constructor(
|
|
public groupName: string, config: PullApproveGroupConfig,
|
|
readonly precedingGroups: PullApproveGroup[] = []) {
|
|
this._captureConditions(config);
|
|
this.reviewers = config.reviewers ?? {users: [], teams: []};
|
|
}
|
|
|
|
private _captureConditions(config: PullApproveGroupConfig) {
|
|
if (config.conditions) {
|
|
return config.conditions.forEach(condition => {
|
|
const expression = condition.trim();
|
|
|
|
if (expression.match(GLOBAL_APPROVAL_CONDITION_REGEX)) {
|
|
// Currently a noop as we don't take any action for global approval conditions.
|
|
return;
|
|
}
|
|
|
|
try {
|
|
this.conditions.push({
|
|
expression,
|
|
checkFn: convertConditionToFunction(expression),
|
|
matchedFiles: new Set(),
|
|
unverifiable: false,
|
|
});
|
|
} catch (e) {
|
|
error(`Could not parse condition in group: ${this.groupName}`);
|
|
error(` - ${expression}`);
|
|
error(`Error:`);
|
|
error(e.message);
|
|
error(e.stack);
|
|
process.exit(1);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests a provided file path to determine if it would be considered matched by
|
|
* the pull approve group's conditions.
|
|
*/
|
|
testFile(filePath: string): boolean {
|
|
return this.conditions.every((condition) => {
|
|
const {matchedFiles, checkFn, expression} = condition;
|
|
try {
|
|
const matchesFile = checkFn([filePath], this.precedingGroups);
|
|
if (matchesFile) {
|
|
matchedFiles.add(filePath);
|
|
}
|
|
return matchesFile;
|
|
} catch (e) {
|
|
// In the case of a condition that depends on the state of groups we want to
|
|
// ignore that the verification can't accurately evaluate the condition and then
|
|
// continue processing. Other types of errors fail the verification, as conditions
|
|
// should otherwise be able to execute without throwing.
|
|
if (e instanceof PullApproveGroupStateDependencyError) {
|
|
condition.unverifiable = true;
|
|
// Return true so that `this.conditions.every` can continue evaluating.
|
|
return true;
|
|
} else {
|
|
const errMessage = `Condition could not be evaluated: \n\n` +
|
|
`From the [${this.groupName}] group:\n` +
|
|
` - ${expression}` +
|
|
`\n\n${e.message} ${e.stack}\n\n`;
|
|
error(errMessage);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/** Retrieve the results for the Group, all matched and unmatched conditions. */
|
|
getResults(): PullApproveGroupResult {
|
|
const matchedConditions = this.conditions.filter(c => c.matchedFiles.size > 0);
|
|
const unmatchedConditions =
|
|
this.conditions.filter(c => c.matchedFiles.size === 0 && !c.unverifiable);
|
|
const unverifiableConditions = this.conditions.filter(c => c.unverifiable);
|
|
return {
|
|
matchedConditions,
|
|
matchedCount: matchedConditions.length,
|
|
unmatchedConditions,
|
|
unmatchedCount: unmatchedConditions.length,
|
|
unverifiableConditions,
|
|
groupName: this.groupName,
|
|
};
|
|
}
|
|
}
|