relion 0.2.0 → 0.3.0

package/src/lib/lifecycles/bump.js

@@ -1,242 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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) {
-	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

@@ -1,67 +0,0 @@
-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) {
-	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

@@ -1,61 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,34 +0,0 @@
-/*
-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
-}