@ckeditor/ckeditor5-dev-release-tools 32.0.0

package/lib/utils/cli.js

@@ -0,0 +1,324 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const inquirer = require( 'inquirer' );
+const semver = require( 'semver' );
+const chalk = require( 'chalk' );
+
+const QUESTION_MARK = chalk.cyan( '?' );
+
+const cli = {
+	/**
+	 * A size of default indent for a log.
+	 */
+	INDENT_SIZE: 3,
+
+	/**
+	 * A size of indent for a second and next lines in a log. The number is equal to length of the log string:
+	 * '* 1234567 ', where '1234567' is a short commit id.
+	 * It does not include a value from `cli.INDENT_SIZE`.
+	 */
+	COMMIT_INDENT_SIZE: 10,
+
+	/**
+	 * Asks a user for a confirmation for updating and tagging versions of the packages.
+	 *
+	 * @param {Map} packages Packages to release.
+	 * @returns {Promise.<Boolean>}
+	 */
+	confirmUpdatingVersions( packages ) {
+		let message = 'Packages and their old and new versions:\n';
+
+		for ( const packageName of Array.from( packages.keys() ).sort() ) {
+			const packageDetails = packages.get( packageName );
+
+			message += `  * "${ packageName }": v${ packageDetails.previousVersion } => v${ packageDetails.version }\n`;
+		}
+
+		message += 'Continue?';
+
+		const confirmQuestion = {
+			message,
+			type: 'confirm',
+			name: 'confirm',
+			default: true
+		};
+
+		return inquirer.prompt( [ confirmQuestion ] )
+			.then( answers => answers.confirm );
+	},
+
+	/**
+	 * Asks a user for a confirmation for publishing changes.
+	 *
+	 * @param {Map} packages Packages to release.
+	 * @returns {Promise.<Boolean>}
+	 */
+	confirmPublishing( packages ) {
+		let message = 'Services where the release will be created:\n';
+
+		for ( const packageName of Array.from( packages.keys() ).sort() ) {
+			const packageDetails = packages.get( packageName );
+
+			let packageMessage = `  * "${ packageName }" - version: ${ packageDetails.version }`;
+
+			const services = [];
+
+			if ( packageDetails.shouldReleaseOnNpm ) {
+				services.push( 'NPM' );
+			}
+
+			if ( packageDetails.shouldReleaseOnGithub ) {
+				services.push( 'GitHub' );
+			}
+
+			let color;
+
+			if ( services.length ) {
+				color = chalk.magenta;
+				packageMessage += ` - services: ${ services.join( ', ' ) } `;
+			} else {
+				color = chalk.gray;
+				packageMessage += ' - nothing to release';
+			}
+
+			message += color( packageMessage ) + '\n';
+		}
+
+		message += 'Continue?';
+
+		const confirmQuestion = {
+			message,
+			type: 'confirm',
+			name: 'confirm',
+			default: true
+		};
+
+		return inquirer.prompt( [ confirmQuestion ] )
+			.then( answers => answers.confirm );
+	},
+
+	/**
+	 * Asks a user for a confirmation for removing archives created by `npm pack` command.
+	 *
+	 * @returns {Promise.<Boolean>}
+	 */
+	confirmRemovingFiles() {
+		const confirmQuestion = {
+			message: 'Remove created archives?',
+			type: 'confirm',
+			name: 'confirm',
+			default: true
+		};
+
+		return inquirer.prompt( [ confirmQuestion ] )
+			.then( answers => answers.confirm );
+	},
+
+	/**
+	 * Asks a user for a confirmation for including a package that does not contain all required files.
+	 *
+	 * @returns {Promise.<Boolean>}
+	 */
+	confirmIncludingPackage() {
+		const confirmQuestion = {
+			message: 'Package does not contain all required files to publish. Include this package in the release and continue?',
+			type: 'confirm',
+			name: 'confirm',
+			default: true
+		};
+
+		return inquirer.prompt( [ confirmQuestion ] )
+			.then( answers => answers.confirm );
+	},
+
+	/**
+	 * Asks a user for providing the new version.
+	 *
+	 * @param {String} packageVersion
+	 * @param {String|null} releaseTypeOrNewVersion
+	 * @param {Object} [options]
+	 * @param {Boolean} [options.disableInternalVersion=false] Whether to "internal" version is enabled.
+	 * @param {Boolean} [options.disableSkipVersion=false] Whether to "skip" version is enabled.
+	 * @param {Number} [options.indentLevel=0] The indent level.
+	 * @returns {Promise.<String>}
+	 */
+	provideVersion( packageVersion, releaseTypeOrNewVersion, options = {} ) {
+		const indentLevel = options.indentLevel || 0;
+		const suggestedVersion = getSuggestedVersion();
+
+		let message = 'Type the new version, "skip" or "internal"';
+
+		if ( options.disableInternalVersion ) {
+			message = 'Type the new version or "skip"';
+		}
+
+		message += ` (suggested: "${ suggestedVersion }", current: "${ packageVersion }"):`;
+
+		const versionQuestion = {
+			type: 'input',
+			name: 'version',
+			default: suggestedVersion,
+			message,
+
+			filter( input ) {
+				return input.trim();
+			},
+
+			validate( input ) {
+				if ( !options.disableSkipVersion && input === 'skip' ) {
+					return true;
+				}
+
+				if ( !options.disableInternalVersion && input === 'internal' ) {
+					return true;
+				}
+
+				// TODO: Check whether provided version is available.
+				return semver.valid( input ) ? true : 'Please provide a valid version.';
+			},
+
+			prefix: getPrefix( indentLevel )
+		};
+
+		return inquirer.prompt( [ versionQuestion ] )
+			.then( answers => answers.version );
+
+		function getSuggestedVersion() {
+			if ( !releaseTypeOrNewVersion || releaseTypeOrNewVersion === 'skip' ) {
+				return 'skip';
+			}
+
+			if ( semver.valid( releaseTypeOrNewVersion ) ) {
+				return releaseTypeOrNewVersion;
+			}
+
+			if ( releaseTypeOrNewVersion === 'internal' ) {
+				return options.disableInternalVersion ? 'skip' : 'internal';
+			}
+
+			if ( semver.prerelease( packageVersion ) ) {
+				releaseTypeOrNewVersion = 'prerelease';
+			}
+
+			// If package's version is below the '1.0.0', bump the 'minor' instead of 'major'
+			if ( releaseTypeOrNewVersion === 'major' && semver.gt( '1.0.0', packageVersion ) ) {
+				return semver.inc( packageVersion, 'minor' );
+			}
+
+			return semver.inc( packageVersion, releaseTypeOrNewVersion );
+		}
+	},
+
+	/**
+	 * Asks a user for providing the new version for a major release.
+	 *
+	 * @param {String} version
+	 * @param {String} foundPackage
+	 * @param {String} bumpType
+	 * @param {Object} [options={}]
+	 * @param {Number} [options.indentLevel=0] The indent level.
+	 * @returns {Promise.<String>}
+	 */
+	provideNewVersionForMonoRepository( version, foundPackage, bumpType, options = {} ) {
+		const indentLevel = options.indentLevel || 0;
+		const suggestedVersion = semver.inc( version, bumpType );
+
+		const message = 'Type the new version ' +
+			`(current highest: "${ version }" found in "${ chalk.underline( foundPackage ) }", suggested: "${ suggestedVersion }"):`;
+
+		const versionQuestion = {
+			type: 'input',
+			name: 'version',
+			default: suggestedVersion,
+			message,
+
+			filter( input ) {
+				return input.trim();
+			},
+
+			validate( input ) {
+				if ( !semver.valid( input ) ) {
+					return 'Please provide a valid version.';
+				}
+
+				return semver.gt( input, version ) ? true : `Provided version must be higher than "${ version }".`;
+			},
+			prefix: getPrefix( indentLevel )
+		};
+
+		return inquirer.prompt( [ versionQuestion ] )
+			.then( answers => answers.version );
+	},
+
+	/**
+	 * Asks a user for providing the GitHub token.
+	 *
+	 * @returns {Promise.<String>}
+	 */
+	provideToken() {
+		const tokenQuestion = {
+			type: 'password',
+			name: 'token',
+			message: 'Provide the GitHub token:',
+			validate( input ) {
+				return input.length === 40 ? true : 'Please provide a valid token.';
+			}
+		};
+
+		return inquirer.prompt( [ tokenQuestion ] )
+			.then( answers => answers.token );
+	},
+
+	/**
+	 * Asks a user for selecting services where packages will be released.
+	 *
+	 * If the user choices a GitHub, required token also has to be provided.
+	 *
+	 * @returns {Promise.<Object>}
+	 */
+	configureReleaseOptions() {
+		const options = {};
+
+		const servicesQuestion = {
+			type: 'checkbox',
+			name: 'services',
+			message: 'Select services where packages will be released:',
+			choices: [
+				'npm',
+				'GitHub'
+			],
+			default: [
+				'npm',
+				'GitHub'
+			]
+		};
+
+		return inquirer.prompt( [ servicesQuestion ] )
+			.then( answers => {
+				options.npm = answers.services.includes( 'npm' );
+				options.github = answers.services.includes( 'GitHub' );
+
+				if ( !options.github ) {
+					return options;
+				}
+
+				return cli.provideToken()
+					.then( token => {
+						options.token = token;
+
+						return options;
+					} );
+			} );
+	}
+};
+
+module.exports = cli;
+
+function getPrefix( indent ) {
+	return ' '.repeat( indent * cli.INDENT_SIZE ) + QUESTION_MARK;
+}

package/lib/utils/creategithubrelease.js

@@ -0,0 +1,35 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { Octokit } = require( '@octokit/rest' );
+
+/**
+ * Create a Github release.
+ *
+ * @param {String} token Token used to authenticate with GitHub.
+ * @param {Object} options
+ * @param {String} options.repositoryOwner Owner of the repository.
+ * @param {String} options.repositoryName Repository name.
+ * @param {String} options.version Name of tag connected with the release.
+ * @param {String} options.description Description of the release.
+ * @returns {Promise}
+ */
+module.exports = function createGithubRelease( token, options ) {
+	const github = new Octokit( {
+		version: '3.0.0',
+		auth: `token ${ token }`
+	} );
+
+	const releaseParams = {
+		owner: options.repositoryOwner,
+		repo: options.repositoryName,
+		tag_name: options.version,
+		body: options.description
+	};
+
+	return github.repos.createRelease( releaseParams );
+};

package/lib/utils/displaycommits.js

@@ -0,0 +1,105 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const chalk = require( 'chalk' );
+const { logger } = require( '@ckeditor/ckeditor5-dev-utils' );
+const utils = require( './transformcommitutils' );
+const { INDENT_SIZE, COMMIT_INDENT_SIZE } = require( './cli' );
+
+/**
+ * @param {Array.<Commit>|Set.<Commit>} commits
+ * @param {Object} [options={}]
+ * @param {Boolean} [options.attachLinkToCommit=false] Whether to attach a link to parsed commit.
+ * @param {Number} [options.indentLevel=1] The indent level.
+ */
+module.exports = function displayCommits( commits, options = {} ) {
+	const log = logger();
+
+	const attachLinkToCommit = options.attachLinkToCommit || false;
+	const indentLevel = options.indentLevel || 1;
+	const listIndent = ' '.repeat( INDENT_SIZE * indentLevel );
+
+	if ( !( commits.length || commits.size ) ) {
+		log.info( listIndent + chalk.italic( 'No commits to display.' ) );
+	}
+
+	const COMMITS_SEPARATOR = listIndent + chalk.gray( '-'.repeat( 112 ) );
+
+	// Group of commits by the commit's hash.
+	/** @type {Map.<String, Set.<Commit>>} */
+	const commitGroups = new Map();
+
+	for ( const singleCommit of commits ) {
+		getCommitGroup( singleCommit ).add( singleCommit );
+	}
+
+	// A flag that helps avoid duplication separators if two groups are consecutive one after another.
+	let finishedWithSeparator = false;
+
+	for ( const [ hash, commits ] of commitGroups ) {
+		// Do not duplicate the separator if it was already added.
+		if ( commits.size > 1 && !finishedWithSeparator ) {
+			log.info( COMMITS_SEPARATOR );
+		}
+
+		for ( const singleCommit of commits.values() ) {
+			const hasCorrectType = utils.availableCommitTypes.has( singleCommit.rawType );
+			const isCommitIncluded = utils.availableCommitTypes.get( singleCommit.rawType );
+
+			const indent = commits.size > 1 ? listIndent.slice( 0, listIndent.length - 1 ) + chalk.gray( '|' ) : listIndent;
+			const noteIndent = indent + ' '.repeat( COMMIT_INDENT_SIZE );
+
+			let logMessage = `${ indent }* ${ chalk.yellow( hash.slice( 0, 7 ) ) } "${ utils.truncate( singleCommit.header, 100 ) }" `;
+
+			if ( hasCorrectType && isCommitIncluded ) {
+				logMessage += chalk.green( 'INCLUDED' );
+			} else if ( hasCorrectType && !isCommitIncluded ) {
+				logMessage += chalk.grey( 'SKIPPED' );
+			} else {
+				logMessage += chalk.red( 'INVALID' );
+			}
+
+			// Avoid displaying singleCommit merge twice.
+			if ( singleCommit.merge && singleCommit.merge !== singleCommit.header ) {
+				logMessage += `\n${ noteIndent }${ chalk.italic( singleCommit.merge ) }`;
+			}
+
+			for ( const note of singleCommit.notes ) {
+				const limit = 100 - note.title.length;
+
+				logMessage += `\n${ noteIndent }${ note.title }: ${ utils.truncate( note.text, limit ) } `;
+			}
+
+			if ( attachLinkToCommit ) {
+				const url = `${ singleCommit.repositoryUrl }/commit/${ singleCommit.hash }`;
+
+				logMessage += `\n${ noteIndent }${ chalk.gray( url ) }`;
+			}
+
+			log.info( logMessage );
+		}
+
+		if ( commits.size > 1 ) {
+			finishedWithSeparator = true;
+			log.info( COMMITS_SEPARATOR );
+		} else {
+			finishedWithSeparator = false;
+		}
+	}
+
+	/**
+	 * @param {Commit} commit
+	 * @returns {Set.<Commit>}
+	 */
+	function getCommitGroup( commit ) {
+		if ( !commitGroups.has( commit.hash ) ) {
+			commitGroups.set( commit.hash, new Set() );
+		}
+
+		return commitGroups.get( commit.hash );
+	}
+};

package/lib/utils/displayskippedpackages.js

@@ -0,0 +1,32 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const chalk = require( 'chalk' );
+const { logger } = require( '@ckeditor/ckeditor5-dev-utils' );
+const getPackageJson = require( './getpackagejson' );
+const { INDENT_SIZE } = require( './cli' );
+
+/**
+ * Displays skipped packages.
+ *
+ * @param {Set} skippedPackagesPaths
+ */
+module.exports = function displaySkippedPackages( skippedPackagesPaths ) {
+	if ( !skippedPackagesPaths.size ) {
+		return;
+	}
+
+	const indent = ' '.repeat( INDENT_SIZE );
+
+	const packageNames = Array.from( skippedPackagesPaths )
+		.map( packagePath => getPackageJson( packagePath ).name );
+
+	let message = indent + chalk.bold.underline( 'Packages listed below have been skipped:' ) + '\n';
+	message += packageNames.map( line => indent + `  * ${ line }` ).join( '\n' );
+
+	logger().info( message );
+};

package/lib/utils/executeonpackages.js

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+/**
+ * The function allows running a function on locally installed packages.
+ *
+ * @param {Iterable} pathsToPackages A collection of paths to packages.
+ * @param {Function} functionToExecute A function that will be called on each package.
+ * The function receives one argument:
+ *   * `{String} dependencyPath An absolute path to the package.`
+ * The function should return a promise.
+ * @returns {Promise}
+ */
+module.exports = function executeOnPackages( pathsToPackages, functionToExecute ) {
+	let promise = Promise.resolve();
+
+	for ( const pathToSinglePackage of pathsToPackages ) {
+		promise = promise.then( () => functionToExecute( pathToSinglePackage ) );
+	}
+
+	return promise;
+};

package/lib/utils/generatechangelog.js

@@ -0,0 +1,121 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { Readable } = require( 'stream' );
+const { stream } = require( '@ckeditor/ckeditor5-dev-utils' );
+const conventionalChangelogWriter = require( 'conventional-changelog-writer' );
+
+const UPDATED_TRANSLATION_COMMIT = '* Updated translations.';
+
+/**
+ * Generates the changelog based on commits.
+ *
+ * @param {Array.<Commit>} commits
+ *
+ * @param {Object} context
+ * @param {String} context.version Current version for the release.
+ * @param {String} context.repoUrl The repository URL.
+ * @param {String} context.currentTag A tag for the current version.
+ * @param {String} context.commit Commit keyword in the URL.
+ * @param {String} [context.previousTag] A tag for the previous version.
+ * @param {Boolean} [options.highlightsPlaceholder=false] Whether to add a note about release highlights.
+ * @param {Boolean} [options.collaborationFeatures=false] Whether to add a note about collaboration features.
+ * @param {Boolean} [context.skipCommitsLink=false] Whether to skip adding links to commit.
+ * @param {Boolean} [context.skipCompareLink=false] Whether to remove the compare URL in the header.
+ *
+ * @param {Object} options
+ * @param {Object} options.transform
+ * @param {Function} options.transform.hash A function for mapping the commit's hash.
+ * @param {Array.<String>|String} options.groupBy A key for grouping the commits.
+ * @param {Function} options.commitGroupsSort A sort function for the groups.
+ * @param {Function} options.noteGroupsSort A soft function for the notes.
+ * @param {String} options.mainTemplate The main template for the changelog.
+ * @param {String} options.headerPartial The "header" partial used in the main template.
+ * @param {String} options.commitPartial The "commit" partial used in the main template.
+ * @param {String} options.footerPartial The "footer" partial used in the main template.
+ *
+ * @returns {Promise.<String>}
+ */
+module.exports = function generateChangelog( commits, context, options ) {
+	const commitStream = new Readable( { objectMode: true } );
+	/* istanbul ignore next */
+	commitStream._read = function() {};
+
+	for ( const commitItem of commits ) {
+		commitStream.push( commitItem );
+	}
+
+	commitStream.push( null );
+
+	return new Promise( ( resolve, reject ) => {
+		commitStream
+			.pipe( conventionalChangelogWriter( context, options ) )
+			.pipe( stream.noop( changes => {
+				changes = mergeUpdateTranslationsCommits( changes.toString(), {
+					skipCommitsLink: context.skipCommitsLink
+				} );
+
+				resolve( changes );
+			} ) )
+			.on( 'error', reject );
+	} );
+};
+
+/**
+ * Merges multiple "Updated translations." entries into the single commit.
+ *
+ * @param {String} changelog Generated changelog.
+ * @param {Object} [options={}]
+ * @param {Boolean} [options.skipCommitsLink=false] Whether to skip adding links to commit.
+ * @returns {String}
+ */
+function mergeUpdateTranslationsCommits( changelog, options = {} ) {
+	let foundUpdatedTranslationCommit = false;
+
+	const changelogAsArray = changelog.split( '\n' );
+
+	// An array that contains duplicated commits.
+	const removedEntries = [];
+
+	// An array that contains changelog without duplicated entries.
+	const uniqueEntries = changelogAsArray.filter( line => {
+		if ( !line.startsWith( UPDATED_TRANSLATION_COMMIT ) ) {
+			return true;
+		}
+
+		if ( foundUpdatedTranslationCommit ) {
+			removedEntries.push( line );
+
+			return false;
+		}
+
+		foundUpdatedTranslationCommit = true;
+
+		return true;
+	} );
+
+	if ( options.skipCommitsLink ) {
+		return uniqueEntries.join( '\n' );
+	}
+
+	return uniqueEntries.map( line => {
+		if ( !line.startsWith( UPDATED_TRANSLATION_COMMIT ) ) {
+			return line;
+		}
+
+		const newLine = line + ' ' + removedEntries
+			.map( entry => {
+				const match = entry.match( /(\(\[commit\].*)$/ );
+
+				return match ? match[ 1 ] : null;
+			} )
+			.filter( item => !!item )
+			.join( ' ' );
+
+		return newLine.trim().replace( /\) \(/g, ', ' );
+	} ).join( '\n' );
+}

package/lib/utils/getchangedfilesforcommit.js

@@ -0,0 +1,33 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+
+/**
+ * Returns an array with paths to changed files for given commit.
+ *
+ * @param {String} commitId
+ * @returns {Array.<String>}
+ */
+module.exports = function getChangedFilesForCommit( commitId ) {
+	const gitCommand = `git log -m -1 --name-only --pretty="format:" ${ commitId }`;
+	const changedFiles = tools.shExec( gitCommand, { verbosity: 'error' } ).trim();
+
+	// Merge commits can have two parents. Returned files for merge commits looks like:
+	// file1            <-- files from merged branch
+	// file2            <-- files from merged branch
+	// file             <-- files from merged branch
+	//
+	// other-file1      <-- files from last commit before merge
+	// other-file2      <-- files from last commit before merge
+	// We need to filter out files from commit before merge.
+
+	return changedFiles.split( '\n\n' )[ 0 ]
+		.split( '\n' )
+		.map( file => file.trim() )
+		.filter( item => item );
+};