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

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2021 Jochen Ulrich
+Copyright (c) 2020-2022 Jochen Ulrich
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -3,8 +3,8 @@
 > Regular expression based version read/write plugin for release-it
 
 ![CI](https://github.com/j-ulrich/release-it-regex-bumper/workflows/CI/badge.svg)
-[![Test Coverage](https://app.codacy.com/project/badge/Coverage/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/manual/j-ulrich/release-it-regex-bumper?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Coverage)
-[![Code Quality](https://app.codacy.com/project/badge/Grade/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/manual/j-ulrich/release-it-regex-bumper?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Grade)
+[![Test Coverage](https://app.codacy.com/project/badge/Coverage/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/gh/j-ulrich/release-it-regex-bumper/dashboard?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Coverage)
+[![Code Quality](https://app.codacy.com/project/badge/Grade/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/gh/j-ulrich/release-it-regex-bumper/dashboard?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Grade)
 
 This [release-it](https://github.com/release-it/release-it) plugin reads and/or writes versions
 using regular expressions.
@@ -48,7 +48,7 @@ For example:
 }
 ```
 
-For a more complex example, see [.release-it.json](.release-it.json).
+For a more complex example, see [here](https://gitlab.com/julrich/MockNetworkAccessManager/-/blob/main/.release-it.json).
 
 
 ## Regular Expressions ##
@@ -421,9 +421,18 @@ encodings are the ones supported by Node's `fs` module.
 
 If this option is not defined or set to `null`, the default value is used.
 
+## Tips ##
+
+### Disable Output via Command-Line Parameter ###
+To completely disable changing any files by the plugin, you can use the command-line parameter `--no-plugins.@j-ulrich/release-it-regex-bumper.out`.
+For example:
+```
+npx release-it --no-plugins.@j-ulrich/release-it-regex-bumper.out
+```
+
 
 # License #
 
-Copyright (c) 2020-2021 Jochen Ulrich
+Copyright (c) 2020-2022 Jochen Ulrich
 
 Licensed under [MIT license](LICENSE).

package/index.js

@@ -1,3 +1,5 @@
+'use strict';
+
 const fs = require( 'fs' );
 const assert = require( 'assert' ).strict;
 const util = require( 'util' );
@@ -9,7 +11,7 @@ const _ = {
 	isNull: require( 'lodash/isNull' ),
 	isString: require( 'lodash/isString' ),
 	isFunction: require( 'lodash/isFunction' ),
-	castArray: require( 'lodash/castArray' )
+	castArray: require( 'lodash/castArray' ),
 };
 const XRegExp = require( 'xregexp' );
 const semver = require( 'semver' );
@@ -22,7 +24,10 @@ const diff = optionalRequire( 'diff' );
 const readFile = util.promisify( fs.readFile );
 const writeFile = util.promisify( fs.writeFile );
 
-const semanticVersionRegex = 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 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 = '-';
@@ -37,36 +42,49 @@ const defaultReplace = '{{version}}';
 
 class RegExBumper extends Plugin {
 
-	constructor(...args) {
-		super(...args);
-		this.setContext({executionTime: new Date()});
+	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 context = Object.assign( {}, this.getContext(), this.config.contextOptions );
 
-		const { searchRegex: globalSearchRegex, flags: globalSearchFlags, versionCaptureGroup: globalVersionCaptureGroup } = parseSearchOptions.call( this, globalSearchOptions );
-		const { file, encoding, searchRegex, flags: searchFlags, versionCaptureGroup } = parseInOptions.call( this, inOptions );
+		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 effectiveSearchRegex = mergeSearchRegExes( [searchRegex, globalSearchRegex, defaultSearchRegex], [searchFlags, globalSearchFlags] );
+		const effectiveSearchRegex = mergeSearchRegExes(
+			[ searchRegex, globalSearchRegex, defaultSearchRegex ],
+			[ searchFlags, globalSearchFlags ]
+		);
 		const replacedSearchRegex = prepareSearch( effectiveSearchRegex, context );
-		const version = await extractVersion.call( this, fileContent, replacedSearchRegex,
-			firstNotNil( versionCaptureGroup, globalVersionCaptureGroup, defaultVersionCaptureGroup ) );
+		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;
@@ -76,15 +94,21 @@ class RegExBumper extends Plugin {
 			context.version = version;
 		}
 
-		const { searchRegex: globalSearchRegex, flags: globalSearchFlags } = 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, flags: searchFlags, 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 = mergeSearchRegExes( [searchRegex, globalSearchRegex, defaultSearchRegex], [searchFlags, globalSearchFlags] );
+			const effectiveSearchRegex = mergeSearchRegExes(
+				[ searchRegex, globalSearchRegex, defaultSearchRegex ],
+				[ searchFlags, globalSearchFlags ]
+			);
 			const effectiveReplacement = firstNotNil( replace, globalReplace, defaultReplace );
 
 			const replacedSearchRegex = prepareSearch( effectiveSearchRegex, context );
@@ -96,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, replacedSearchRegex, 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, replacedSearchRegex, file );
+					await this.searchAndReport( fileContent, replacedSearchRegex, file );
 					continue;
 				}
 
-				const processedFileContent = replaceVersion.call( this, fileContent, replacedSearchRegex, 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!` );
 	}
 
 }
@@ -146,7 +240,7 @@ function parseSearchOptions( options ) {
 		return { searchRegex, versionCaptureGroup };
 	}
 	const { pattern, flags, versionCaptureGroup } = options;
-	const searchRegex = _.isNil(pattern) ? pattern : XRegExp( pattern, _.isNull( flags ) ? undefined : flags );
+	const searchRegex = _.isNil( pattern ) ? pattern : XRegExp( pattern, _.isNull( flags ) ? undefined : flags );
 	return { searchRegex, flags, versionCaptureGroup };
 }
 
@@ -156,22 +250,22 @@ function extractVersion( content, versionRegex, versionCaptureGroup ) {
 		throw new Error( 'Could not extract version from file' );
 	}
 	if ( !_.isNil( versionCaptureGroup ) ) {
-		if( hasOwnProperty( match, versionCaptureGroup ) ) {
+		if ( hasOwnProperty( match, versionCaptureGroup ) ) {
 			// object injection mitigated by checking hasOwnProperty()
 			// eslint-disable-next-line security/detect-object-injection
-			return match[ versionCaptureGroup ];
+			return match[versionCaptureGroup];
 		}
 	}
 	else {
 		if ( hasOwnProperty( match, 'version' ) ) {
-			return match[ 'version' ];
+			return match['version'];
 		}
 		if ( hasOwnProperty( match, 1 ) ) {
-			return match[ 1 ];
+			return match[1];
 		}
 	}
 
-	return match[ 0 ];
+	return match[0];
 }
 
 function hasOwnProperty( obj, prop ) {
@@ -179,20 +273,20 @@ function hasOwnProperty( 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, flags } = 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, flags, replace };
 	} );
@@ -215,55 +309,6 @@ 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 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 ) ) {
-		warnNoFileChange.call( this, 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 } );
-	} );
-
-}
-
-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 warnNoFileChange( filePath ) {
-	this.log.warn( `File "${filePath}" did not change!` );
-}
-
 function mergeSearchRegExes( regExCandidates, flagCandidates ) {
 	const searchRegEx = firstNotNil( ...regExCandidates );
 	const flags = firstNotNil( ...flagCandidates );
@@ -273,36 +318,39 @@ function mergeSearchRegExes( regExCandidates, flagCandidates ) {
 function prepareSearch( searchRegEx, context ) {
 	const pattern = searchRegEx.xregexp.source;
 	const placeholderMap = {
-		'now': ( format ) => {
-			if( _.isNil( format ) ) {
+		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}`
+		semver: `${semanticVersionRegex.xregexp.source || semanticVersionRegex.source}`,
 	};
 	const parsedVer = semver.parse( context.latestVersion );
-	if( parsedVer ) {
+	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}` ),
-
+			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 ) } );
+		Object.assign( placeholderMap, { tag: XRegExp.escape( context.latestTag ) } );
 	}
 
 	if ( context.version ) {
-		Object.assign( placeholderMap, { 'newVersion': XRegExp.escape( context.version ) } );
+		Object.assign( placeholderMap, { newVersion: XRegExp.escape( context.version ) } );
 	}
 
 	wrapSearchPatternPlaceholders( placeholderMap );
@@ -311,11 +359,11 @@ function prepareSearch( searchRegEx, context ) {
 }
 
 function wrapSearchPatternPlaceholders( placeholderMap ) {
-	for( const placeholder of Object.keys( 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 ) ) {
+		if ( _.isFunction( replacement ) ) {
 			// eslint-disable-next-line security/detect-object-injection
 			placeholderMap[ placeholder ] = ( ...args ) => {
 				return wrapInRegexGroup( replacement( ...args ) );
@@ -332,7 +380,7 @@ function wrapInRegexGroup( 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;
 }
@@ -340,24 +388,25 @@ function replaceVersion( content, searchRegex, replace, context ) {
 function prepareReplacement( replace, context ) {
 	const parsedVer = semver.parse( context.version );
 	const placeholderMap = {
-		'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 ) ) {
+		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( context.executionTime, format );
-		}
+		},
 	};
 	return replacePlaceholders( replace, placeholderMap );
 }
@@ -381,7 +430,6 @@ function replacePlaceholders( template, placeholderMap ) {
 	} );
 }
 
-
 function optionalRequire( packageName ) {
 	try {
 		// eslint-disable-next-line security/detect-non-literal-require
@@ -395,20 +443,21 @@ function optionalRequire( packageName ) {
 }
 
 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;
 	}

package/package.json

@@ -1,8 +1,11 @@
 {
 	"name": "@j-ulrich/release-it-regex-bumper",
-	"version": "3.0.1",
+	"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",
@@ -49,14 +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",
-		"eslint": "^8.0.1",
+		"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,76 +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, 14.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: 16.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: 16.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
-
-    lint:
-        name: Lint
-        runs-on: ubuntu-latest
-
-        steps:
-        - uses: actions/checkout@v2
-        - uses: actions/setup-node@v1
-          with:
-              node-version: 16.x
-        - run: npm ci
-        - run: npm run lint

package/.gitignore

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