release.js

#!/usr/bin/env node

const { execSync } = require('child_process');
const readline = require('readline');
const fs = require('fs');

const rl = readline.createInterface({
	input: process.stdin,
	output: process.stdout
});

const exec = (command) => {
	try {
		return execSync(command, { stdio: 'inherit' });
	} catch (error) {
		console.error(`Error executing command: ${command}`);
		process.exit(1);
	}
};

const execWithOutput = (command) => {
	try {
		return execSync(command, { stdio: 'pipe' }).toString().trim();
	} catch (error) {
		console.error(`Error executing command: ${command}`);
		process.exit(1);
	}
};

const updateVersionInFile = (filePath, version, patterns) => {
	let content = fs.readFileSync(filePath, 'utf8');

	patterns.forEach(({ search, replace }) => {
		content = content.replace(
			search,
			typeof replace === 'function' ? replace(version) : replace
		);
	});

	fs.writeFileSync(filePath, content);
};

const generateChangelog = async () => {
	// Run the changelog generation command
	try {
		execSync('composer changelog:write', { stdio: 'ignore' });
	} catch (error) {
		console.error('Error generating changelog:');
		console.error(error);
		process.exit(1);
	}

	// Grab the version from the generated changelog
	const content = fs.readFileSync('CHANGELOG.md', 'utf8');
	const version = content.match(/## \[(\d+\.\d+\.\d+)\] - \d{4}-\d{2}-\d{2}/)[1];

	if (!version) {
		console.error('No version found in CHANGELOG.md');
		process.exit(1);
	}

	return version;
};

const updateReadmeWithChangelog = (version) => {
	// Grab the contents of the changelog and readme files.
	const changelogContent = fs.readFileSync('CHANGELOG.md', 'utf8');
	const readmeContent = fs.readFileSync('readme.txt', 'utf8');

	// Ensure the latest release entry was found in the list of latest releases we grabbed.
	const latestReleaseRegex = new RegExp(`## \\[${version}\\].*?(?=## \\[|$)`, 's');
	const latestReleaseMatch = changelogContent.match(latestReleaseRegex);
	if (!latestReleaseMatch) {
		console.error(`No changelog entry found for version ${version}`);
		process.exit(1);
	}

	// Extract the changelog entries for the given version
	// as well as any other entries from other releases under the same major version
	// e.g. if the latest release is 5.4.1, then we want to include all entries from 5.0.0 to 5.4.1.
	const majorVersion = version.split('.')[0];

	// Find all releases with the same major version
	const releaseRegex = /## \[(\d+\.\d+\.\d+)\] - (\d{4}-\d{2}-\d{2})/g;
	const releases = [];
	let match;

	while ((match = releaseRegex.exec(changelogContent)) !== null) {
		const [, releaseVersion, releaseDate] = match;
		if (releaseVersion.startsWith(`${majorVersion}.`)) {
			// Find the content for this release
			const releaseContentRegex = new RegExp(`## \\[${releaseVersion}\\].*?(?=## \\[|$)`, 's');
			const releaseContent = changelogContent.match(releaseContentRegex);

			if (releaseContent) {
				releases.push({
					version: releaseVersion,
					date: releaseDate,
					content: releaseContent[0]
				});
			}
		}
	}

	// Sort releases by version number (newest first)
	releases.sort((a, b) => {
		const aParts = a.version.split('.').map(Number);
		const bParts = b.version.split('.').map(Number);

		for (let i = 0; i < 3; i++) {
			if (aParts[i] !== bParts[i]) {
				return bParts[i] - aParts[i]; // Descending order
			}
		}

		return 0;
	});

	// Format the changelog entries for readme.txt
	// 1. Increase the header level by one (add one more #)
	// 2. Remove the square brackets from the version numbers.
	// 3. Remove PR numbers like [#123] from the ends of lines.
	let formattedChangelog = releases.map(release => {
		return release.content
			.replace(/### /g, '#### ')
			.replace(`## [${release.version}] - ${release.date}`, `### ${release.version} - ${release.date}`)
			.replace(/\s+\[#\d+\]$/mg, '')
			.trim();
	}).join('\n\n');

	// Find the changelog section in readme.txt
	const changelogSectionRegex = /== Changelog ==([\s\S]*?)(?=== |$)/;
	const changelogSection = readmeContent.match(changelogSectionRegex);

	if (!changelogSection) {
		console.error('No changelog section found in readme.txt');
		process.exit(1);
	}

	// At the bottom of the changelog section, add a link to the full changelog on GitHub.
	formattedChangelog += '\n\nSee full Changelog on [GitHub](https://github.com/Automattic/wordpress-activitypub/blob/trunk/CHANGELOG.md).';

	// Update the readme.txt with the new changelog section
	const updatedReadmeContent = readmeContent.replace(
		changelogSectionRegex,
		`== Changelog ==\n\n${formattedChangelog}\n\n`
	);

	fs.writeFileSync('readme.txt', updatedReadmeContent);
	console.log(`Updated readme.txt with changelog entries for version ${version} and other entries from major version ${majorVersion}`);
};

const updateReadmeWithUpgradeNotice = (version) => {
	return new Promise((resolve) => {
		rl.question('\nWould you like to add an upgrade notice for this version? (y/n): ', (answer) => {
			if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
				rl.question('Enter the upgrade notice (leave empty to skip): ', (notice) => {
					if (notice.trim()) {
						// Read the readme.txt file
						let readmeContent = fs.readFileSync('readme.txt', 'utf8');

						// Check if Upgrade Notice section already exists
						const upgradeNoticeSectionRegex = /== Upgrade Notice ==([\s\S]*?)(?=== |$)/;
						const upgradeNoticeSection = readmeContent.match(upgradeNoticeSectionRegex);

						// Create the new upgrade notice section
						const newUpgradeNotice = `== Upgrade Notice ==\n\n= ${version} =\n\n${notice.trim()}\n\n`;

						if (upgradeNoticeSection) {
							// Replace the entire existing Upgrade Notice section
							readmeContent = readmeContent.replace(
								upgradeNoticeSectionRegex,
								newUpgradeNotice
							);
						} else {
							// Create a new Upgrade Notice section at the end of the file
							readmeContent += `\n\n${newUpgradeNotice}`;
						}

						fs.writeFileSync('readme.txt', readmeContent);
						console.log(`Added upgrade notice for version ${version} to readme.txt`);
					} else {
						console.log('No upgrade notice added.');
					}
					resolve();
				});
			} else {
				console.log('Skipping upgrade notice.');
				resolve();
			}
		});
	});
};

async function createRelease() {
	// Start by generating the changelog.
	// The changelog will automatically pick a version
	// based off each changelog entry's provided significance.
	const version = await generateChangelog();

	const currentBranch = execWithOutput('git rev-parse --abbrev-ref HEAD');

	// Check if release branch already exists
	const branchExists = execWithOutput(`git branch --list release/${version}`);
	if (branchExists) {
		console.error(`\nError: Branch release/${version} already exists.`);
		// Return to original branch if we're not already there
		if (currentBranch !== execWithOutput('git rev-parse --abbrev-ref HEAD')) {
			exec(`git checkout ${currentBranch}`);
		}
		process.exit(1);
	}

	// Create and checkout release branch
	const branchName = `release/${version}`;
	exec(`git checkout -b ${branchName}`);

	// Update version numbers in files
	updateVersionInFile('activitypub.php', version, [
		{
			search: /Version: \d+\.\d+\.\d+/,
			replace: `Version: ${version}`
		},
		{
			search: /ACTIVITYPUB_PLUGIN_VERSION', '\d+\.\d+\.\d+/,
			replace: `ACTIVITYPUB_PLUGIN_VERSION', '${version}`
		}
	]);

	updateVersionInFile('readme.txt', version, [
		{
			search: /Stable tag: \d+\.\d+\.\d+/,
			replace: `Stable tag: ${version}`
		},
		{
			search: /= Unreleased =/,
			replace: `= ${version} =`
		}
	]);

	// Update the changelog section in readme.txt
	updateReadmeWithChangelog(version);

	// Prompt for and update the upgrade notice section in readme.txt
	await updateReadmeWithUpgradeNotice(version);

	updateVersionInFile('includes/class-migration.php', version, [
		{
			search: /(?<!\*[\s\S]{0,50})(?<=version_compare\s*\(\s*\$version_from_db,\s*')unreleased(?=',\s*['<=>])/g,
			replace: (match) => match.replace(/unreleased/i, version)
		}
	]);

	const phpFiles = execWithOutput('find . -name "*.php"').split('\n');

	phpFiles.forEach((filePath) => {
		updateVersionInFile(filePath, version, [
			{
				search: /@since unreleased/gi,
				replace: `@since ${version}`
			},
			{
				search: /@deprecated unreleased/gi,
				replace: `@deprecated ${version}`
			},
			{
				search: /(?<=_deprecated_function\s*\(\s*__METHOD__,\s*')unreleased(?=',\s*['<=>])/gi,
				replace: (match) => match.replace(/unreleased/i, version)
			},
			{
				search: /(?<=\bapply_filters_deprecated\s*\(\s*'.*?'\s*,\s*array\s*\(.*?\)\s*,\s*')unreleased(?=',\s*['<=>])/gi,
				replace: (match) => match.replace(/unreleased/i, version)
			}
		]);
	});

	// Stage and commit changes
	exec('git add .');
	exec(`git commit -m "Release ${version}"`);

	// Push to remote
	exec(`git push -u origin ${branchName}`);

	// Get current user's GitHub username
	const currentUser = execWithOutput('gh api user --jq .login');

	// Create PR using GitHub CLI and capture the URL
	console.log('\nCreating PR...');
	const prUrl = execWithOutput(`gh pr create --title "Release ${version}" --body "Release version ${version}" --base trunk --head ${branchName} --reviewer "Automattic/fediverse" --assignee "${currentUser}" --label "Release"`);

	// Open PR in browser if a URL was returned
	if (prUrl && prUrl.includes('github.com')) {
		exec(`open ${prUrl}`);
	}
}

async function release() {
	try {
		// Check if gh CLI is installed
		try {
			execSync('gh --version', { stdio: 'ignore' });
		} catch (error) {
			console.error('GitHub CLI (gh) is not installed. Please install it first:');
			console.error('https://cli.github.com/');
			process.exit(1);
		}

		// Ensure we're on trunk branch and up to date
		exec('git checkout trunk');
		exec('git pull origin trunk');

		await createRelease();

	} catch (error) {
		console.error('An error occurred:', error);
		process.exit(1);
	} finally {
		rl.close();
	}
}

release();