@j-ulrich/release-it-regex-bumper 2.0.0 → 3.0.2

package/index.js

@@ -1,9 +1,18 @@
+'use strict';
+
 const fs = require( 'fs' );
 const assert = require( 'assert' ).strict;
 const util = require( 'util' );
 const glob = require( 'fast-glob' );
 const chalk = require( 'chalk' );
-const _ = require( 'lodash' );
+const _ = {
+	isEmpty: require( 'lodash/isEmpty' ),
+	isNil: require( 'lodash/isNil' ),
+	isNull: require( 'lodash/isNull' ),
+	isString: require( 'lodash/isString' ),
+	isFunction: require( 'lodash/isFunction' ),
+	castArray: require( 'lodash/castArray' ),
+};
 const XRegExp = require( 'xregexp' );
 const semver = require( 'semver' );
 const { Plugin } = require( 'release-it' );
@@ -15,9 +24,17 @@ const diff = optionalRequire( 'diff' );
 const readFile = util.promisify( fs.readFile );
 const writeFile = util.promisify( fs.writeFile );
 
+const semanticVersionRegex = XRegExp(
+	// eslint-disable-next-line security/detect-unsafe-regex
+	/(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?/
+);
+const placeholderRegex = XRegExp( '\\{\\{(?<placeholder>(?:[a-z][a-z0-9_]*|\\{))(?::(?<format>.*))?\\}\\}', 'ig' );
+
+const prereleasePrefix = '-';
+const buildPrefix = '+';
 
 const defaultEncoding = 'utf-8';
-const defaultSearchRegex = XRegExp( /(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?/ );
+const defaultSearchRegex = XRegExp( '{{semver}}' );
 const defaultVersionCaptureGroup = null;
 const defaultReplace = '{{version}}';
 
@@ -25,47 +42,77 @@ const defaultReplace = '{{version}}';
 
 class RegExBumper extends Plugin {
 
+	constructor( ...args ) {
+		super( ...args );
+		this.setContext( { executionTime: new Date() } );
+	}
+
 	async getLatestVersion() {
 
 		const { in: inOptions, search: globalSearchOptions, encoding: globalEncoding } = this.options;
 		if ( _.isNil( inOptions ) ) {
-			return;
+			return undefined;
 		}
 
-		const { searchRegex: globalSearchRegex, versionCaptureGroup: globalVersionCaptureGroup } = parseSearchOptions.call( this, globalSearchOptions );
-		const { file, encoding, searchRegex, versionCaptureGroup } = parseInOptions.call( this, inOptions );
+		const context = Object.assign( {}, this.getContext(), this.config.contextOptions );
+
+		const {
+			searchRegex: globalSearchRegex,
+			flags: globalSearchFlags,
+			versionCaptureGroup: globalVersionCaptureGroup,
+		} = parseSearchOptions( globalSearchOptions );
+		const { file, encoding, searchRegex, flags: searchFlags, versionCaptureGroup } = parseInOptions( inOptions );
 
 		const effectiveEncoding = firstNotNil( encoding, globalEncoding, defaultEncoding );
 		const fileContent = await readFile( file, { encoding: effectiveEncoding } );
-		const version = await extractVersion.call( this, fileContent, firstNotNil( searchRegex, globalSearchRegex, defaultSearchRegex ),
-			firstNotNil( versionCaptureGroup, globalVersionCaptureGroup, defaultVersionCaptureGroup ) );
+		const effectiveSearchRegex = mergeSearchRegExes(
+			[ searchRegex, globalSearchRegex, defaultSearchRegex ],
+			[ searchFlags, globalSearchFlags ]
+		);
+		const replacedSearchRegex = prepareSearch( effectiveSearchRegex, context );
+		const version = await extractVersion(
+			fileContent,
+			replacedSearchRegex,
+			firstNotNil( versionCaptureGroup, globalVersionCaptureGroup, defaultVersionCaptureGroup )
+		);
 		return version;
 	}
 
-
 	async bump( version ) {
-
-		const { out: outOptions, search: globalSearchOptions, replace: globalReplace, encoding: globalEncoding } = this.options;
+		const {
+			out: outOptions,
+			search: globalSearchOptions,
+			replace: globalReplace,
+			encoding: globalEncoding,
+		} = this.options;
 		const { isDryRun } = this.config;
 		if ( _.isNil( outOptions ) ) {
 			return;
 		}
-		const context = Object.assign( {}, this.config.contextOptions );
+		const context = Object.assign( {}, this.getContext(), this.config.contextOptions );
 		if ( !context.version ) {
 			context.version = version;
 		}
 
-		const { searchRegex: globalSearchRegex } = parseSearchOptions.call( this, globalSearchOptions );
+		const { searchRegex: globalSearchRegex, flags: globalSearchFlags } = parseSearchOptions.call(
+			this,
+			globalSearchOptions
+		);
 		const expandedOutOptions = await expandOutOptionFiles.call( this, parseOutOptions.call( this, outOptions ) );
 
-		for ( const outOptions of expandedOutOptions ) {
-
-			const { files, encoding, searchRegex, replace } = outOptions;
+		/* eslint-disable no-await-in-loop */
+		for ( const outOption of expandedOutOptions ) {
+			const { files, encoding, searchRegex, flags: searchFlags, replace } = outOption;
 
 			const effectiveEncoding = firstNotNil( encoding, globalEncoding, defaultEncoding );
-			const effectiveSearchRegex = firstNotNil( searchRegex, globalSearchRegex, defaultSearchRegex );
+			const effectiveSearchRegex = mergeSearchRegExes(
+				[ searchRegex, globalSearchRegex, defaultSearchRegex ],
+				[ searchFlags, globalSearchFlags ]
+			);
 			const effectiveReplacement = firstNotNil( replace, globalReplace, defaultReplace );
 
+			const replacedSearchRegex = prepareSearch( effectiveSearchRegex, context );
+
 			for ( const file of files ) {
 
 				this.log.info( `Updating version in ${file}` );
@@ -73,26 +120,96 @@ class RegExBumper extends Plugin {
 				const fileContent = await readFile( file, { encoding: effectiveEncoding } );
 
 				if ( isDryRun ) {
-					loadDiff.call( this );
+					this.loadDiff();
 					if ( this.diff ) {
-						const processedFileContent = replaceVersion.call( this, fileContent, effectiveSearchRegex, effectiveReplacement, context );
-						await diffAndReport.call( this, fileContent, processedFileContent, file );
+						const processedFileContent = replaceVersion( fileContent, replacedSearchRegex,
+						                                             effectiveReplacement, context );
+						await this.diffAndReport( fileContent, processedFileContent, file );
 						continue;
 					}
-					await searchAndReport.call( this, fileContent, effectiveSearchRegex, file );
+					await this.searchAndReport( fileContent, replacedSearchRegex, file );
 					continue;
 				}
 
-				const processedFileContent = replaceVersion.call( this, fileContent, effectiveSearchRegex, effectiveReplacement, context );
+				const processedFileContent = replaceVersion(
+					fileContent,
+					replacedSearchRegex,
+					effectiveReplacement,
+					context
+				);
 
-				if ( processedFileContent == fileContent ) {
-					warnNoFileChange.call( this, file );
+				if ( processedFileContent === fileContent ) {
+					this.warnNoFileChange( file );
 				}
 				else {
 					await writeFile( file, processedFileContent, effectiveEncoding );
 				}
 			}
 		}
+		/* eslint-enable no-await-in-loop */
+	}
+
+	loadDiff() {
+		if ( !diff || diff instanceof Error ) {
+			this.log.info( 'Optional "diff" package not available' );
+			this.log.verbose( 'Exception was:', diff );
+		}
+		this.diff = diff;
+	}
+
+	diffAndReport( oldContent, newContent, filePath ) {
+		const { isDryRun } = this.config;
+		const diffResult = this.diff.structuredPatch( filePath, filePath, oldContent, newContent, undefined, undefined,
+			{
+				context: 0,
+			}
+		);
+
+		if ( _.isEmpty( diffResult.hunks ) ) {
+			this.warnNoFileChange( filePath );
+		}
+		diffResult.hunks.forEach( ( hunk ) => {
+			this.log.exec(
+				`Replacing at line ${hunk.oldStart}:\n` +
+					hunk.lines
+						.map( ( line ) => {
+							const lineText = '\t' + line;
+							if ( line.startsWith( '-' ) ) {
+								return chalk.red( lineText );
+							}
+							if ( line.startsWith( '+' ) ) {
+								return chalk.green( lineText );
+							}
+							return lineText;
+						} )
+						.join( '\n' ),
+				{ isDryRun }
+			);
+		} );
+	}
+
+	searchAndReport( content, searchRegex, filePath ) {
+		const { isDryRun } = this.config;
+		let foundMatch = false;
+		const lineCounter = new LineCounter( content );
+		XRegExp.forEach( content, searchRegex, ( match ) => {
+			const matchText = match[0];
+			const matchIndex = searchRegex.lastIndex - matchText.length;
+			this.log.exec(
+				`Replacing match at line ${lineCounter.lineOfIndex( matchIndex )}, ` +
+					`column ${lineCounter.columnOfIndex( matchIndex )}:\n\t` +
+					matchText,
+				{ isDryRun }
+			);
+			foundMatch = true;
+		} );
+		if ( !foundMatch ) {
+			this.warnNoFileChange( filePath );
+		}
+	}
+
+	warnNoFileChange( filePath ) {
+		this.log.warn( `File "${filePath}" did not change!` );
 	}
 
 }
@@ -106,11 +223,11 @@ function parseInOptions( options ) {
 		return { file, encoding, searchRegex, versionCaptureGroup };
 	}
 	const { file, encoding } = options;
-	const { searchRegex, versionCaptureGroup } = parseSearchOptions( options.search );
+	const { searchRegex, flags, versionCaptureGroup } = parseSearchOptions( options.search );
 	if ( !file ) {
-		throw new Error( 'Missing "file" property in "in" options' );
+		throw new Error( "Missing 'file' property in 'in' options" );
 	}
-	return { file, encoding, searchRegex, versionCaptureGroup };
+	return { file, encoding, searchRegex, flags, versionCaptureGroup };
 }
 
 function parseSearchOptions( options ) {
@@ -123,8 +240,8 @@ function parseSearchOptions( options ) {
 		return { searchRegex, versionCaptureGroup };
 	}
 	const { pattern, flags, versionCaptureGroup } = options;
-	const searchRegex = XRegExp( pattern, _.isNull( flags ) ? undefined : flags );
-	return { searchRegex, versionCaptureGroup };
+	const searchRegex = _.isNil( pattern ) ? pattern : XRegExp( pattern, _.isNull( flags ) ? undefined : flags );
+	return { searchRegex, flags, versionCaptureGroup };
 }
 
 function extractVersion( content, versionRegex, versionCaptureGroup ) {
@@ -133,39 +250,45 @@ function extractVersion( content, versionRegex, versionCaptureGroup ) {
 		throw new Error( 'Could not extract version from file' );
 	}
 	if ( !_.isNil( versionCaptureGroup ) ) {
-		if( match.hasOwnProperty( versionCaptureGroup ) ) {
-			return match[ versionCaptureGroup ];
+		if ( hasOwnProperty( match, versionCaptureGroup ) ) {
+			// object injection mitigated by checking hasOwnProperty()
+			// eslint-disable-next-line security/detect-object-injection
+			return match[versionCaptureGroup];
 		}
 	}
 	else {
-		if ( match.hasOwnProperty( 'version' ) ) {
-			return match[ 'version' ];
+		if ( hasOwnProperty( match, 'version' ) ) {
+			return match['version'];
 		}
-		if ( match.hasOwnProperty( 1 ) ) {
-			return match[ 1 ];
+		if ( hasOwnProperty( match, 1 ) ) {
+			return match[1];
 		}
 	}
 
-	return match[ 0 ];
+	return match[0];
+}
+
+function hasOwnProperty( obj, prop ) {
+	return Object.prototype.hasOwnProperty.call( obj, prop );
 }
 
 function parseOutOptions( options ) {
-	return _.castArray( options ).map( options => {
-		if ( _.isString( options ) ) {
+	return _.castArray( options ).map( ( option ) => {
+		if ( _.isString( option ) ) {
 			return {
-				files: [ options ],
+				files: [ option ],
 				encoding: null,
 				searchRegex: null,
 				replace: null,
 			};
 		}
-		const { encoding, replace } = options;
-		const { searchRegex } = parseSearchOptions( options.search );
-		const files = options.files ? _.castArray( options.files ) : [];
-		if( options.file ) {
-			files.unshift( options.file );
+		const { encoding, replace } = option;
+		const { searchRegex, flags } = parseSearchOptions( option.search );
+		const files = option.files ? _.castArray( option.files ) : [];
+		if ( option.file ) {
+			files.unshift( option.file );
 		}
-		return { files, encoding, searchRegex, replace };
+		return { files, encoding, searchRegex, flags, replace };
 	} );
 }
 
@@ -186,132 +309,167 @@ async function expandOutOptionFiles( options ) {
 	return options;
 }
 
-function loadDiff() {
-	if ( !diff || diff instanceof Error ) {
-		this.log.info( 'Optional "diff" package not available' );
-		this.log.verbose( 'Exception was:', diff );
-	}
-	this.diff = diff;
+function mergeSearchRegExes( regExCandidates, flagCandidates ) {
+	const searchRegEx = firstNotNil( ...regExCandidates );
+	const flags = firstNotNil( ...flagCandidates );
+	return XRegExp( searchRegEx.xregexp.source, flags );
 }
 
-function diffAndReport( oldContent, newContent, filePath ) {
-	const { isDryRun } = this.config;
-	const diffResult = this.diff.structuredPatch( filePath, filePath, oldContent, newContent, undefined, undefined, { context: 0 } );
+function prepareSearch( searchRegEx, context ) {
+	const pattern = searchRegEx.xregexp.source;
+	const placeholderMap = {
+		now: ( format ) => {
+			if ( _.isNil( format ) ) {
+				throw new Error( "Missing required parameter 'format' for placeholder {{now}}" );
+			}
+			return XRegExp.escape( dateFormat( context.executionTime, format ) );
+		},
+		semver: `${semanticVersionRegex.xregexp.source || semanticVersionRegex.source}`,
+	};
+	const parsedVer = semver.parse( context.latestVersion );
+	if ( parsedVer ) {
+		Object.assign( placeholderMap, {
+			version: XRegExp.escape( parsedVer.raw ),
+			major: parsedVer.major,
+			minor: parsedVer.minor,
+			patch: parsedVer.patch,
+			prerelease: XRegExp.escape( parsedVer.prerelease.join( '.' ) ),
+			prefixedPrerelease:
+				parsedVer.prerelease.length > 0
+					? XRegExp.escape( prereleasePrefix + parsedVer.prerelease.join( '.' ) )
+					: '',
+			build: XRegExp.escape( parsedVer.build.join( '.' ) ),
+			prefixedBuild:
+				parsedVer.build.length > 0 ? XRegExp.escape( buildPrefix + parsedVer.build.join( '.' ) ) : '',
+			versionWithoutBuild: XRegExp.escape( parsedVer.version ),
+			versionWithoutPrerelease: XRegExp.escape( `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}` ),
+		} );
+	}
+	if ( context.latestTag ) {
+		Object.assign( placeholderMap, { tag: XRegExp.escape( context.latestTag ) } );
+	}
 
-	if ( _.isEmpty( diffResult.hunks ) ) {
-		warnNoFileChange.call( this, filePath );
+	if ( context.version ) {
+		Object.assign( placeholderMap, { newVersion: XRegExp.escape( context.version ) } );
 	}
-	diffResult.hunks.forEach( hunk => {
-		this.log.exec( `Replacing at line ${hunk.oldStart}:\n` + hunk.lines.map( line => {
-			const lineText = '\t' + line;
-			if ( line.startsWith( '-' ) ) {
-				return chalk.red( lineText );
-			}
-			if ( line.startsWith( '+' ) ) {
-				return chalk.green( lineText );
-			}
-			return lineText;
-		} ).join( '\n' ), { isDryRun } );
-	} );
 
+	wrapSearchPatternPlaceholders( placeholderMap );
+	const replacedPattern = replacePlaceholders( pattern, placeholderMap );
+	return XRegExp( replacedPattern, searchRegEx.xregexp.flags || undefined );
 }
 
-function searchAndReport( content, searchRegex, filePath ) {
-	const { isDryRun } = this.config;
-	let foundMatch = false;
-	const lineCounter = new LineCounter( content );
-	XRegExp.forEach( content, searchRegex, ( match ) => {
-		const matchText = match[ 0 ];
-		const matchIndex = searchRegex.lastIndex - matchText.length;
-		this.log.exec( `Replacing match at line ${lineCounter.lineOfIndex( matchIndex )}, column ${lineCounter.columnOfIndex( matchIndex )}:\n\t` + matchText, { isDryRun } );
-		foundMatch = true;
-	} );
-	if ( !foundMatch ) {
-		warnNoFileChange.call( this, filePath );
+function wrapSearchPatternPlaceholders( placeholderMap ) {
+	for ( const placeholder of Object.keys( placeholderMap ) ) {
+		// object injection mitigated for placeholderMap since placeholder is from Object.keys( placeholderMap )
+		// eslint-disable-next-line security/detect-object-injection
+		const replacement = placeholderMap[ placeholder ];
+		if ( _.isFunction( replacement ) ) {
+			// eslint-disable-next-line security/detect-object-injection
+			placeholderMap[ placeholder ] = ( ...args ) => {
+				return wrapInRegexGroup( replacement( ...args ) );
+			};
+			continue;
+		}
+		// eslint-disable-next-line security/detect-object-injection
+		placeholderMap[ placeholder ] = wrapInRegexGroup( replacement );
 	}
 }
 
-function warnNoFileChange( filePath ) {
-	this.log.warn( `File "${filePath}" did not change!` );
+function wrapInRegexGroup( pattern ) {
+	return `(?:${pattern})`;
 }
 
 function replaceVersion( content, searchRegex, replace, context ) {
-	const processedReplace = prepareReplacement.call( this, replace, context );
+	const processedReplace = prepareReplacement( replace, context );
 	const processedContent = XRegExp.replace( content, searchRegex, processedReplace );
 	return processedContent;
 }
 
 function prepareReplacement( replace, context ) {
-	const placeholderRegex = XRegExp( /\{\{(?<placeholder>(?:[a-z][a-z0-9_]*|\{))(?::(?<format>.*))?\}\}/ig );
-	const now = new Date();
 	const parsedVer = semver.parse( context.version );
 	const placeholderMap = {
-		'{': '{',
-		'version': parsedVer.raw,
-		'major': parsedVer.major,
-		'minor': parsedVer.minor,
-		'patch': parsedVer.patch,
-		'prerelease': parsedVer.prerelease.join( '.' ),
-		'build': parsedVer.build.join( '.' ),
-		'versionWithoutBuild': parsedVer.version,
-		'versionWithoutPrerelease': `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}`,
-		'latestVersion': context.latestVersion,
-		'latestTag': context.latestTag,
-		'now': ( format ) => {
-			if( _.isNil( format ) ) {
-				return dateFormatIso( now );
+		version: parsedVer.raw,
+		major: parsedVer.major,
+		minor: parsedVer.minor,
+		patch: parsedVer.patch,
+		prerelease: parsedVer.prerelease.join( '.' ),
+		prefixedPrerelease:
+			parsedVer.prerelease.length > 0 ? prereleasePrefix + parsedVer.prerelease.join( '.' ) : '',
+		build: parsedVer.build.join( '.' ),
+		prefixedBuild: parsedVer.build.length > 0 ? buildPrefix + parsedVer.build.join( '.' ) : '',
+		versionWithoutBuild: parsedVer.version,
+		versionWithoutPrerelease: `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}`,
+		latestVersion: context.latestVersion || '',
+		latestTag: context.latestTag || '',
+		now: ( format ) => {
+			if ( _.isNil( format ) ) {
+				return dateFormatIso( context.executionTime );
 			}
-			return dateFormat( now, format );
-		}
+			return dateFormat( context.executionTime, format );
+		},
 	};
-	return XRegExp.replace( replace, placeholderRegex, ( match, placeholder, format ) => {
-		const placeholderReplace = placeholderMap.hasOwnProperty( placeholder) ? placeholderMap[ placeholder ] : undefined;
-		if ( _.isFunction( placeholderReplace ) ) {
+	return replacePlaceholders( replace, placeholderMap );
+}
+
+function replacePlaceholders( template, placeholderMap ) {
+	placeholderMap = Object.assign( {}, placeholderMap, { '{': '{' } );
+	return XRegExp.replace( template, placeholderRegex, ( match, placeholder, format ) => {
+		if ( !hasOwnProperty( placeholderMap, placeholder ) ) {
+			throw new Error( `Unknown placeholder encountered: {{${placeholder}}}` );
+		}
+		// object injection mitigated by checking hasOwnProperty()
+		// eslint-disable-next-line security/detect-object-injection
+		const replacement = placeholderMap[ placeholder ];
+		if ( _.isFunction( replacement ) ) {
 			if ( _.isString( format ) ) {
-				return placeholderReplace( format );
+				return replacement( format );
 			}
-			return placeholderReplace();
+			return replacement();
 		}
-		return placeholderReplace;
+		return replacement;
 	} );
 }
 
-
 function optionalRequire( packageName ) {
 	try {
+		// eslint-disable-next-line security/detect-non-literal-require
 		return require( packageName );
 	}
+	/* c8 ignore next 4 */
+	/* rewiremock can't simulate the absence of a package so we can't test this case */
 	catch ( ex ) {
 		return ex;
 	}
 }
 
 function firstNotNil( ...args ) {
-	return args.find( ele => !_.isNil( ele ) );
+	return args.find( ( ele ) => !_.isNil( ele ) );
 }
 
 class LineCounter {
 	constructor( text ) {
 		let index = 0;
-		this.lineEndIndex = text.split( '\n' ).map( line => {
+		this.lineEndIndex = text.split( '\n' ).map( ( line ) => {
 			index += line.length + 1;
 			return index;
 		} );
 	}
 
 	lineOfIndex( index ) {
-		const arrayIndex = this.lineEndIndex.findIndex( lineEndIndex => ( index <= lineEndIndex ) );
+		// eslint-disable-next-line no-extra-parens
+		const arrayIndex = this.lineEndIndex.findIndex( ( lineEndIndex ) => index <= lineEndIndex );
 		assert( arrayIndex >= 0 );
 		return arrayIndex + 1;
 	}
 
 	columnOfIndex( index ) {
-		const line = this.lineOfIndex( index );
-		assert( line >= 1 );
-		if ( line === 1 ) {
+		const lineNumber = this.lineOfIndex( index );
+		assert( lineNumber >= 1 );
+		if ( lineNumber === 1 ) {
 			return index;
 		}
-		const previousLineEndIndex = this.lineEndIndex[ line - 2 ];
+		const previousLineNumber = lineNumber - 1;
+		const previousLineEndIndex = this.lineEndIndex[ previousLineNumber - 1 ];
 		return index - previousLineEndIndex;
 	}
 }

package/package.json

@@ -1,11 +1,15 @@
 {
 	"name": "@j-ulrich/release-it-regex-bumper",
-	"version": "2.0.0",
+	"version": "3.0.2",
 	"description": "Regular expression based version read/write plugin for release-it",
 	"main": "index.js",
+	"files": [
+		"index.js"
+	],
 	"scripts": {
 		"test": "npx bron test.js",
 		"test+coverage": "npx c8 npx bron test.js",
+		"lint": "npx eslint .",
 		"release": "npx release-it"
 	},
 	"keywords": [
@@ -48,12 +52,17 @@
 		"diff": "^3.0.0 || ^4.0.0"
 	},
 	"devDependencies": {
+		"@j-ulrich/eslint-config": "^1.0.0",
+		"@release-it/keep-a-changelog": "^2.5.0",
 		"bron": "^1.1.0",
 		"c8": "^7.3.0",
-		"mock-fs": "^4.13.0",
+		"eslint": "^8.6.0",
+		"eslint-plugin-security": "^1.4.0",
+		"mock-fs": "^5.1.1",
 		"release-it": "^14.0.0",
 		"rewiremock": "^3.14.3",
-		"sinon": "^9.0.3"
+		"sinon": "^9.0.3",
+		"temp": "^0.9.4"
 	},
 	"engines": {
 		"node": ">=10.12.0"

package/.github/workflows/CI.yml

@@ -1,64 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: CI
-
-on: [ push, pull_request ]
-
-jobs:
-    compatibility-test-node:
-        name: Test Node Version Compatibility
-        runs-on: ubuntu-latest
-
-        strategy:
-            matrix:
-                node-version: [ 10.x, 12.x ]
-
-        steps:
-        - uses: actions/checkout@v2
-        - name: Use Node.js ${{ matrix.node-version }}
-          uses: actions/setup-node@v1
-          with:
-              node-version: ${{ matrix.node-version }}
-        - run: npm ci
-        - run: npm install release-it
-        - run: npm run build --if-present
-        - run: npm run test
-
-    compatibility-test-release:
-        name: Test Release-it Version Compatibility
-        runs-on: ubuntu-latest
-
-        strategy:
-            matrix:
-                release-it-version: [ 11.x, 12.x, 13.x, 14.x ]
-
-        steps:
-        - uses: actions/checkout@v2
-        - uses: actions/setup-node@v1
-          with:
-              node-version: 14.x
-        - run: npm ci
-        - run: npm install release-it@${{ matrix.release-it-version }}
-        - run: npm run build --if-present
-        - run: npm run test
-
-    coverage:
-        name: Coverage
-        runs-on: ubuntu-latest
-
-        steps:
-        - uses: actions/checkout@v2
-        - uses: actions/setup-node@v1
-          with:
-              node-version: 14.x
-        - run: npm ci
-        - run: npm install release-it
-        - run: npm run build --if-present
-        - run: npm run test+coverage
-        - run: npx c8 report --reporter lcov
-        - name: Upload coverage to Codacy
-          uses: codacy/codacy-coverage-reporter-action@v1
-          with:
-              project-token: ${{ secrets.CODACY_PROJECT_TOKEN }}
-              coverage-reports: coverage/lcov.info

package/.gitignore

@@ -1,6 +0,0 @@
-coverage/
-.*
-!.github
-!.gitignore
-!.release-it.json
-node_modules/