Bootstrap an automation tool

bin/build-plugin-zip.sh

@@ -28,40 +28,42 @@ warning () {
 
 status "💃 Time to release Gutenberg 🕺"
 
-# Make sure there are no changes in the working tree. Release builds should be
-# traceable to a particular commit and reliably reproducible. (This is not
-# totally true at the moment because we download nightly vendor scripts).
-changed=
-if ! git diff --exit-code > /dev/null; then
-	changed="file(s) modified"
-elif ! git diff --cached --exit-code > /dev/null; then
-	changed="file(s) staged"
-fi
-if [ ! -z "$changed" ]; then
-	git status
-	error "ERROR: Cannot build plugin zip with dirty working tree. ☝️
-       Commit your changes and try again."
-	exit 1
-fi
-
-# Do a dry run of the repository reset. Prompting the user for a list of all
-# files that will be removed should prevent them from losing important files!
-status "Resetting the repository to pristine condition. ✨"
-to_clean=$(git clean -xdf --dry-run)
-if [ ! -z "$to_clean" ]; then
-	echo $to_clean
-	warning "🚨 About to delete everything above! Is this okay? 🚨"
-	echo -n "[y]es/[N]o: "
-	read answer
-	if [ "$answer" != "${answer#[Yy]}" ]; then
-		# Remove ignored files to reset repository to pristine condition. Previous
-		# test ensures that changed files abort the plugin build.
-		status "Cleaning working directory... 🛀"
-		git clean -xdf
-	else
-		error "Fair enough; aborting. Tidy up your repo and try again. 🙂"
+if [ -z "$NO_CHECKS" ]; then
+	# Make sure there are no changes in the working tree. Release builds should be
+	# traceable to a particular commit and reliably reproducible. (This is not
+	# totally true at the moment because we download nightly vendor scripts).
+	changed=
+	if ! git diff --exit-code > /dev/null; then
+		changed="file(s) modified"
+	elif ! git diff --cached --exit-code > /dev/null; then
+		changed="file(s) staged"
+	fi
+	if [ ! -z "$changed" ]; then
+		git status
+		error "ERROR: Cannot build plugin zip with dirty working tree. ☝️
+		Commit your changes and try again."
 		exit 1
 	fi
+
+	# Do a dry run of the repository reset. Prompting the user for a list of all
+	# files that will be removed should prevent them from losing important files!
+	status "Resetting the repository to pristine condition. ✨"
+	to_clean=$(git clean -xdf --dry-run)
+	if [ ! -z "$to_clean" ]; then
+		echo $to_clean
+		warning "🚨 About to delete everything above! Is this okay? 🚨"
+		echo -n "[y]es/[N]o: "
+		read answer
+		if [ "$answer" != "${answer#[Yy]}" ]; then
+			# Remove ignored files to reset repository to pristine condition. Previous
+			# test ensures that changed files abort the plugin build.
+			status "Cleaning working directory... 🛀"
+			git clean -xdf
+		else
+			error "Fair enough; aborting. Tidy up your repo and try again. 🙂"
+			exit 1
+		fi
+	fi
 fi
 
 # Download all vendor scripts

bin/commander.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+
+// Dependencies
+const path = require( 'path' );
+const program = require( 'commander' );
+const inquirer = require( 'inquirer' );
+const semver = require( 'semver' );
+const chalk = require( 'chalk' );
+const fs = require( 'fs-extra' );
+const SimpleGit = require( 'simple-git/promise' );
+const childProcess = require( 'child_process' );
+const Octokit = require( '@octokit/rest' );
+const os = require( 'os' );
+const uuid = require( 'uuid/v4' );
+
+// Common info
+const workingDirectoryPath = path.join( os.tmpdir(), uuid() );
+const packageJsonPath = workingDirectoryPath + '/package.json';
+const packageLockPath = workingDirectoryPath + '/package-lock.json';
+const pluginFilePath = workingDirectoryPath + '/gutenberg.php';
+const gutenbergZipPath = workingDirectoryPath + '/gutenberg.zip';
+const repoOwner = 'WordPress';
+const repoURL = 'git@github.com:' + repoOwner + '/gutenberg.git';
+
+// UI
+const error = chalk.bold.red;
+const warning = chalk.bold.keyword( 'orange' );
+const success = chalk.bold.green;
+
+// Utils
+
+/**
+ * Asks the user for a confirmation to continue or abort otherwise
+ *
+ * @param {string} message      Confirmation message.
+ * @param {boolean} isDefault   Default reply.
+ * @param {string} abortMessage Abort message.
+ */
+const askForConfirmationToContinue = async ( message, isDefault = true, abortMessage = 'Aborting.' ) => {
+	const { isReady } = await inquirer.prompt( [ {
+		type: 'confirm',
+		name: 'isReady',
+		default: isDefault,
+		message,
+	} ] );
+
+	if ( ! isReady ) {
+		console.log( error( '\n' + abortMessage ) );
+		process.exit( 1 );
+	}
+};
+
+/**
+ * Common logic wrapping a step in the process.
+ *
+ * @param {string} name         Step name.
+ * @param {string} abortMessage Abort message.
+ * @param {function} handler    Step logic.
+ */
+const runStep = async ( name, abortMessage, handler ) => {
+	try {
+		await handler();
+	} catch ( exception ) {
+		console.log(
+			error( 'The following error happened during the "' + warning( name ) + '" step:' ) + '\n\n',
+			exception,
+			error( '\n\n' + abortMessage )
+		);
+
+		process.exit( 1 );
+	}
+};
+
+program
+	.command( 'release-plugin-rc' )
+	.alias( 'rc' )
+	.description( 'Release an RC version of the plugin (supports only rc.1 for now)' )
+	.action( async () => {
+		console.log(
+			chalk.bold( '💃 Time to release Gutenberg 🕺\n\n' ),
+			'Welcome! This tool is going to help you release a new RC version of the Gutenberg Plugin.\n',
+			'It goes throught different steps : creating the release branch, bumping the plugin version, tagging and creating the github release, building the zip...\n',
+			'To perform a release you\'ll have to be a member of the Gutenberg Core Team.\n'
+		);
+
+		// This is a variable that contains the abort message shown when the script is aborted.
+		let abortMessage = 'Aborting!';
+		await askForConfirmationToContinue( 'Ready go go? ' );
+
+		// Cloning the repository
+		await runStep( 'Cloning the repository', abortMessage, async () => {
+			console.log( '>> Cloning the repository' );
+			const simpleGit = SimpleGit();
+			await simpleGit.clone( repoURL, workingDirectoryPath, [ '--depth=1' ] );
+			console.log( '>> The gutenberg repository has been successfully cloned in the following temporary folder: ' + success( workingDirectoryPath ) );
+		} );
+
+		// Creating the release branch
+		const simpleGit = SimpleGit( workingDirectoryPath );
+		let nextVersion;
+		let nextVersionLabel;
+		let releaseBranch;
+		const packageJson = require( packageJsonPath );
+		const packageLock = require( packageLockPath );
+		await runStep( 'Creating the release branch', abortMessage, async () => {
+			const parsedVersion = semver.parse( packageJson.version );
+			if ( parsedVersion.minor === 9 ) {
+				nextVersion = ( parsedVersion.major + 1 ) + '.0.0-rc.1';
+				releaseBranch = 'release/' + ( parsedVersion.major + 1 ) + '.0';
+				nextVersionLabel = ( parsedVersion.major + 1 ) + '.0.0 RC1';
+			} else {
+				nextVersion = parsedVersion.major + '.' + ( parsedVersion.minor + 1 ) + '.0-rc.1';
+				releaseBranch = 'release/' + parsedVersion.major + '.' + ( parsedVersion.minor + 1 );
+				nextVersionLabel = parsedVersion.major + '.' + ( parsedVersion.minor + 1 ) + '.0 RC1';
+			}
+			await askForConfirmationToContinue(
+				'The RC Version to be applied is ' + success( nextVersion ) + '. Proceed with the creation of the release branch?',
+				true,
+				abortMessage
+			);
+
+			// Creating the release branch
+			await simpleGit.checkoutLocalBranch( releaseBranch );
+			console.log( '>> The local release branch ' + success( releaseBranch ) + ' has been successfully created.' );
+		} );
+
+		// Bumping the version in the different files (package.json, package-lock.json, gutenberg.php)
+		let commitHash;
+		await runStep( 'Updating the plugin version', abortMessage, async () => {
+			const newPackageJson = {
+				...packageJson,
+				version: nextVersion,
+			};
+			fs.writeFileSync( packageJsonPath, JSON.stringify( newPackageJson, null, '\t' ) + '\n' );
+			const newPackageLock = {
+				...packageLock,
+				version: nextVersion,
+			};
+			fs.writeFileSync( packageLockPath, JSON.stringify( newPackageLock, null, '\t' ) + '\n' );
+			const content = fs.readFileSync( pluginFilePath, 'utf8' );
+			fs.writeFileSync( pluginFilePath, content.replace( ' * Version: ' + packageJson.version, ' * Version: ' + nextVersion ) );
+			console.log( '>> The plugin version has been updated successfully.' );
+
+			// Commit the version bump
+			await askForConfirmationToContinue(
+				'Please check the diff. Proceed with the version bump commit?',
+				true,
+				abortMessage
+			);
+			await simpleGit.add( [
+				packageJsonPath,
+				packageLockPath,
+				pluginFilePath,
+			] );
+			const commitData = await simpleGit.commit( 'Bump plugin version to ' + nextVersion );
+			commitHash = commitData.commit;
+			console.log( '>> The plugin version bump has been commited succesfully.' );
+		} );
+
+		// Plugin ZIP creation
+		await runStep( 'Plugin ZIP creation', abortMessage, async () => {
+			await askForConfirmationToContinue(
+				'Proceed and build the plugin zip? (It takes a few minutes)',
+				true,
+				abortMessage
+			);
+			childProcess.execSync( '/bin/bash bin/build-plugin-zip.sh', {
+				cwd: workingDirectoryPath,
+				env: {
+					NO_CHECKS: true,
+					PATH: process.env.PATH,
+				},
+				stdio: [ 'inherit', 'ignore', 'inherit' ],
+			} );
+
+			console.log( '>> The plugin zip has been built succesfully. Path: ' + success( gutenbergZipPath ) );
+		} );
+
+		// Creating the git tag
+		await runStep( 'Creating the git tag', abortMessage, async () => {
+			await askForConfirmationToContinue(
+				'Proceed with the creation of the git tag?',
+				true,
+				abortMessage
+			);
+			await simpleGit.addTag( 'v' + nextVersion );
+			console.log( '>> The ' + success( 'v' + nextVersion ) + ' tag has been created succesfully.' );
+		} );
+
+		await runStep( 'Pushing the release branch and the tag', abortMessage, async () => {
+			await askForConfirmationToContinue(
+				'The release branch and the tag are going to be pushed to the remote repository. Continue?',
+				true,
+				abortMessage
+			);
+			await simpleGit.push( 'origin', releaseBranch );
+			await simpleGit.pushTags( 'origin' );
+		} );
+		abortMessage = 'Aborting! Make sure to remove remote release branch and tag.';
+
+		// Creating the GitHub Release
+		let octokit;
+		let release;
+		await runStep( 'Creating the Github release', abortMessage, async () => {
+			await askForConfirmationToContinue(
+				'Proceed with the creation of the Github release?',
+				true,
+				abortMessage
+			);
+			const { changelog } = await inquirer.prompt( [ {
+				type: 'editor',
+				name: 'changelog',
+				message: 'Please provide the CHANGELOG of the release (markdown)',
+			} ] );
+
+			const { token } = await inquirer.prompt( [ {
+				type: 'input',
+				name: 'token',
+				message: 'Please provide a Github personal authentication token. (Navigate to ' + success( 'https://github.com/settings/tokens' ) + ' to create one with admin:org, repo and write:packages rights)',
+			} ] );
+
+			octokit = new Octokit( {
+				auth: token,
+			} );
+
+			const releaseData = await octokit.repos.createRelease( {
+				owner: repoOwner,
+				repo: 'gutenberg',
+				tag_name: 'v' + nextVersion,
+				name: nextVersionLabel,
+				body: changelog,
+				prerelease: true,
+			} );
+			release = releaseData.data;
+
+			console.log( '>> The Github release has been created succesfully.' );
+		} );
+		abortMessage = 'Aborting! Make sure to remove the remote release branch, the git tag and the Github release.';
+
+		// Uploading the Gutenberg Zip to the release
+		await runStep( 'Uploading the plugin zip', abortMessage, async () => {
+			const filestats = fs.statSync( gutenbergZipPath );
+			await octokit.repos.uploadReleaseAsset( {
+				url: release.upload_url,
+				headers: {
+					'content-length': filestats.size,
+					'content-type': 'application/zip',
+				},
+				name: 'gutenberg.zip',
+				file: fs.createReadStream( gutenbergZipPath ),
+			} );
+			console.log( '>> The plugin zip has been succesfully uploaded.' );
+		} );
+		abortMessage = 'Aborting! Make sure to manually cherry-pick the ' + success( commitHash ) + ' commit to the master branch.';
+
+		// Cherry-picking the bump commit into master
+		await runStep( 'Cherry-picking the bump commit into master', abortMessage, async () => {
+			await askForConfirmationToContinue(
+				'The plugin RC is now released. Proceed with the version bump in the master branch?',
+				true,
+				'test'
+			);
+			await simpleGit.fetch();
+			await simpleGit.checkout( 'master' );
+			await simpleGit.reset( 'hard' );
+			await simpleGit.pull( 'origin', 'master' );
+			await simpleGit.raw( [ 'cherry-pick', commitHash ] );
+			await simpleGit.push( 'origin', 'master' );
+		} );
+
+		abortMessage = 'Aborting! The release is finished though.';
+		await runStep( 'Cleaning the temporary folder', abortMessage, async () => {
+			await fs.remove( workingDirectoryPath );
+		} );
+
+		console.log(
+			'\n>> 🎉 The Gutenberg ' + success( nextVersionLabel ) + '  has been successfully released.\n',
+			'You can access the Github release here: ' + success( release.html_url ) + '\n',
+			'Thanks for performing the release!'
+		);
+	} );
+
+program.parse( process.argv );