@ckeditor/ckeditor5-dev-release-tools 32.0.0

package/lib/utils/getcommits.js

@@ -0,0 +1,104 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const conventionalCommitsParser = require( 'conventional-commits-parser' );
+const conventionalCommitsFilter = require( 'conventional-commits-filter' );
+const gitRawCommits = require( 'git-raw-commits' );
+const concat = require( 'concat-stream' );
+const parserOptions = require( './parseroptions' );
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+
+/**
+ * Returns a promise that resolves an array of commits since the last tag specified as `options.from`.
+ *
+ * @param {Function} transformCommit
+ * @param {Object} options
+ * @param {String} [options.from] A commit or tag name that will be the first param of the range of commits to collect.
+ * @param {String} [options.releaseBranch='master'] A name of the branch that should be used for releasing packages.
+ * @param {String} [options.mainBranch='master'] A name of the main branch in the repository.
+ * @returns {Promise.<Array.<Commit>>}
+ */
+module.exports = function getCommits( transformCommit, options = {} ) {
+	const releaseBranch = options.releaseBranch || 'master';
+	const mainBranch = options.mainBranch || 'master';
+
+	const currentBranch = exec( 'git rev-parse --abbrev-ref HEAD' ).trim();
+
+	// Check whether current branch is the same as the release branch.
+	if ( currentBranch !== releaseBranch ) {
+		return Promise.reject( new Error(
+			`Expected to be checked out on the release branch ("${ releaseBranch }") instead of "${ currentBranch }". Aborting.`
+		) );
+	}
+
+	// If the release branch is the same as the main branch, we can collect all commits directly from the branch.
+	if ( releaseBranch === mainBranch ) {
+		return findCommits( { from: options.from } );
+	} else {
+		// Otherwise, (release branch is other than the main branch) we need to merge arrays of commits.
+		// See: https://github.com/ckeditor/ckeditor5/issues/7492.
+		const baseCommit = exec( `git merge-base ${ releaseBranch } ${ mainBranch }` ).trim();
+
+		const commitPromises = [
+			// 1. Commits from the last release and to the point where the release branch was created (the merge-base commit).
+			findCommits( { from: options.from, to: baseCommit } ),
+			// 2. Commits from the merge-base commit to HEAD.
+			findCommits( { from: baseCommit } )
+		];
+
+		return Promise.all( commitPromises )
+			.then( commits => [].concat( ...commits ) );
+	}
+
+	function findCommits( gitRawCommitsOptions ) {
+		const gitRawCommitsOpts = Object.assign( {}, gitRawCommitsOptions, {
+			format: '%B%n-hash-%n%H',
+			merges: undefined,
+			firstParent: true
+		} );
+
+		return new Promise( ( resolve, reject ) => {
+			const stream = gitRawCommits( gitRawCommitsOpts )
+				.on( 'error', err => {
+					/* istanbul ignore else */
+					if ( err.message.match( /'HEAD': unknown/ ) ) {
+						reject( new Error( 'Given repository is empty.' ) );
+					} else if ( err.message.match( new RegExp( `'${ options.from }\\.\\.HEAD': unknown` ) ) ) {
+						reject( new Error(
+							`Cannot find tag or commit "${ options.from }" in given repository.`
+						) );
+					} else {
+						reject( err );
+					}
+				} );
+
+			stream.pipe( conventionalCommitsParser( parserOptions ) )
+				.pipe( concat( data => {
+					const commits = conventionalCommitsFilter( data )
+						.map( commit => transformCommit( commit ) )
+						.reduce( ( allCommits, commit ) => {
+							if ( Array.isArray( commit ) ) {
+								allCommits.push( ...commit );
+							} else {
+								allCommits.push( commit );
+							}
+
+							return allCommits;
+						}, [] )
+						.filter( commit => commit );
+
+					stream.destroy();
+
+					return resolve( commits );
+				} ) );
+		} );
+	}
+
+	function exec( command ) {
+		return tools.shExec( command, { verbosity: 'error' } );
+	}
+};

package/lib/utils/getnewversiontype.js

@@ -0,0 +1,53 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+/**
+ * Proposes new version based on commits.
+ *
+ * @param {Array.<Commit>} commits
+ * @returns {String|null}
+ */
+module.exports = function getNewVersionType( commits ) {
+	// No commits = no changes.
+	if ( !commits.length ) {
+		return 'skip';
+	}
+
+	const publicCommits = commits.filter( commit => commit.isPublicCommit );
+
+	// No public commits = internal changes.
+	if ( !publicCommits.length ) {
+		return 'internal';
+	}
+
+	let newFeatures = false;
+	let minorBreakingChanges = false;
+
+	for ( const commit of publicCommits ) {
+		for ( const note of commit.notes ) {
+			if ( note.title === 'MAJOR BREAKING CHANGES' || note.title === 'BREAKING CHANGES' ) {
+				return 'major';
+			}
+
+			/* istanbul ignore else */
+			if ( note.title === 'MINOR BREAKING CHANGES' ) {
+				minorBreakingChanges = true;
+			}
+		}
+
+		if ( commit.rawType === 'Feature' ) {
+			newFeatures = true;
+		}
+	}
+
+	// Repository has new features or minor breaking changes.
+	if ( minorBreakingChanges || newFeatures ) {
+		return 'minor';
+	}
+
+	return 'patch';
+};

package/lib/utils/getpackagejson.js

@@ -0,0 +1,24 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs' );
+const path = require( 'path' );
+
+/**
+ * Returns object from `package.json`.
+ *
+ * This function is helpful for testing the whole process. Allows mocking the file
+ * instead of create the fixtures.
+ *
+ * @param {String} [cwd=process.cwd()] Where to look for package.json.
+ * @returns {Object}
+ */
+module.exports = function getPackageJson( cwd = process.cwd() ) {
+	return JSON.parse(
+		fs.readFileSync( path.join( cwd, 'package.json' ), 'utf-8' )
+	);
+};

package/lib/utils/getpackagespaths.js

@@ -0,0 +1,90 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const path = require( 'path' );
+const minimatch = require( 'minimatch' );
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+const getPackageJson = require( './getpackagejson' );
+
+/**
+ * Returns an object with two collections of paths to packages which are located in single repository.
+ * Those packages must be defined as dependencies in the repository found in `options.cwd`.
+ *
+ *   - The first one is marked as `matched` and means that packages specified in a path (which is a combination of values specified as
+ *     `options.cwd` and  `options.packages`) match to given criteria.
+ *   - The second one is marked as `skipped` and means that packages should not be processed. They were listed as packages to skip
+ *     (`options.skipPackages` or don't mach to `options.scope`).
+ *
+ * @param {Object} options
+ * @param {String} options.cwd Current work directory.
+ * @param {String|null} options.packages Name of directory where to look for packages. If `null`, only repository specified under
+ * `options.cwd` will be returned.
+ * @param {String|Array.<String>} options.skipPackages Glob pattern(s) which describes which packages should be skipped.
+ * @param {String} [options.scope] Package names have to match to specified glob pattern.
+ * @param {Boolean} [options.skipMainRepository=false] If set on true, package found in `options.cwd` will be skipped.
+ * @returns {PathsCollection}
+ */
+module.exports = function getPackagesPaths( options ) {
+	const pathsCollection = {
+		matched: new Set(),
+		skipped: new Set()
+	};
+
+	if ( options.skipMainRepository ) {
+		pathsCollection.skipped.add( options.cwd );
+	} else {
+		pathsCollection.matched.add( options.cwd );
+	}
+
+	if ( !options.packages ) {
+		return pathsCollection;
+	}
+
+	const packagesPath = path.join( options.cwd, options.packages );
+	const skipPackages = Array.isArray( options.skipPackages ) ? options.skipPackages : [ options.skipPackages ];
+
+	for ( const directory of tools.getDirectories( packagesPath ) ) {
+		const dependencyPath = path.join( packagesPath, directory );
+
+		try {
+			const dependencyName = getPackageJson( dependencyPath ).name;
+
+			if ( isValidPackage( dependencyName ) ) {
+				pathsCollection.matched.add( dependencyPath );
+			} else {
+				pathsCollection.skipped.add( dependencyPath );
+			}
+		} catch ( err ) {
+			/* istanbul ignore next */
+			console.warn( `Missing "package.json file in "${ dependencyPath }". Skipping.` );
+		}
+	}
+
+	return pathsCollection;
+
+	function isValidPackage( packageName ) {
+		for ( const skipPackageGlob of skipPackages ) {
+			if ( minimatch( packageName, skipPackageGlob ) ) {
+				return false;
+			}
+		}
+
+		if ( options.scope ) {
+			return minimatch( packageName, options.scope );
+		}
+
+		return true;
+	}
+};
+
+/**
+ * @typedef {Object} PathsCollection
+ *
+ * @property {Set.<String>} matched Packages that match given criteria.
+ *
+ * @property {Set.<String>} skipped Packages that do not match given criteria.
+ */

package/lib/utils/getpackagestorelease.js

@@ -0,0 +1,152 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const executeOnPackages = require( './executeonpackages' );
+const getPackageJson = require( './getpackagejson' );
+
+/**
+ * Returns a list of packages which should be releases based on changes in a changelog file and tags created in Git repository.
+ *
+ * @param {Set} pathsToPackages A collection of paths to packages that should be checked.
+ * @param {Object} options
+ * @param {String} options.changes A description of changes for the main repository. It should contain a script-friendly list that provides
+ * new versions for parsed packages. If didn't find, `options.version` will be used instead.
+ * @param {String} options.version New version for the main repository.
+ * @returns {Promise.<Map.<String, ReleaseDetails>>}
+ */
+module.exports = function getPackagesToRelease( pathsToPackages, options ) {
+	const cwd = process.cwd();
+	const packagesToRelease = new Map();
+
+	return executeOnPackages( pathsToPackages, filterPackagesToRelease )
+		.then( () => {
+			process.chdir( cwd );
+
+			return Promise.resolve( packagesToRelease );
+		} );
+
+	function filterPackagesToRelease( repositoryPath ) {
+		process.chdir( repositoryPath );
+
+		const packageJson = getPackageJson();
+		const repositoryName = packageJson.name;
+
+		let newVersion;
+
+		// For the main package/repository use the version specified as `options.cwd`.
+		// For the rest packages, find a version in the changelog file.
+		if ( repositoryPath === cwd ) {
+			newVersion = options.version;
+		} else {
+			newVersion = findVersionInChangelog( options.changes, repositoryName );
+		}
+
+		// If these versions aren't equal, it means that the package is ready to release
+		// because we assume that a version from `package.json` is the latest.
+		if ( newVersion && packageJson.version !== newVersion ) {
+			packagesToRelease.set( repositoryName, {
+				previousVersion: packageJson.version,
+				version: newVersion
+			} );
+		}
+
+		return Promise.resolve();
+	}
+};
+
+// Search for a new version for specified package in the main changelog description.
+// It must be defined as following:
+//
+//      [packageName](https://www.npmjs.com/package/packageName): v0.0.1 => v1.0.0
+//
+// where:
+//   `v0.0.1` is the current version (already published),
+//   `v1.0.0` is the new version what we're looking for.
+//
+// or:
+//
+//      [packageName](https://www.npmjs.com/package/packageName): v0.0.1
+//
+// where:
+//   `v0.0.1` is the current version (not published yet).
+//
+// The function handles pre-release, so, e.g. `v1.0.0.alpha.0` is also a proper input.
+//
+// Keep in mind that the dash (`-`) is a separator of the pre-release. Other characters are not allowed
+// and npm will not publish a package if its version does not contain the symbol.
+//
+// @param {String} changelog Changes.
+// @param {String} packageName Package to look.
+// @returns {String|null} `null` if the version was not found.
+function findVersionInChangelog( changelog, packageName ) {
+	// Pick: `x.y.z` or `x.y.z-prerelease.n`, assumptions: `x, y, z, n = { 0, 1, 2, ... }`.
+	const semVer = '\\d+\\.\\d+\\.\\d+(.[a-z\\d.]+)?';
+
+	const existingPackageRegExp = new RegExp( `\\[${ packageName.replace( '/', '\\/' ) }\\].*v(${ semVer })+\\ (=>) v(${ semVer })` );
+	// Groups:
+	// 1. Previous version.
+	// 2. Previous version - pre-release part.
+	// 3. "=>" character that suggests that the package exists on npm.
+	// 4. New version.
+	// 5. New version - pre-release part.
+
+	let match = changelog.match( existingPackageRegExp );
+
+	// The package exists on npm.
+	if ( match ) {
+		// The version does not match to `x.y.z-prerelease.n`, npm will not allow publish it.
+		if ( match[ 5 ] && !match[ 5 ].startsWith( '-' ) ) {
+			return null;
+		}
+
+		return match[ 4 ];
+	}
+
+	// At this stage, we know that it will be the first release of `packageName`.
+	// If the specified version is correct, let's use it.
+	const newPackageRegExp = new RegExp( `\\[${ packageName.replace( '/', '\\/' ) }\\].*v(${ semVer })` );
+	// Groups:
+	// 1. New version.
+	// 2. New version - pre-release part.
+
+	match = changelog.match( newPackageRegExp );
+
+	if ( !match ) {
+		return null;
+	}
+
+	// The version does not match to `x.y.z-prerelease.n`, npm will not allow publish it.
+	if ( match[ 2 ] && !match[ 2 ].startsWith( '-' ) ) {
+		return null;
+	}
+
+	return match[ 1 ];
+}
+
+/**
+ * @typedef {Object} ReleaseDetails
+ *
+ * @property {String} version The latest version of the package.
+ *
+ * @property {String|null} [previousVersion] Previous version of the package.
+ *
+ * @property {String} [changes] Description of changes for specified `version`. Should be taken from the changelog file.
+ *
+ * @property {String} [repositoryOwner] A name of organization that publishes the repository.
+ * E.g. for "ckeditor/ckeditor5" it is "ckeditor".
+ *
+ * @property {String} [repositoryName] A name of the repository.
+ * E.g. for "ckeditor/ckeditor5" it is "ckeditor5".
+ *
+ * @property {String} [npmVersion] The latest version of package published on NPM.
+ *
+ * @property {Boolean} [shouldReleaseOnNpm] Whether the package should be published on NPM.
+ *
+ * @property {String} [githubVersion] The latest version of package published on Github.
+ *
+ * @property {Boolean} [shouldReleaseOnGithub] Whether the package should have created a release on GitHub..
+ */

package/lib/utils/getwriteroptions.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 fs = require( 'fs' );
+const path = require( 'path' );
+const templatePath = path.join( __dirname, '..', 'templates' );
+const { getTypeOrder } = require( './transformcommitutils' );
+
+/**
+ * @param {Function|Object} transform
+ * @returns {Object}
+ */
+module.exports = function getWriterOptions( transform ) {
+	return {
+		transform,
+		groupBy: 'type',
+		commitGroupsSort: sortFunction,
+		commitsSort: [ 'subject' ],
+		noteGroupsSort: sortFunction,
+		mainTemplate: fs.readFileSync( path.join( templatePath, 'template.hbs' ), 'utf-8' ),
+		headerPartial: fs.readFileSync( path.join( templatePath, 'header.hbs' ), 'utf-8' ),
+		commitPartial: fs.readFileSync( path.join( templatePath, 'commit.hbs' ), 'utf-8' ),
+		footerPartial: fs.readFileSync( path.join( templatePath, 'footer.hbs' ), 'utf-8' )
+	};
+};
+
+function sortFunction( a, b ) {
+	return getTypeOrder( a.title ) - getTypeOrder( b.title );
+}

package/lib/utils/parseroptions.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';
+
+module.exports = {
+	mergePattern: /^Merge .*$/,
+	headerPattern: /^([^:]+): (.*)$/,
+	headerCorrespondence: [
+		'type',
+		'subject'
+	],
+	noteKeywords: [
+		'MAJOR BREAKING CHANGES',
+		'MAJOR BREAKING CHANGE',
+		'MINOR BREAKING CHANGES',
+		'MINOR BREAKING CHANGE',
+		'BREAKING CHANGES', // It will be treated as "MAJOR BREAKING CHANGES"
+		'BREAKING CHANGE' // An alias for "BREAKING CHANGES".
+	],
+	revertPattern: /^Revert:\s([\s\S]*?)\s*This reverts commit (\w*)\./,
+	revertCorrespondence: [ 'header', 'hash' ],
+	referenceActions: []
+};