109 lines
5.1 KiB
TypeScript
109 lines
5.1 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 * as semver from 'semver';
|
|
|
|
import {green, info, yellow} from '../../../utils/console';
|
|
import {ActiveReleaseTrains} from '../../versioning/active-release-trains';
|
|
import {computeNewPrereleaseVersionForNext} from '../../versioning/next-prerelease-version';
|
|
import {ReleaseAction} from '../actions';
|
|
import {getCommitMessageForExceptionalNextVersionBump, getReleaseNoteCherryPickCommitMessage} from '../commit-message';
|
|
import {changelogPath, packageJsonPath} from '../constants';
|
|
import {ReleaseNotes} from '../release-notes/release-notes';
|
|
|
|
/**
|
|
* Release action that moves the next release-train into the feature-freeze phase. This means
|
|
* that a new version branch is created from the next branch, and a new next pre-release is
|
|
* cut indicating the started feature-freeze.
|
|
*/
|
|
export class MoveNextIntoFeatureFreezeAction extends ReleaseAction {
|
|
private _newVersion = computeNewPrereleaseVersionForNext(this.active, this.config);
|
|
|
|
async getDescription() {
|
|
const {branchName} = this.active.next;
|
|
const newVersion = await this._newVersion;
|
|
return `Move the "${branchName}" branch into feature-freeze phase (v${newVersion}).`;
|
|
}
|
|
|
|
async perform() {
|
|
const newVersion = await this._newVersion;
|
|
const newBranch = `${newVersion.major}.${newVersion.minor}.x`;
|
|
|
|
// Branch-off the next branch into a feature-freeze branch.
|
|
await this._createNewVersionBranchFromNext(newBranch);
|
|
|
|
// Stage the new version for the newly created branch, and push changes to a
|
|
// fork in order to create a staging pull request. Note that we re-use the newly
|
|
// created branch instead of re-fetching from the upstream.
|
|
const {pullRequest: {id}, releaseNotes} =
|
|
await this.stageVersionForBranchAndCreatePullRequest(newVersion, newBranch);
|
|
|
|
// Wait for the staging PR to be merged. Then build and publish the feature-freeze next
|
|
// pre-release. Finally, cherry-pick the release notes into the next branch in combination
|
|
// with bumping the version to the next minor too.
|
|
await this.waitForPullRequestToBeMerged(id);
|
|
await this.buildAndPublish(newVersion, newBranch, 'next');
|
|
await this._createNextBranchUpdatePullRequest(releaseNotes, newVersion);
|
|
}
|
|
|
|
/** Creates a new version branch from the next branch. */
|
|
private async _createNewVersionBranchFromNext(newBranch: string) {
|
|
const {branchName: nextBranch} = this.active.next;
|
|
await this.verifyPassingGithubStatus(nextBranch);
|
|
await this.checkoutUpstreamBranch(nextBranch);
|
|
await this.createLocalBranchFromHead(newBranch);
|
|
await this.pushHeadToRemoteBranch(newBranch);
|
|
info(green(` ✓ Version branch "${newBranch}" created.`));
|
|
}
|
|
|
|
/**
|
|
* Creates a pull request for the next branch that bumps the version to the next
|
|
* minor, and cherry-picks the changelog for the newly branched-off feature-freeze version.
|
|
*/
|
|
private async _createNextBranchUpdatePullRequest(
|
|
releaseNotes: ReleaseNotes, newVersion: semver.SemVer) {
|
|
const {branchName: nextBranch, version} = this.active.next;
|
|
// We increase the version for the next branch to the next minor. The team can decide
|
|
// later if they want next to be a major through the `Configure Next as Major` release action.
|
|
const newNextVersion = semver.parse(`${version.major}.${version.minor + 1}.0-next.0`)!;
|
|
const bumpCommitMessage = getCommitMessageForExceptionalNextVersionBump(newNextVersion);
|
|
|
|
await this.checkoutUpstreamBranch(nextBranch);
|
|
await this.updateProjectVersion(newNextVersion);
|
|
|
|
// Create an individual commit for the next version bump. The changelog should go into
|
|
// a separate commit that makes it clear where the changelog is cherry-picked from.
|
|
await this.createCommit(bumpCommitMessage, [packageJsonPath]);
|
|
|
|
await this.prependReleaseNotesToChangelog(releaseNotes);
|
|
|
|
const commitMessage = getReleaseNoteCherryPickCommitMessage(releaseNotes.version);
|
|
|
|
await this.createCommit(commitMessage, [changelogPath]);
|
|
|
|
let nextPullRequestMessage = `The previous "next" release-train has moved into the ` +
|
|
`release-candidate phase. This PR updates the next branch to the subsequent ` +
|
|
`release-train.\n\nAlso this PR cherry-picks the changelog for ` +
|
|
`v${newVersion} into the ${nextBranch} branch so that the changelog is up to date.`;
|
|
|
|
const nextUpdatePullRequest = await this.pushChangesToForkAndCreatePullRequest(
|
|
nextBranch, `next-release-train-${newNextVersion}`,
|
|
`Update next branch to reflect new release-train "v${newNextVersion}".`,
|
|
nextPullRequestMessage);
|
|
|
|
info(green(` ✓ Pull request for updating the "${nextBranch}" branch has been created.`));
|
|
info(yellow(` Please ask team members to review: ${nextUpdatePullRequest.url}.`));
|
|
}
|
|
|
|
static async isActive(active: ActiveReleaseTrains) {
|
|
// A new feature-freeze/release-candidate branch can only be created if there
|
|
// is no active release-train in feature-freeze/release-candidate phase.
|
|
return active.releaseCandidate === null;
|
|
}
|
|
}
|