relion 0.2.0 → 0.4.0

package/src/index.js

@@ -1,75 +0,0 @@
-import bump, { getNewVersion } from './lib/lifecycles/bump.js'
-import changelog from './lib/lifecycles/changelog.js'
-import commit from './lib/lifecycles/commit.js'
-import { readFileSync } from 'fs'
-import tag from './lib/lifecycles/tag.js'
-import defaults from './defaults.js'
-import { mergician } from 'mergician'
-import { execSync } from 'child_process'
-
-export default async function relion(argv) {
-	let args = mergician(defaults, argv)
-	if (args.profile) args = mergeProfileConfig(args)
-
-	if (args.all) args.bump = args.changelog = args.commit = args.tag = true
-
-	const currentVersion = getCurrentVersion()
-	const newVersion = await getNewVersion(args, currentVersion)
-	args.context.version = newVersion
-	args.context.newTag = args.tagPrefix + newVersion
-
-	if (lastCommitHasTag()) {
-		// use the current version as the new version if there's no new commits
-		// to avoid empty new release changelog generation
-		args.context.version = currentVersion
-
-		if (args.releaseCount === 1) {
-			// genearate the last release changelog
-			args.releaseCount = 2
-		}
-	}
-
-	if (args.bump) await bump(args, newVersion)
-	if (args.changelog) await changelog(args, newVersion)
-	if (args.commit) await commit(args, newVersion)
-	if (args.tag) await tag(newVersion, false, args)
-}
-
-function getCurrentVersion() {
-	const packageJsonContent = readFileSync('package.json', 'utf-8')
-	return /"version".*?"(.*?)"/.exec(packageJsonContent)?.[1]
-}
-
-function lastCommitHasTag() {
-	const lastCommit = execSync('git rev-parse HEAD').toString().trim()
-	const tags = execSync(`git tag --points-at ${lastCommit}`).toString().trim()
-	return !!tags
-}
-
-/**
- * Merge profile config if args.profile is specified.
- * Merges args._<profile> into args, then deletes args._<profile>.
- */
-function mergeProfileConfig(args) {
-	function uniqBy(arr, keyFn) {
-		const seen = new Set()
-		return arr.filter((item) => {
-			const key = keyFn(item)
-			if (seen.has(key)) return false
-			seen.add(key)
-			return true
-		})
-	}
-
-	const profileKey = `_${args.profile}`
-	const merged = mergician({
-		prependArrays: true,
-		dedupArrays: true,
-	})(args, structuredClone(args[profileKey]))
-
-	const dedupedTypes = uniqBy(merged.preset.types, item => item.type)
-	merged.preset.types = dedupedTypes
-
-	delete merged[profileKey]
-	return merged
-}

package/src/lib/checkpoint.js

@@ -1,23 +0,0 @@
-import chalk from 'chalk'
-import figures from 'figures'
-import util from 'util'
-
-export default function (argv, msg, args, figure) {
-	const defaultFigure = argv.dryRun
-		? chalk.yellow(figures.tick)
-		: chalk.green(figures.tick)
-	if (!argv.silent) {
-		console.info(
-			(figure || defaultFigure)
-			+ ' '
-			+ util.format.apply(
-				util,
-				[msg].concat(
-					args.map(function (arg) {
-						return chalk.bold(arg)
-					}),
-				),
-			),
-		)
-	}
-}

package/src/lib/configuration.js

@@ -1,35 +0,0 @@
-import path from 'path'
-import { findUpSync } from 'find-up'
-import { readFileSync } from 'fs'
-import { pathToFileURL } from 'url'
-
-const CONFIGURATION_FILES = [
-	'', '.json', '.js', '.cjs', '.mjs', '.ts']
-	.map(ext => `.versionrc${ext}`)
-
-export async function getConfiguration() {
-	let config = {}
-	const configPath = findUpSync(CONFIGURATION_FILES)
-	if (!configPath) return config
-
-	const ext = path.extname(configPath)
-	const regex = /^\.([cm]?js|ts)$/
-	if (regex.test(ext)) {
-		const exportedConfig = (await import(pathToFileURL(configPath).href)).default
-		if (typeof exportedConfig === 'function') {
-			config = exportedConfig()
-		}
-		else {
-			config = exportedConfig
-		}
-	}
-	else {
-		config = JSON.parse(readFileSync(configPath))
-	}
-
-	if (typeof config !== 'object') {
-		throw Error(`[relion] Invalid configuration in ${configPath} provided. Expected an object but found ${typeof config}.`)
-	}
-
-	return config
-}

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

@@ -1,52 +0,0 @@
-/**
- * modified from <https://github.com/egoist/detect-package-manager/blob/main/src/index.ts>
- * the original code is licensed under MIT
- * modified to support only detecting lock file and not detecting global package manager
- */
-
-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
-	}
-}
-
-function getTypeofLockFile(cwd = '.') {
-	return Promise.all([
-		pathExists(resolve(cwd, 'yarn.lock')),
-		pathExists(resolve(cwd, 'package-lock.json')),
-		pathExists(resolve(cwd, 'pnpm-lock.yaml')),
-	]).then(([isYarn, isNpm, isPnpm]) => {
-		let value = null
-
-		if (isYarn) {
-			value = 'yarn'
-		}
-		else if (isPnpm) {
-			value = 'pnpm'
-		}
-		else if (isNpm) {
-			value = 'npm'
-		}
-
-		return value
-	})
-}
-
-export async function detectPMByLockFile(cwd) {
-	const type = await getTypeofLockFile(cwd)
-	if (type) {
-		return type
-	}
-
-	return 'npm'
-}

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

@@ -1,4 +0,0 @@
-export default function (args) {
-	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 +0,0 @@
-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

@@ -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))
-}