relion 0.1.1 → 0.2.0

package/src/lib/detect-package-manager.js

@@ -4,18 +4,19 @@
  * modified to support only detecting lock file and not detecting global package manager
  */
 
-import { promises as fs } from 'fs';
-import { resolve } from 'path';
+import { promises as fs } from 'fs'
+import { resolve } from 'path'
 
 /**
  * Check if a path exists
  */
 async function pathExists(p) {
 	try {
-		await fs.access(p);
-		return true;
-	} catch {
-		return false;
+		await fs.access(p)
+		return true
+	}
+	catch {
+		return false
 	}
 }
 
@@ -25,25 +26,27 @@ function getTypeofLockFile(cwd = '.') {
 		pathExists(resolve(cwd, 'package-lock.json')),
 		pathExists(resolve(cwd, 'pnpm-lock.yaml')),
 	]).then(([isYarn, isNpm, isPnpm]) => {
-		let value = null;
+		let value = null
 
 		if (isYarn) {
-			value = 'yarn';
-		} else if (isPnpm) {
-			value = 'pnpm';
-		} else if (isNpm) {
-			value = 'npm';
+			value = 'yarn'
+		}
+		else if (isPnpm) {
+			value = 'pnpm'
+		}
+		else if (isNpm) {
+			value = 'npm'
 		}
 
-		return value;
-	});
+		return value
+	})
 }
 
 export async function detectPMByLockFile(cwd) {
-	const type = await getTypeofLockFile(cwd);
+	const type = await getTypeofLockFile(cwd)
 	if (type) {
-		return type;
+		return type
 	}
 
-	return 'npm';
-}
+	return 'npm'
+}

package/src/lib/format-commit-message.js

@@ -1,4 +1,4 @@
 export default function (args) {
-	const message = String(args.preset.releaseCommitMessageFormat);
+	const message = String(args.preset.releaseCommitMessageFormat)
 	return message.replace(/{{currentTag}}/g, args.tagPrefix + args.context.version)
-}
+}

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

@@ -1,34 +1,34 @@
-import * as gitSemverTags from 'git-semver-tags';
-import semver from 'semver';
+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');
+			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), ''));
+			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.valid(tag)) return false
 					if (!semver.prerelease(tag)) {
 						// include all non-prerelease versions
-						return true;
+						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 true
 					}
-					return false;
-				});
+					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]);
-		});
-	});
-}
+				return semver.clean(tag)
+			})
+			tags.sort(semver.rcompare)
+			return resolve(tags[0])
+		})
+	})
+}

package/src/lib/lifecycles/bump.js

@@ -1,41 +1,41 @@
-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;
+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 = {};
+	configsToUpdate = {}
 
 	if (
-		args.releaseAs &&
-		!(['major', 'minor', 'patch'].includes(args.releaseAs.toLowerCase()) || semver.valid(args.releaseAs))
+		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.");
+		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');
+	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;
+		const prebumpString = stdout.trim().replace(sanitizeQuotesRegex, '')
+		if (semver.valid(prebumpString)) args.releaseAs = prebumpString
 	}
-	updateConfigs(args, newVersion);
-	await runLifecycleScript(args, 'postbump');
-	return newVersion;
+	updateConfigs(args, newVersion)
+	await runLifecycleScript(args, 'postbump')
+	return newVersion
 }
 
 Bump.getUpdatedConfigs = function () {
-	return configsToUpdate;
-};
+	return configsToUpdate
+}
 
 /**
  * Get the new version number
@@ -44,43 +44,47 @@ Bump.getUpdatedConfigs = function () {
  * @returns Promise<string>
  */
 export async function getNewVersion(args, version) {
-	let newVersion = version;
+	let newVersion = version
 	if (semver.valid(args.releaseAs)) {
-		const releaseAs = new semver.SemVer(args.releaseAs);
+		const releaseAs = new semver.SemVer(args.releaseAs)
 		if (
-			isString(args.prerelease) &&
-			releaseAs.prerelease.length &&
-			releaseAs.prerelease.slice(0, -1).join('.') !== args.prerelease
+			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;
+			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)
+			isString(args.prerelease)
+			&& ['prerelease', null].includes(semver.diff(version, newVersion))
+			&& semver.lte(newVersion, version)
 		) {
-			newVersion = semver.inc(version, 'prerelease', args.prerelease);
+			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 = 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);
+		newVersion = semver.inc(version, releaseType, args.prerelease)
 	}
-	return newVersion;
+	return newVersion
 }
 
 /**
@@ -90,28 +94,29 @@ export async function getNewVersion(args, version) {
  * @returns {string}
  */
 function semvarToVersionStr(semverVersion, semverBuild) {
-	return [semverVersion, semverBuild.join('.')].filter(Boolean).join('+');
+	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)
+				shouldContinuePrerelease(currentVersion, expectedReleaseType)
+				|| getTypePriority(getCurrentActiveType(currentVersion)) > getTypePriority(expectedReleaseType)
 			) {
-				return 'prerelease';
+				return 'prerelease'
 			}
 		}
 
-		return 'pre' + expectedReleaseType;
-	} else {
-		return expectedReleaseType;
+		return 'pre' + expectedReleaseType
+	}
+	else {
+		return expectedReleaseType
 	}
 }
 
 function isString(val) {
-	return typeof val === 'string';
+	return typeof val === 'string'
 }
 
 /**
@@ -124,14 +129,14 @@ function isString(val) {
  * @return {boolean}
  */
 function shouldContinuePrerelease(version, expectType) {
-	return getCurrentActiveType(version) === expectType;
+	return getCurrentActiveType(version) === expectType
 }
 
 function isInPrerelease(version) {
-	return Array.isArray(semver.prerelease(version));
+	return Array.isArray(semver.prerelease(version))
 }
 
-const TypeList = ['major', 'minor', 'patch'].reverse();
+const TypeList = ['major', 'minor', 'patch'].reverse()
 
 /**
  * extract the in-pre-release type in target version
@@ -140,10 +145,10 @@ const TypeList = ['major', 'minor', 'patch'].reverse();
  * @return {string}
  */
 function getCurrentActiveType(version) {
-	const typelist = TypeList;
+	const typelist = TypeList
 	for (let i = 0; i < typelist.length; i++) {
 		if (semver[typelist[i]](version)) {
-			return typelist[i];
+			return typelist[i]
 		}
 	}
 }
@@ -156,37 +161,39 @@ function getCurrentActiveType(version) {
  * @return {number}
  */
 function getTypePriority(type) {
-	return TypeList.indexOf(type);
+	return TypeList.indexOf(type)
 }
 
 async function bumpVersion(releaseAs, currentVersion, args) {
 	if (releaseAs) {
 		return {
 			releaseType: releaseAs,
-		};
-	} else {
-		const recommendation = await getRecommendedBump(args, currentVersion);
+		}
+	}
+	else {
+		const recommendation = await getRecommendedBump(args, currentVersion)
 		if (recommendation) {
-			return recommendation;
-		} else {
-			throw new Error('No recommendation found');
+			return recommendation
+		}
+		else {
+			throw new Error('No recommendation found')
 		}
 	}
 }
 
 async function getRecommendedBump(args, currentVersion) {
-	const bumper = new Bumper(args.path);
+	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;
+	})
+	bumper.commits({}, args.parserOpts)
+	const recommendation = await bumper.bump()
+	return recommendation
 }
 
 /**
@@ -196,39 +203,40 @@ async function getRecommendedBump(args, currentVersion) {
  * @return void
  */
 function updateConfigs(args, newVersion) {
-	const dotgit = DotGitignore();
+	const dotgit = DotGitignore()
 	args.bumpFiles.forEach(async function (bumpFile) {
-		const updater = await resolveUpdaterObjectFromArgument(bumpFile);
+		const updater = await resolveUpdaterObjectFromArgument(bumpFile)
 		if (!updater) {
-			return;
+			return
 		}
-		const configPath = path.resolve(process.cwd(), updater.filename);
+		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;
+				console.debug(`Not updating file '${updater.filename}', as it is ignored in Git`)
+				return
 			}
-			const stat = fs.lstatSync(configPath);
+			const stat = fs.lstatSync(configPath)
 
 			if (!stat.isFile()) {
-				console.debug(`Not updating '${updater.filename}', as it is not a file`);
-				return;
+				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);
+			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);
+			])
+			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);
+			configsToUpdate[updater.filename] = true
+		}
+		catch (err) {
+			if (err.code !== 'ENOENT') console.warn(err.message)
 		}
-	});
+	})
 }
 
-export default Bump;
+export default Bump

package/src/lib/lifecycles/changelog.js

@@ -1,57 +1,57 @@
-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;
+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');
+	await runLifecycleScript(args, 'prechangelog')
+	await outputChangelog(args, newVersion)
+	await runLifecycleScript(args, 'postchangelog')
 }
 
-Changelog.START_OF_LAST_RELEASE_PATTERN = START_OF_LAST_RELEASE_PATTERN;
+Changelog.START_OF_LAST_RELEASE_PATTERN = START_OF_LAST_RELEASE_PATTERN
 
-export default Changelog;
+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');
+	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);
+	const oldContentStart = oldContent.search(START_OF_LAST_RELEASE_PATTERN)
 	return oldContentStart !== -1
 		? oldContent.substring(oldContentStart)
-		: oldContent;
+		: oldContent
 }
 
-function outputChangelog(args, newVersion) {
+function outputChangelog(args) {
 	return new Promise((resolve, reject) => {
-		createIfMissing(args);
-		const header = args.preset.header;
+		createIfMissing(args)
+		const header = args.preset.header
 
-		const oldContent =
-			args.dryRun || args.releaseCount === 0
+		const oldContent
+			= args.dryRun || args.releaseCount === 0
 				? ''
-				: fs.readFileSync(args.infile, 'utf-8');
+				: fs.readFileSync(args.infile, 'utf-8')
 
-		const oldContentBody = extractChangelogBody(oldContent);
+		const oldContentBody = extractChangelogBody(oldContent)
 
-		const changelogFrontMatter = extractFrontMatter(oldContent);
+		const changelogFrontMatter = extractFrontMatter(oldContent)
 
-		let content = '';
+		let content = ''
 		const changelogStream = conventionalChangelog(
 			{
 				preset: args.preset,
@@ -59,8 +59,8 @@ function outputChangelog(args, newVersion) {
 				releaseCount: args.releaseCount,
 				...(args.verbose
 					? {
-							debug: console.info.bind(console, 'conventional-recommended-bump'),
-						}
+						debug: console.info.bind(console, 'conventional-recommended-bump'),
+					}
 					: {}),
 			},
 			args.context,
@@ -68,38 +68,39 @@ function outputChangelog(args, newVersion) {
 			args.parserOpts,
 			args.writerOpts,
 		).on('error', function (err) {
-			return reject(err);
-		});
+			return reject(err)
+		})
 
 		changelogStream.on('data', function (buffer) {
-			content += buffer.toString();
-		});
+			content += buffer.toString()
+		})
 
 		changelogStream.on('end', function () {
-			checkpoint(args, 'outputting changes to %s', [args.infile]);
+			checkpoint(args, 'outputting changes to %s', [args.infile])
 			if (args.dryRun)
-				console.info(`\n---\n${chalk.gray(content.trim())}\n---\n`);
+				console.info(`\n---\n${chalk.gray(content.trim())}\n---\n`)
 			else
 				writeFile(
 					args,
 					args.infile,
-					changelogFrontMatter +
-					header +
-					(content + oldContentBody).replace(/\n+$/, '\n'),
-				);
-			return resolve();
-		});
-	});
+					changelogFrontMatter
+					+ header
+					+ (content + oldContentBody).replace(/\n+$/, '\n'),
+				)
+			return resolve()
+		})
+	})
 }
 
 function createIfMissing(args) {
 	try {
-		fs.accessSync(args.infile, fs.F_OK);
-	} catch (err) {
+		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');
+			checkpoint(args, 'created %s', [args.infile])
+			args.outputUnreleased = true
+			writeFile(args, args.infile, '\n')
 		}
 	}
-}
+}