relion 0.1.1

package/src/lib/latest-semver-tag.js

@@ -0,0 +1,34 @@
+import * as gitSemverTags from 'git-semver-tags';
+import semver from 'semver';
+
+export default function ({ tagPrefix, prerelease }) {
+	return new Promise((resolve, reject) => {
+		gitSemverTags({ tagPrefix }, function (err, tags) {
+			if (err) return reject(err);
+			else if (!tags.length) return resolve('1.0.0');
+			// Respect tagPrefix
+			tags = tags.map((tag) => tag.replace(new RegExp('^' + tagPrefix), ''));
+			if (prerelease) {
+				// ignore any other prelease tags
+				tags = tags.filter((tag) => {
+					if (!semver.valid(tag)) return false;
+					if (!semver.prerelease(tag)) {
+						// include all non-prerelease versions
+						return true;
+					}
+					// check if the name of the prerelease matches the one we are looking for
+					if (semver.prerelease(tag)[0] === prerelease) {
+						return true;
+					}
+					return false;
+				});
+			}
+			// ensure that the largest semver tag is at the head.
+			tags = tags.map((tag) => {
+				return semver.clean(tag);
+			});
+			tags.sort(semver.rcompare);
+			return resolve(tags[0]);
+		});
+	});
+}

package/src/lib/lifecycles/bump.js

@@ -0,0 +1,234 @@
+import checkpoint from '../checkpoint.js';
+import { Bumper } from 'conventional-recommended-bump';
+import fs from 'fs';
+import DotGitignore from 'dotgitignore';
+import path from 'path';
+import runLifecycleScript from '../run-lifecycle-script.js';
+import semver from 'semver';
+import writeFile from '../write-file.js';
+import { resolveUpdaterObjectFromArgument } from '../updaters/index.js';
+let configsToUpdate = {};
+const sanitizeQuotesRegex = /['"]+/g;
+
+async function Bump(args, newVersion) {
+	// reset the cache of updated config files each
+	// time we perform the version bump step.
+	configsToUpdate = {};
+
+	if (
+		args.releaseAs &&
+		!(['major', 'minor', 'patch'].includes(args.releaseAs.toLowerCase()) || semver.valid(args.releaseAs))
+	) {
+		throw new Error("releaseAs must be one of 'major', 'minor' or 'patch', or a valid semvar version.");
+	}
+
+	await runLifecycleScript(args, 'prerelease');
+	const stdout = await runLifecycleScript(args, 'prebump');
+	if (stdout?.trim().length) {
+		const prebumpString = stdout.trim().replace(sanitizeQuotesRegex, '');
+		if (semver.valid(prebumpString)) args.releaseAs = prebumpString;
+	}
+	updateConfigs(args, newVersion);
+	await runLifecycleScript(args, 'postbump');
+	return newVersion;
+}
+
+Bump.getUpdatedConfigs = function () {
+	return configsToUpdate;
+};
+
+/**
+ * Get the new version number
+ * @param args
+ * @param version
+ * @returns Promise<string>
+ */
+export async function getNewVersion(args, version) {
+	let newVersion = version;
+	if (semver.valid(args.releaseAs)) {
+		const releaseAs = new semver.SemVer(args.releaseAs);
+		if (
+			isString(args.prerelease) &&
+			releaseAs.prerelease.length &&
+			releaseAs.prerelease.slice(0, -1).join('.') !== args.prerelease
+		) {
+			// If both releaseAs and the prerelease identifier are supplied, they must match. The behavior
+			// for a mismatch is undefined, so error out instead.
+			throw new Error('releaseAs and prerelease have conflicting prerelease identifiers');
+		} else if (isString(args.prerelease) && releaseAs.prerelease.length) {
+			newVersion = releaseAs.version;
+		} else if (isString(args.prerelease)) {
+			newVersion = `${releaseAs.major}.${releaseAs.minor}.${releaseAs.patch}-${args.prerelease}.0`;
+		} else {
+			newVersion = releaseAs.version;
+		}
+
+		// Check if the previous version is the same version and prerelease, and increment if so
+		if (
+			isString(args.prerelease) &&
+			['prerelease', null].includes(semver.diff(version, newVersion)) &&
+			semver.lte(newVersion, version)
+		) {
+			newVersion = semver.inc(version, 'prerelease', args.prerelease);
+		}
+
+		// Append any build info from releaseAs
+		newVersion = semvarToVersionStr(newVersion, releaseAs.build);
+	} else {
+		const release = await bumpVersion(args.releaseAs, version, args);
+		const releaseType = getReleaseType(args.prerelease, release.releaseType, version);
+
+		newVersion = semver.inc(version, releaseType, args.prerelease);
+	}
+	return newVersion;
+}
+
+/**
+ * Convert a semver object to a full version string including build metadata
+ * @param {string} semverVersion The semvar version string
+ * @param {string[]} semverBuild An array of the build metadata elements, to be joined with '.'
+ * @returns {string}
+ */
+function semvarToVersionStr(semverVersion, semverBuild) {
+	return [semverVersion, semverBuild.join('.')].filter(Boolean).join('+');
+}
+
+function getReleaseType(prerelease, expectedReleaseType, currentVersion) {
+	if (isString(prerelease)) {
+		if (isInPrerelease(currentVersion)) {
+			if (
+				shouldContinuePrerelease(currentVersion, expectedReleaseType) ||
+				getTypePriority(getCurrentActiveType(currentVersion)) > getTypePriority(expectedReleaseType)
+			) {
+				return 'prerelease';
+			}
+		}
+
+		return 'pre' + expectedReleaseType;
+	} else {
+		return expectedReleaseType;
+	}
+}
+
+function isString(val) {
+	return typeof val === 'string';
+}
+
+/**
+ * if a version is currently in pre-release state,
+ * and if it current in-pre-release type is same as expect type,
+ * it should continue the pre-release with the same type
+ *
+ * @param version
+ * @param expectType
+ * @return {boolean}
+ */
+function shouldContinuePrerelease(version, expectType) {
+	return getCurrentActiveType(version) === expectType;
+}
+
+function isInPrerelease(version) {
+	return Array.isArray(semver.prerelease(version));
+}
+
+const TypeList = ['major', 'minor', 'patch'].reverse();
+
+/**
+ * extract the in-pre-release type in target version
+ *
+ * @param version
+ * @return {string}
+ */
+function getCurrentActiveType(version) {
+	const typelist = TypeList;
+	for (let i = 0; i < typelist.length; i++) {
+		if (semver[typelist[i]](version)) {
+			return typelist[i];
+		}
+	}
+}
+
+/**
+ * calculate the priority of release type,
+ * major - 2, minor - 1, patch - 0
+ *
+ * @param type
+ * @return {number}
+ */
+function getTypePriority(type) {
+	return TypeList.indexOf(type);
+}
+
+async function bumpVersion(releaseAs, currentVersion, args) {
+	if (releaseAs) {
+		return {
+			releaseType: releaseAs,
+		};
+	} else {
+		const recommendation = await getRecommendedBump(args, currentVersion);
+		if (recommendation) {
+			return recommendation;
+		} else {
+			throw new Error('No recommendation found');
+		}
+	}
+}
+
+async function getRecommendedBump(args, currentVersion) {
+	const bumper = new Bumper(args.path);
+	bumper.loadPreset({
+		preMajor: semver.lt(currentVersion, '1.0.0'),
+		...args.preset,
+	});
+	bumper.tag({
+		tagPrefix: args.tagPrefix,
+		lernaPackage: args.lernaPackage,
+	});
+	bumper.commits({}, args.parserOpts);
+	const recommendation = await bumper.bump();
+	return recommendation;
+}
+
+/**
+ * attempt to update the version number in provided `bumpFiles`
+ * @param args config object
+ * @param newVersion version number to update to.
+ * @return void
+ */
+function updateConfigs(args, newVersion) {
+	const dotgit = DotGitignore();
+	args.bumpFiles.forEach(async function (bumpFile) {
+		const updater = await resolveUpdaterObjectFromArgument(bumpFile);
+		if (!updater) {
+			return;
+		}
+		const configPath = path.resolve(process.cwd(), updater.filename);
+		try {
+			if (dotgit.ignore(updater.filename)) {
+				console.debug(`Not updating file '${updater.filename}', as it is ignored in Git`);
+				return;
+			}
+			const stat = fs.lstatSync(configPath);
+
+			if (!stat.isFile()) {
+				console.debug(`Not updating '${updater.filename}', as it is not a file`);
+				return;
+			}
+			const contents = fs.readFileSync(configPath, 'utf8');
+			const newContents = updater.updater.writeVersion(contents, newVersion);
+			const realNewVersion = updater.updater.readVersion(newContents);
+			checkpoint(args, 'bumping version in ' + updater.filename + ' from %s to %s', [
+				updater.updater.readVersion(contents),
+				realNewVersion,
+			]);
+			writeFile(args, configPath, newContents);
+			// flag any config files that we modify the version # for
+			// as having been updated.
+			configsToUpdate[updater.filename] = true;
+		} catch (err) {
+			if (err.code !== 'ENOENT') console.warn(err.message);
+		}
+	});
+}
+
+export default Bump;

package/src/lib/lifecycles/changelog.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import checkpoint from '../checkpoint.js';
+import conventionalChangelog from 'conventional-changelog';
+import fs from 'fs';
+import runLifecycleScript from '../run-lifecycle-script.js';
+import writeFile from '../write-file.js';
+const START_OF_LAST_RELEASE_PATTERN = /(^#.*?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m;
+
+async function Changelog(args, newVersion) {
+	await runLifecycleScript(args, 'prechangelog');
+	await outputChangelog(args, newVersion);
+	await runLifecycleScript(args, 'postchangelog');
+}
+
+Changelog.START_OF_LAST_RELEASE_PATTERN = START_OF_LAST_RELEASE_PATTERN;
+
+export default Changelog;
+
+/**
+ * Front matter is only extracted and therefore retained in final output where Changelog "header" begins with #Changelog,
+ * e.g. meets Standard-Version (last release) or relion(current) format
+ */
+function extractFrontMatter(oldContent) {
+	const headerStart = oldContent.indexOf('# Changelog');
+	return headerStart !== -1 || headerStart !== 0
+		? oldContent.substring(0, headerStart)
+		: '';
+}
+
+/**
+ * find the position of the last release and remove header
+ */
+function extractChangelogBody(oldContent) {
+	const oldContentStart = oldContent.search(START_OF_LAST_RELEASE_PATTERN);
+	return oldContentStart !== -1
+		? oldContent.substring(oldContentStart)
+		: oldContent;
+}
+
+function outputChangelog(args, newVersion) {
+	return new Promise((resolve, reject) => {
+		createIfMissing(args);
+		const header = args.preset.header;
+
+		const oldContent =
+			args.dryRun || args.releaseCount === 0
+				? ''
+				: fs.readFileSync(args.infile, 'utf-8');
+
+		const oldContentBody = extractChangelogBody(oldContent);
+
+		const changelogFrontMatter = extractFrontMatter(oldContent);
+
+		let content = '';
+		const changelogStream = conventionalChangelog(
+			{
+				preset: args.preset,
+				tagPrefix: args.tagPrefix,
+				releaseCount: args.releaseCount,
+				...(args.verbose
+					? {
+							debug: console.info.bind(console, 'conventional-recommended-bump'),
+						}
+					: {}),
+			},
+			args.context,
+			{ merges: null, path: args.path, showSignature: false },
+			args.parserOpts,
+			args.writerOpts,
+		).on('error', function (err) {
+			return reject(err);
+		});
+
+		changelogStream.on('data', function (buffer) {
+			content += buffer.toString();
+		});
+
+		changelogStream.on('end', function () {
+			checkpoint(args, 'outputting changes to %s', [args.infile]);
+			if (args.dryRun)
+				console.info(`\n---\n${chalk.gray(content.trim())}\n---\n`);
+			else
+				writeFile(
+					args,
+					args.infile,
+					changelogFrontMatter +
+					header +
+					(content + oldContentBody).replace(/\n+$/, '\n'),
+				);
+			return resolve();
+		});
+	});
+}
+
+function createIfMissing(args) {
+	try {
+		fs.accessSync(args.infile, fs.F_OK);
+	} catch (err) {
+		if (err.code === 'ENOENT') {
+			checkpoint(args, 'created %s', [args.infile]);
+			args.outputUnreleased = true;
+			writeFile(args, args.infile, '\n');
+		}
+	}
+}

package/src/lib/lifecycles/commit.js

@@ -0,0 +1,67 @@
+import bump from '../lifecycles/bump.js';
+import checkpoint from '../checkpoint.js';
+import formatCommitMessage from '../format-commit-message.js';
+import path from 'path';
+import runExecFile from '../run-execFile.js';
+import runLifecycleScript from '../run-lifecycle-script.js';
+
+export default async function (args, newVersion) {
+	const message = await runLifecycleScript(args, 'precommit');
+	if (message && message.length) args.preset.releaseCommitMessageFormat = message;
+	await execCommit(args, newVersion);
+	await runLifecycleScript(args, 'postcommit');
+}
+
+async function execCommit(args, newVersion) {
+	let msg = 'committing %s';
+	let paths = [];
+	const verify = args.verify === false || args.n ? ['--no-verify'] : [];
+	const sign = args.sign ? ['-S'] : [];
+	const signoff = args.signoff ? ['--signoff'] : [];
+	const toAdd = [];
+
+	// only start with a pre-populated paths list when CHANGELOG processing is not skipped
+	if (args.changelog) {
+		paths = [args.infile];
+		toAdd.push(args.infile);
+	}
+
+	// commit any of the config files that we've updated
+	// the version # for.
+	Object.keys(bump.getUpdatedConfigs()).forEach(function (p) {
+		paths.unshift(p);
+		toAdd.push(path.relative(process.cwd(), p));
+
+		// account for multiple files in the output message
+		if (paths.length > 1) {
+			msg += ' and %s';
+		}
+	});
+
+	if (args.commitAll) {
+		msg += ' and %s';
+		paths.push('all staged files');
+	}
+
+	checkpoint(args, msg, paths);
+
+	// nothing to do, exit without commit anything
+	if (
+		!args.commitAll &&
+		!args.changelog &&
+		!args.bump &&
+		toAdd.length === 0
+	) {
+		return;
+	}
+
+	await runExecFile(args, 'git', ['add'].concat(toAdd));
+	await runExecFile(
+		args,
+		'git',
+		['commit'].concat(verify, sign, signoff, args.commitAll ? [] : toAdd, [
+			'-m',
+			`${formatCommitMessage(args)}`,
+		]),
+	);
+}

package/src/lib/lifecycles/tag.js

@@ -0,0 +1,59 @@
+import bump from '../lifecycles/bump.js';
+import chalk from 'chalk';
+import checkpoint from '../checkpoint.js';
+import figures from 'figures';
+import formatCommitMessage from '../format-commit-message.js';
+import runExecFile from '../run-execFile.js';
+import runLifecycleScript from '../run-lifecycle-script.js';
+import { detectPMByLockFile } from '../detect-package-manager.js';
+
+export default async function (newVersion, pkgPrivate, args) {
+	await runLifecycleScript(args, 'pretag');
+	await execTag(newVersion, pkgPrivate, args);
+	await runLifecycleScript(args, 'posttag');
+}
+
+async function detectPublishHint() {
+	const npmClientName = await detectPMByLockFile();
+	const publishCommand = 'publish';
+	return `${npmClientName} ${publishCommand}`;
+}
+
+async function execTag(newVersion, pkgPrivate, args) {
+	const tagOption = [];
+	if (args.sign) {
+		tagOption.push('-s');
+	} else {
+		tagOption.push('-a');
+	}
+	if (args.tagForce) {
+		tagOption.push('-f');
+	}
+	checkpoint(args, 'tagging release %s%s', [args.tagPrefix, newVersion]);
+	await runExecFile(args, 'git', [
+		'tag',
+		...tagOption,
+		args.tagPrefix + newVersion,
+		'-m',
+		`${formatCommitMessage(args)}`,
+	]);
+	const currentBranch = await runExecFile('', 'git', [
+		'rev-parse',
+		'--abbrev-ref',
+		'HEAD',
+	]);
+	let message = 'git push --follow-tags origin ' + currentBranch.trim();
+	if (pkgPrivate !== true && bump.getUpdatedConfigs()['package.json']) {
+		const npmPublishHint = args.npmPublishHint || (await detectPublishHint());
+		message += ` && ${npmPublishHint}`;
+		if (args.prerelease !== undefined) {
+			if (args.prerelease === '') {
+				message += ' --tag prerelease';
+			} else {
+				message += ' --tag ' + args.prerelease;
+			}
+		}
+	}
+
+	checkpoint(args, 'Run `%s` to publish', [message], chalk.blue(figures.info));
+}

package/src/lib/print-error.js

@@ -0,0 +1,15 @@
+import chalk from 'chalk';
+
+export default function (args, msg, opts) {
+	if (!args.silent) {
+		opts = Object.assign(
+			{
+				level: 'error',
+				color: 'red',
+			},
+			opts,
+		);
+
+		console[opts.level](chalk[opts.color](msg));
+	}
+}

package/src/lib/run-exec.js

@@ -0,0 +1,19 @@
+import { promisify } from 'util';
+import printError from './print-error.js';
+import { exec as execCb } from 'child_process';
+
+const exec = promisify(execCb);
+
+export default async function (args, cmd) {
+	if (args.dryRun) return;
+	try {
+		const { stderr, stdout } = await exec(cmd);
+		// If exec returns content in stderr, but no error, print it as a warning
+		if (stderr) printError(args, stderr, { level: 'warn', color: 'yellow' });
+		return stdout;
+	} catch (error) {
+		// If exec returns an error, print it and exit with return code 1
+		printError(args, error.stderr || error.message);
+		throw error;
+	}
+}

package/src/lib/run-execFile.js

@@ -0,0 +1,19 @@
+import { promisify } from 'util';
+import printError from './print-error.js';
+import { execFile as execFileCb } from 'child_process';
+
+const execFile = promisify(execFileCb);
+
+export default async function (args, cmd, cmdArgs) {
+	if (args.dryRun) return;
+	try {
+		const { stderr, stdout } = await execFile(cmd, cmdArgs);
+		// If execFile returns content in stderr, but no error, print it as a warning
+		if (stderr) printError(args, stderr, { level: 'warn', color: 'yellow' });
+		return stdout;
+	} catch (error) {
+		// If execFile returns an error, print it and exit with return code 1
+		printError(args, error.stderr || error.message);
+		throw error;
+	}
+}

package/src/lib/run-lifecycle-script.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import checkpoint from './checkpoint.js';
+import figures from 'figures';
+import runExec from './run-exec.js';
+
+export default function (args, hookName) {
+	const scripts = args.scripts;
+	if (!scripts || !scripts[hookName]) return Promise.resolve();
+	const command = scripts[hookName];
+	checkpoint(args, 'Running lifecycle script "%s"', [hookName]);
+	checkpoint(
+		args,
+		'- execute command: "%s"',
+		[command],
+		chalk.blue(figures.info),
+	);
+	return runExec(args, command);
+}

package/src/lib/stringify-package.js

@@ -0,0 +1,34 @@
+/*
+Copyright npm, Inc
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+https://github.com/npm/stringify-package/blob/main/LICENSE
+*/
+
+'use strict';
+
+const DEFAULT_INDENT = 2;
+const CRLF = '\r\n';
+const LF = '\n';
+
+export default function stringifyPackage(data, indent, newline) {
+	indent = indent || (indent === 0 ? 0 : DEFAULT_INDENT);
+	const json = JSON.stringify(data, null, indent);
+
+	if (newline === CRLF) {
+		return json.replace(/\n/g, CRLF) + CRLF;
+	}
+
+	return json + LF;
+}